# Copyright (c) 2013 Peter Zotov # # Parts of the source are derived from ruby_parser: # Copyright (c) Ryan Davis, seattle.rb # # MIT License # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. class Parser::Ruby18 token 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 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 tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT tREGEXP_END tUPLUS tUMINUS tUMINUS_NUM tPOW tCMP tEQ tEQQ tNEQ tGEQ tLEQ tANDOP tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF tASET tLSHFT tRSHFT tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN tLPAREN2 tRPAREN tLPAREN_ARG tLBRACK tLBRACK2 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 tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING tSYMBOL tREGEXP_OPT tNL tEH tCOLON tCOMMA tSPACE tSEMI prechigh right tBANG tTILDE tUPLUS right tPOW right tUMINUS_NUM tUMINUS left tSTAR2 tDIVIDE tPERCENT left tPLUS tMINUS left tLSHFT tRSHFT left tAMPER2 left tPIPE tCARET left tGT tGEQ tLT tLEQ nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH left tANDOP left tOROP nonassoc tDOT2 tDOT3 right tEH tCOLON left kRESCUE_MOD right tEQL tOP_ASGN nonassoc kDEFINED right kNOT left kOR kAND nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD nonassoc tLBRACE_ARG nonassoc tLOWEST preclow rule program: compstmt { result = val[0] } bodystmt: compstmt opt_rescue opt_else opt_ensure { rescue_bodies = val[1] else_t, else_ = val[2] ensure_t, ensure_ = val[3] if rescue_bodies.empty? && !else_.nil? diagnostic :warning, :useless_else, nil, else_t end result = @builder.begin_body(val[0], rescue_bodies, else_t, else_, ensure_t, ensure_) } compstmt: stmts opt_terms { result = @builder.compstmt(val[0]) } stmts: # nothing { result = [] } | stmt { result = [ val[0] ] } | error stmt { result = [ val[1] ] } | stmts terms stmt { result = val[0] << val[2] } stmt: kALIAS fitem { @lexer.state = :expr_fname } fitem { result = @builder.alias(val[0], val[1], val[3]) } | kALIAS tGVAR tGVAR { result = @builder.alias(val[0], @builder.gvar(val[1]), @builder.gvar(val[2])) } | kALIAS tGVAR tBACK_REF { result = @builder.alias(val[0], @builder.gvar(val[1]), @builder.back_ref(val[2])) } | kALIAS tGVAR tNTH_REF { diagnostic :error, :nth_ref_alias, nil, val[2] } | kUNDEF undef_list { result = @builder.undef_method(val[0], val[1]) } | stmt kIF_MOD expr_value { result = @builder.condition_mod(val[0], nil, val[1], val[2]) } | stmt kUNLESS_MOD expr_value { result = @builder.condition_mod(nil, val[0], val[1], val[2]) } | stmt kWHILE_MOD expr_value { result = @builder.loop_mod(:while, val[0], val[1], val[2]) } | stmt kUNTIL_MOD expr_value { result = @builder.loop_mod(:until, val[0], val[1], val[2]) } | stmt kRESCUE_MOD stmt { rescue_body = @builder.rescue_body(val[1], nil, nil, nil, nil, val[2]) result = @builder.begin_body(val[0], [ rescue_body ]) } | klBEGIN tLCURLY compstmt tRCURLY { if in_def? diagnostic :error, :begin_in_method, nil, val[0] end result = @builder.preexe(val[0], val[1], val[2], val[3]) } | klEND tLCURLY compstmt tRCURLY { result = @builder.postexe(val[0], val[1], val[2], val[3]) } | lhs tEQL command_call { result = @builder.assign(val[0], val[1], val[2]) } | mlhs tEQL command_call { result = @builder.multi_assign(val[0], val[1], val[2]) } | var_lhs tOP_ASGN command_call { result = @builder.op_assign(val[0], val[1], val[2]) } | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN command_call { result = @builder.op_assign( @builder.index( val[0], val[1], val[2], val[3]), val[4], val[5]) } | primary_value tDOT tIDENTIFIER tOP_ASGN command_call { result = @builder.op_assign( @builder.call_method( val[0], val[1], val[2]), val[3], val[4]) } | primary_value tDOT tCONSTANT tOP_ASGN command_call { result = @builder.op_assign( @builder.call_method( val[0], val[1], val[2]), val[3], val[4]) } | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call { result = @builder.op_assign( @builder.call_method( val[0], val[1], val[2]), val[3], val[4]) } | backref tOP_ASGN command_call { @builder.op_assign(val[0], val[1], val[2]) } | lhs tEQL mrhs { result = @builder.assign(val[0], val[1], @builder.array(nil, val[2], nil)) } | mlhs tEQL arg_value { result = @builder.multi_assign(val[0], val[1], val[2]) } | mlhs tEQL mrhs { result = @builder.multi_assign(val[0], val[1], @builder.array(nil, val[2], nil)) } | expr expr: command_call | expr kAND expr { result = @builder.logical_op(:and, val[0], val[1], val[2]) } | expr kOR expr { result = @builder.logical_op(:or, val[0], val[1], val[2]) } | kNOT expr { result = @builder.not_op(val[0], nil, val[1], nil) } | tBANG command_call { result = @builder.not_op(val[0], nil, val[1], nil) } | arg expr_value: expr command_call: command | block_command | kRETURN call_args { result = @builder.keyword_cmd(:return, val[0], nil, val[1], nil) } | kBREAK call_args { result = @builder.keyword_cmd(:break, val[0], nil, val[1], nil) } | kNEXT call_args { result = @builder.keyword_cmd(:next, val[0], nil, val[1], nil) } block_command: block_call | block_call tDOT operation2 command_args { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } | block_call tCOLON2 operation2 command_args { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } cmd_brace_block: tLBRACE_ARG { @static_env.extend_dynamic } opt_block_var compstmt tRCURLY { result = [ val[0], val[2], val[3], val[4] ] @static_env.unextend } command: operation command_args =tLOWEST { lparen_t, args, rparen_t = val[1] result = @builder.call_method(nil, nil, val[0], lparen_t, args, rparen_t) } | operation command_args cmd_brace_block { lparen_t, args, rparen_t = val[1] method_call = @builder.call_method(nil, nil, val[0], lparen_t, args, rparen_t) begin_t, block_args, body, end_t = val[2] result = @builder.block(method_call, begin_t, block_args, body, end_t) } | primary_value tDOT operation2 command_args =tLOWEST { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } | primary_value tDOT operation2 command_args cmd_brace_block { lparen_t, args, rparen_t = val[3] method_call = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) begin_t, block_args, body, end_t = val[4] result = @builder.block(method_call, begin_t, block_args, body, end_t) } | primary_value tCOLON2 operation2 command_args =tLOWEST { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } | primary_value tCOLON2 operation2 command_args cmd_brace_block { lparen_t, args, rparen_t = val[3] method_call = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) begin_t, block_args, body, end_t = val[4] result = @builder.block(method_call, begin_t, block_args, body, end_t) } | kSUPER command_args { lparen_t, args, rparen_t = val[1] result = @builder.keyword_cmd(:super, val[0], lparen_t, args, rparen_t) } | kYIELD command_args { lparen_t, args, rparen_t = val[1] result = @builder.keyword_cmd(:yield, val[0], lparen_t, args, rparen_t) } mlhs: mlhs_basic { result = @builder.multi_lhs(nil, val[0], nil) } | tLPAREN mlhs_entry tRPAREN { result = @builder.begin(val[0], val[1], val[2]) } mlhs_entry: mlhs_basic { result = @builder.multi_lhs(nil, val[0], nil) } | tLPAREN mlhs_entry tRPAREN { result = @builder.multi_lhs(val[0], val[1], val[2]) } mlhs_basic: mlhs_head { result = val[0] } | mlhs_head mlhs_item { result = val[0] << val[1] } | mlhs_head tSTAR mlhs_node { result = val[0] << @builder.splat(val[1], val[2]) } | mlhs_head tSTAR { result = val[0] << @builder.splat(val[1]) } | tSTAR mlhs_node { result = [ @builder.splat(val[0], val[1]) ] } | tSTAR { result = [ @builder.splat(val[0]) ] } mlhs_item: mlhs_node | tLPAREN mlhs_entry tRPAREN { result = @builder.begin(val[0], val[1], val[2]) } mlhs_head: mlhs_item tCOMMA { result = [ val[0] ] } | mlhs_head mlhs_item tCOMMA { result = val[0] << val[1] } mlhs_node: variable { result = @builder.assignable(val[0]) } | primary_value tLBRACK2 aref_args tRBRACK { result = @builder.index_asgn(val[0], val[1], val[2], val[3]) } | primary_value tDOT tIDENTIFIER { result = @builder.attr_asgn(val[0], val[1], val[2]) } | primary_value tCOLON2 tIDENTIFIER { result = @builder.attr_asgn(val[0], val[1], val[2]) } | primary_value tDOT tCONSTANT { result = @builder.attr_asgn(val[0], val[1], val[2]) } | primary_value tCOLON2 tCONSTANT { result = @builder.assignable( @builder.const_fetch(val[0], val[1], val[2])) } | tCOLON3 tCONSTANT { result = @builder.assignable( @builder.const_global(val[0], val[1])) } | backref { result = @builder.assignable(val[0]) } lhs: variable { result = @builder.assignable(val[0]) } | primary_value tLBRACK2 aref_args tRBRACK { result = @builder.index_asgn(val[0], val[1], val[2], val[3]) } | primary_value tDOT tIDENTIFIER { result = @builder.attr_asgn(val[0], val[1], val[2]) } | primary_value tCOLON2 tIDENTIFIER { result = @builder.attr_asgn(val[0], val[1], val[2]) } | primary_value tDOT tCONSTANT { result = @builder.attr_asgn(val[0], val[1], val[2]) } | primary_value tCOLON2 tCONSTANT { result = @builder.assignable( @builder.const_fetch(val[0], val[1], val[2])) } | tCOLON3 tCONSTANT { result = @builder.assignable( @builder.const_global(val[0], val[1])) } | backref { result = @builder.assignable(val[0]) } cname: tIDENTIFIER { diagnostic :error, :module_name_const, nil, val[0] } | tCONSTANT cpath: tCOLON3 cname { result = @builder.const_global(val[0], val[1]) } | cname { result = @builder.const(val[0]) } | primary_value tCOLON2 cname { result = @builder.const_fetch(val[0], val[1], val[2]) } fname: tIDENTIFIER | tCONSTANT | tFID | op | reswords fsym: fname { result = @builder.symbol(val[0]) } | symbol fitem: fsym | dsym undef_list: fitem { result = [ val[0] ] } | undef_list tCOMMA { @lexer.state = :expr_fname } fitem { result = val[0] << val[3] } op: tPIPE | tCARET | tAMPER2 | tCMP | tEQ | tEQQ | tMATCH | tGT | tGEQ | tLT | tLEQ | tLSHFT | tRSHFT | tPLUS | tMINUS | tSTAR2 | tSTAR | tDIVIDE | tPERCENT | tPOW | tTILDE | tUPLUS | tUMINUS | tAREF | tASET | tBACK_REF2 reswords: k__LINE__ | k__FILE__ | klBEGIN | klEND | kALIAS | kAND | kBEGIN | kBREAK | kCASE | kCLASS | kDEF | kDEFINED | kDO | kELSE | kELSIF | kEND | kENSURE | kFALSE | kFOR | kIN | kMODULE | kNEXT | kNIL | kNOT | kOR | kREDO | kRESCUE | kRETRY | kRETURN | kSELF | kSUPER | kTHEN | kTRUE | kUNDEF | kWHEN | kYIELD | kIF | kUNLESS | kWHILE | kUNTIL arg: lhs tEQL arg { result = @builder.assign(val[0], val[1], val[2]) } | lhs tEQL arg kRESCUE_MOD arg { rescue_body = @builder.rescue_body(val[3], nil, nil, nil, nil, val[4]) rescue_ = @builder.begin_body(val[2], [ rescue_body ]) result = @builder.assign(val[0], val[1], rescue_) } | var_lhs tOP_ASGN arg { result = @builder.op_assign(val[0], val[1], val[2]) } | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN arg { result = @builder.op_assign( @builder.index( val[0], val[1], val[2], val[3]), val[4], val[5]) } | primary_value tDOT tIDENTIFIER tOP_ASGN arg { result = @builder.op_assign( @builder.call_method( val[0], val[1], val[2]), val[3], val[4]) } | primary_value tDOT tCONSTANT tOP_ASGN arg { result = @builder.op_assign( @builder.call_method( val[0], val[1], val[2]), val[3], val[4]) } | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg { result = @builder.op_assign( @builder.call_method( val[0], val[1], val[2]), val[3], val[4]) } | primary_value tCOLON2 tCONSTANT tOP_ASGN arg { diagnostic :error, :dynamic_const, nil, val[2], [ val[3] ] } | tCOLON3 tCONSTANT tOP_ASGN arg { diagnostic :error, :dynamic_const, nil, val[1], [ val[2] ] } | backref tOP_ASGN arg { result = @builder.op_assign(val[0], val[1], val[2]) } | arg tDOT2 arg { result = @builder.range_inclusive(val[0], val[1], val[2]) } | arg tDOT3 arg { result = @builder.range_exclusive(val[0], val[1], val[2]) } | arg tPLUS arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tMINUS arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tSTAR2 arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tDIVIDE arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tPERCENT arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tPOW arg { result = @builder.binary_op(val[0], val[1], val[2]) } | tUMINUS_NUM tINTEGER tPOW arg { result = @builder.unary_op(val[0], @builder.binary_op( @builder.integer(val[1]), val[2], val[3])) } | tUMINUS_NUM tFLOAT tPOW arg { result = @builder.unary_op(val[0], @builder.binary_op( @builder.float(val[1]), val[2], val[3])) } | tUPLUS arg { result = @builder.unary_op(val[0], val[1]) } | tUMINUS arg { result = @builder.unary_op(val[0], val[1]) } | arg tPIPE arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tCARET arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tAMPER2 arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tCMP arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tGT arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tGEQ arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tLT arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tLEQ arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tEQ arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tEQQ arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tNEQ arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tMATCH arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tNMATCH arg { result = @builder.binary_op(val[0], val[1], val[2]) } | tBANG arg { result = @builder.not_op(val[0], nil, val[1], nil) } | tTILDE arg { result = @builder.unary_op(val[0], val[1]) } | arg tLSHFT arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tRSHFT arg { result = @builder.binary_op(val[0], val[1], val[2]) } | arg tANDOP arg { result = @builder.logical_op(:and, val[0], val[1], val[2]) } | arg tOROP arg { result = @builder.logical_op(:or, val[0], val[1], val[2]) } | kDEFINED opt_nl arg { result = @builder.keyword_cmd(:defined?, val[0], nil, [ val[2] ], nil) } | arg tEH arg tCOLON arg { result = @builder.ternary(val[0], val[1], val[2], val[3], val[4]) } | primary arg_value: arg aref_args: none | command opt_nl { result = [ val[0] ] } | args trailer { result = val[0] } | args tCOMMA tSTAR arg opt_nl { result = val[0] << @builder.splat(val[2], val[3]) } | assocs trailer { result = [ @builder.associate(nil, val[0], nil) ] } | tSTAR arg opt_nl { result = [ @builder.splat(val[0], val[1]) ] } paren_args: tLPAREN2 none tRPAREN { result = [ val[0], [], val[2] ] } | tLPAREN2 call_args opt_nl tRPAREN { result = [ val[0], val[1], val[3] ] } | tLPAREN2 block_call opt_nl tRPAREN { result = [ val[0], [ val[1] ], val[3] ] } | tLPAREN2 args tCOMMA block_call opt_nl tRPAREN { result = [ val[0], val[1] << val[3], val[5] ] } opt_paren_args: # nothing { result = [ nil, [], nil ] } | paren_args call_args: command { result = [ val[0] ] } | args opt_block_arg { result = val[0].concat(val[1]) } | args tCOMMA tSTAR arg_value opt_block_arg { result = val[0].concat( [ @builder.splat(val[2], val[3]), *val[4] ]) } | assocs opt_block_arg { result = [ @builder.associate(nil, val[0], nil), *val[1] ] } | assocs tCOMMA tSTAR arg_value opt_block_arg { result = [ @builder.associate(nil, val[0], nil), @builder.splat(val[2], val[3]), *val[4] ] } | args tCOMMA assocs opt_block_arg { result = val[0].concat( [ @builder.associate(nil, val[2], nil), *val[3] ]) } | args tCOMMA assocs tCOMMA tSTAR arg opt_block_arg { result = val[0].concat( [ @builder.associate(nil, val[2], nil), @builder.splat(val[4], val[5]), *val[6] ]) } | tSTAR arg_value opt_block_arg { result = [ @builder.splat(val[0], val[1]), *val[2] ] } | block_arg { result = [ val[0] ] } call_args2: arg_value tCOMMA args opt_block_arg { result = [ val[0], *val[2].concat(val[3]) ] } | arg_value tCOMMA block_arg { result = [ val[0], val[2] ] } | arg_value tCOMMA tSTAR arg_value opt_block_arg { result = [ val[0], @builder.splat(val[2], val[3]), *val[4] ] } | arg_value tCOMMA args tCOMMA tSTAR arg_value opt_block_arg { result = [ val[0], *val[2]. push(@builder.splat(val[4], val[5])). concat(val[6]) ] } | assocs opt_block_arg { result = [ @builder.associate(nil, val[0], nil), *val[1] ] } | assocs tCOMMA tSTAR arg_value opt_block_arg { result = [ @builder.associate(nil, val[0], nil), @builder.splat(val[2], val[3]), *val[4] ] } | arg_value tCOMMA assocs opt_block_arg { result = [ val[0], @builder.associate(nil, val[2], nil), *val[3] ] } | arg_value tCOMMA args tCOMMA assocs opt_block_arg { result = [ val[0], *val[2]. push(@builder.associate(nil, val[4], nil)). concat(val[5]) ] } | arg_value tCOMMA assocs tCOMMA tSTAR arg_value opt_block_arg { result = [ val[0], @builder.associate(nil, val[2], nil), @builder.splat(val[4], val[5]), *val[6] ] } | arg_value tCOMMA args tCOMMA assocs tCOMMA tSTAR arg_value opt_block_arg { result = [ val[0], *val[2]. push(@builder.associate(nil, val[4], nil)). push(@builder.splat(val[6], val[7])). concat(val[8]) ] } | tSTAR arg_value opt_block_arg { result = [ @builder.splat(val[0], val[1]), *val[2] ] } | block_arg { result = [ val[0] ] } command_args: { result = @lexer.cmdarg.dup @lexer.cmdarg.push(true) } open_args { @lexer.cmdarg = val[0] result = val[1] } open_args: call_args { result = [ nil, val[0], nil ] } | tLPAREN_ARG { @lexer.state = :expr_endarg } tRPAREN { result = [ val[0], [], val[2] ] } | tLPAREN_ARG call_args2 { @lexer.state = :expr_endarg } tRPAREN { result = [ val[0], val[1], val[3] ] } block_arg: tAMPER arg_value { result = @builder.block_pass(val[0], val[1]) } opt_block_arg: tCOMMA block_arg { result = [ val[1] ] } | # nothing { result = [] } args: arg_value { result = [ val[0] ] } | args tCOMMA arg_value { result = val[0] << val[2] } mrhs: args tCOMMA arg_value { result = val[0] << val[2] } | args tCOMMA tSTAR arg_value { result = val[0] << @builder.splat(val[2], val[3]) } | tSTAR arg_value { result = [ @builder.splat(val[0], val[1]) ] } primary: literal | strings | xstring | regexp | words | qwords | var_ref | backref | tFID { result = @builder.call_method(nil, nil, val[0]) } | kBEGIN bodystmt kEND { result = @builder.begin_keyword(val[0], val[1], val[2]) } | tLPAREN_ARG expr { @lexer.state = :expr_endarg } opt_nl tRPAREN { result = @builder.begin(val[0], val[1], val[4]) } | tLPAREN compstmt tRPAREN { result = @builder.begin(val[0], val[1], val[2]) } | primary_value tCOLON2 tCONSTANT { result = @builder.const_fetch(val[0], val[1], val[2]) } | tCOLON3 tCONSTANT { result = @builder.const_global(val[0], val[1]) } | primary_value tLBRACK2 aref_args tRBRACK { result = @builder.index(val[0], val[1], val[2], val[3]) } | tLBRACK aref_args tRBRACK { result = @builder.array(val[0], val[1], val[2]) } | tLBRACE assoc_list tRCURLY { result = @builder.associate(val[0], val[1], val[2]) } | kRETURN { result = @builder.keyword_cmd(:return, val[0]) } | kYIELD tLPAREN2 call_args tRPAREN { result = @builder.keyword_cmd(:yield, val[0], val[1], val[2], val[3]) } | kYIELD tLPAREN2 tRPAREN { result = @builder.keyword_cmd(:yield, val[0], val[1], [], val[2]) } | kYIELD { result = @builder.keyword_cmd(:yield, val[0]) } | kDEFINED opt_nl tLPAREN2 expr tRPAREN { result = @builder.keyword_cmd(:defined?, val[0], val[2], [ val[3] ], val[4]) } | operation brace_block { method_call = @builder.call_method(nil, nil, val[0]) begin_t, args, body, end_t = val[1] result = @builder.block(method_call, begin_t, args, body, end_t) } | method_call | method_call brace_block { begin_t, args, body, end_t = val[1] result = @builder.block(val[0], begin_t, args, body, end_t) } | kIF expr_value then compstmt if_tail kEND { else_t, else_ = val[4] result = @builder.condition(val[0], val[1], val[2], val[3], else_t, else_, val[5]) } | kUNLESS expr_value then compstmt opt_else kEND { else_t, else_ = val[4] result = @builder.condition(val[0], val[1], val[2], else_, else_t, val[3], val[5]) } | kWHILE { @lexer.cond.push(true) } expr_value do { @lexer.cond.pop } compstmt kEND { result = @builder.loop(:while, val[0], val[2], val[3], val[5], val[6]) } | kUNTIL { @lexer.cond.push(true) } expr_value do { @lexer.cond.pop } compstmt kEND { result = @builder.loop(:until, val[0], val[2], val[3], val[5], val[6]) } | kCASE expr_value opt_terms case_body kEND { when_bodies = val[3][0..-2] else_t, else_body = val[3][-1] result = @builder.case(val[0], val[1], when_bodies, else_t, else_body, val[4]) } | kCASE opt_terms case_body kEND { when_bodies = val[2][0..-2] else_t, else_body = val[2][-1] result = @builder.case(val[0], nil, when_bodies, else_t, else_body, val[3]) } | kCASE opt_terms kELSE compstmt kEND { result = @builder.case(val[0], nil, [], val[2], val[3], val[4]) } | kFOR for_var kIN { @lexer.cond.push(true) } expr_value do { @lexer.cond.pop } compstmt kEND { result = @builder.for(val[0], val[1], val[2], val[4], val[5], val[7], val[8]) } | kCLASS cpath superclass { @static_env.extend_static } bodystmt kEND { if in_def? diagnostic :error, :class_in_def, nil, val[0] end lt_t, superclass = val[2] result = @builder.def_class(val[0], val[1], lt_t, superclass, val[4], val[5]) @static_env.unextend } | kCLASS tLSHFT expr term { result = @def_level @def_level = 0 @static_env.extend_static } bodystmt kEND { result = @builder.def_sclass(val[0], val[1], val[2], val[5], val[6]) @static_env.unextend @def_level = val[4] } | kMODULE cpath { @static_env.extend_static } bodystmt kEND { if in_def? diagnostic :error, :module_in_def, nil, val[0] end result = @builder.def_module(val[0], val[1], val[3], val[4]) @static_env.unextend } | kDEF fname { @def_level += 1 @static_env.extend_static } f_arglist bodystmt kEND { result = @builder.def_method(val[0], val[1], val[3], val[4], val[5]) @static_env.unextend @def_level -= 1 } | kDEF singleton dot_or_colon { @lexer.state = :expr_fname } fname { @def_level += 1 @static_env.extend_static } f_arglist bodystmt kEND { result = @builder.def_singleton(val[0], val[1], val[2], val[4], val[6], val[7], val[8]) @static_env.unextend @def_level -= 1 } | kBREAK { result = @builder.keyword_cmd(:break, val[0]) } | kNEXT { result = @builder.keyword_cmd(:next, val[0]) } | kREDO { result = @builder.keyword_cmd(:redo, val[0]) } | kRETRY { result = @builder.keyword_cmd(:retry, val[0]) } primary_value: primary then: term | tCOLON | kTHEN | term kTHEN { result = val[1] } do: term | tCOLON | kDO_COND if_tail: opt_else | kELSIF expr_value then compstmt if_tail { else_t, else_ = val[4] result = [ val[0], @builder.condition(val[0], val[1], val[2], val[3], else_t, else_, nil), ] } opt_else: none | kELSE compstmt { result = val } for_var: lhs | mlhs block_par: mlhs_item { result = [ @builder.arg_expr(val[0]) ] } | block_par tCOMMA mlhs_item { result = val[0] << @builder.arg_expr(val[2]) } block_var: block_par | block_par tCOMMA | block_par tCOMMA tAMPER lhs { result = val[0]. push(@builder.blockarg_expr(val[2], val[3])) } | block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs { result = val[0]. push(@builder.restarg_expr(val[2], val[3])). push(@builder.blockarg_expr(val[5], val[6])) } | block_par tCOMMA tSTAR tCOMMA tAMPER lhs { result = val[0]. push(@builder.restarg_expr(val[2])). push(@builder.blockarg_expr(val[4], val[5])) } | block_par tCOMMA tSTAR lhs { result = val[0]. push(@builder.restarg_expr(val[2], val[3])) } | block_par tCOMMA tSTAR { result = val[0]. push(@builder.restarg_expr(val[2])) } | tSTAR lhs tCOMMA tAMPER lhs { result = [ @builder.restarg_expr(val[0], val[1]), @builder.blockarg_expr(val[3], val[4]) ] } | tSTAR tCOMMA tAMPER lhs { result = [ @builder.restarg_expr(val[0]), @builder.blockarg_expr(val[2], val[3]) ] } | tSTAR lhs { result = [ @builder.restarg_expr(val[0], val[1]) ] } | tSTAR { result = [ @builder.restarg_expr(val[0]) ] } | tAMPER lhs { result = [ @builder.blockarg_expr(val[0], val[1]) ] } ; opt_block_var: # nothing { result = @builder.args(nil, [], nil) } | tPIPE tPIPE { result = @builder.args(val[0], [], val[1]) } | tOROP { result = @builder.args(val[0], [], val[0]) } | tPIPE block_var tPIPE { result = @builder.args(val[0], val[1], val[2], false) } do_block: kDO_BLOCK { @static_env.extend_dynamic } opt_block_var compstmt kEND { result = [ val[0], val[2], val[3], val[4] ] @static_env.unextend } block_call: command do_block { begin_t, block_args, body, end_t = val[1] result = @builder.block(val[0], begin_t, block_args, body, end_t) } | block_call tDOT operation2 opt_paren_args { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } | block_call tCOLON2 operation2 opt_paren_args { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } method_call: operation paren_args { lparen_t, args, rparen_t = val[1] result = @builder.call_method(nil, nil, val[0], lparen_t, args, rparen_t) } | primary_value tDOT operation2 opt_paren_args { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } | primary_value tCOLON2 operation2 paren_args { lparen_t, args, rparen_t = val[3] result = @builder.call_method(val[0], val[1], val[2], lparen_t, args, rparen_t) } | primary_value tCOLON2 operation3 { result = @builder.call_method(val[0], val[1], val[2]) } | kSUPER paren_args { lparen_t, args, rparen_t = val[1] result = @builder.keyword_cmd(:super, val[0], lparen_t, args, rparen_t) } | kSUPER { result = @builder.keyword_cmd(:zsuper, val[0]) } brace_block: tLCURLY { @static_env.extend_dynamic } opt_block_var compstmt tRCURLY { result = [ val[0], val[2], val[3], val[4] ] @static_env.unextend } | kDO { @static_env.extend_dynamic } opt_block_var compstmt kEND { result = [ val[0], val[2], val[3], val[4] ] @static_env.unextend } case_body: kWHEN when_args then compstmt cases { result = [ @builder.when(val[0], val[1], val[2], val[3]), *val[4] ] } when_args: args | args tCOMMA tSTAR arg_value { result = val[0] << @builder.splat(val[2], val[3]) } | tSTAR arg_value { result = [ @builder.splat(val[0], val[1]) ] } cases: opt_else { result = [ val[0] ] } | case_body opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue { assoc_t, exc_var = val[2] if val[1] exc_list = @builder.array(nil, val[1], nil) end result = [ @builder.rescue_body(val[0], exc_list, assoc_t, exc_var, val[3], val[4]), *val[5] ] } | # nothing { result = [] } exc_list: arg_value { result = [ val[0] ] } | mrhs | none exc_var: tASSOC lhs { result = [ val[0], val[1] ] } | none opt_ensure: kENSURE compstmt { result = [ val[0], val[1] ] } | none literal: numeric | symbol | dsym strings: string { result = @builder.string_compose(nil, val[0], nil) } string: string1 { result = [ val[0] ] } | string string1 { result = val[0] << val[1] } string1: tSTRING_BEG string_contents tSTRING_END { result = @builder.string_compose(val[0], val[1], val[2]) } | tSTRING { result = @builder.string(val[0]) } xstring: tXSTRING_BEG xstring_contents tSTRING_END { result = @builder.xstring_compose(val[0], val[1], val[2]) } regexp: tREGEXP_BEG xstring_contents tSTRING_END tREGEXP_OPT { opts = @builder.regexp_options(val[3]) result = @builder.regexp_compose(val[0], val[1], val[2], opts) } words: tWORDS_BEG word_list tSTRING_END { result = @builder.words_compose(val[0], val[1], val[2]) } word_list: # nothing { result = [] } | word_list word tSPACE { result = val[0] << @builder.word(val[1]) } word: string_content { result = [ val[0] ] } | word string_content { result = val[0] << val[1] } qwords: tQWORDS_BEG qword_list tSTRING_END { result = @builder.words_compose(val[0], val[1], val[2]) } qword_list: # nothing { result = [] } | qword_list tSTRING_CONTENT tSPACE { result = val[0] << @builder.string_internal(val[1]) } string_contents: # nothing { result = [] } | string_contents string_content { result = val[0] << val[1] } xstring_contents: # nothing { result = [] } | xstring_contents string_content { result = val[0] << val[1] } string_content: tSTRING_CONTENT { result = @builder.string_internal(val[0]) } | tSTRING_DVAR string_dvar { result = val[1] } | tSTRING_DBEG { @lexer.cond.push(false) @lexer.cmdarg.push(false) } compstmt tRCURLY { @lexer.cond.lexpop @lexer.cmdarg.lexpop result = @builder.begin(val[0], val[2], val[3]) } string_dvar: tGVAR { result = @builder.gvar(val[0]) } | tIVAR { result = @builder.ivar(val[0]) } | tCVAR { result = @builder.cvar(val[0]) } | backref symbol: tSYMBOL { result = @builder.symbol(val[0]) } dsym: tSYMBEG xstring_contents tSTRING_END { result = @builder.symbol_compose(val[0], val[1], val[2]) } numeric: tINTEGER { result = @builder.integer(val[0]) } | tFLOAT { result = @builder.float(val[0]) } | tUMINUS_NUM tINTEGER =tLOWEST { result = @builder.negate(val[0], @builder.integer(val[1])) } | tUMINUS_NUM tFLOAT =tLOWEST { result = @builder.negate(val[0], @builder.float(val[1])) } variable: tIDENTIFIER { result = @builder.ident(val[0]) } | tIVAR { result = @builder.ivar(val[0]) } | tGVAR { result = @builder.gvar(val[0]) } | tCVAR { result = @builder.cvar(val[0]) } | tCONSTANT { result = @builder.const(val[0]) } | kNIL { result = @builder.nil(val[0]) } | kSELF { result = @builder.self(val[0]) } | kTRUE { result = @builder.true(val[0]) } | kFALSE { result = @builder.false(val[0]) } | k__FILE__ { result = @builder.__FILE__(val[0]) } | k__LINE__ { result = @builder.__LINE__(val[0]) } var_ref: variable { result = @builder.accessible(val[0]) } var_lhs: variable { result = @builder.assignable(val[0]) } backref: tNTH_REF { result = @builder.nth_ref(val[0]) } | tBACK_REF { result = @builder.back_ref(val[0]) } superclass: term { result = nil } | tLT expr_value term { result = [ val[0], val[1] ] } | error term { yyerrok result = nil } f_arglist: tLPAREN2 f_args opt_nl tRPAREN { result = @builder.args(val[0], val[1], val[3]) @lexer.state = :expr_beg } | f_args term { result = @builder.args(nil, val[0], nil) } f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_f_block_arg { result = val[0]. concat(val[2]). concat(val[4]). concat(val[5]) } | f_arg tCOMMA f_optarg opt_f_block_arg { result = val[0]. concat(val[2]). concat(val[3]) } | f_arg tCOMMA f_rest_arg opt_f_block_arg { result = val[0]. concat(val[2]). concat(val[3]) } | f_arg opt_f_block_arg { result = val[0]. concat(val[1]) } | f_optarg tCOMMA f_rest_arg opt_f_block_arg { result = val[0]. concat(val[2]). concat(val[3]) } | f_optarg opt_f_block_arg { result = val[0]. concat(val[1]) } | f_rest_arg opt_f_block_arg { result = val[0]. concat(val[1]) } | f_block_arg { result = [ val[0] ] } | # nothing { result = [] } f_norm_arg: tCONSTANT { diagnostic :error, :argument_const, nil, val[0] } | tIVAR { diagnostic :error, :argument_ivar, nil, val[0] } | tGVAR { diagnostic :error, :argument_gvar, nil, val[0] } | tCVAR { diagnostic :error, :argument_cvar, nil, val[0] } | tIDENTIFIER { @static_env.declare val[0][0] result = @builder.arg(val[0]) } f_arg: f_norm_arg { result = [ val[0] ] } | f_arg tCOMMA f_norm_arg { result = val[0] << val[2] } f_opt: tIDENTIFIER tEQL arg_value { @static_env.declare val[0][0] result = @builder.optarg(val[0], val[1], val[2]) } f_optarg: f_opt { result = [ val[0] ] } | f_optarg tCOMMA f_opt { result = val[0] << val[2] } restarg_mark: tSTAR2 | tSTAR f_rest_arg: restarg_mark tIDENTIFIER { @static_env.declare val[1][0] result = [ @builder.restarg(val[0], val[1]) ] } | restarg_mark { result = [ @builder.restarg(val[0]) ] } blkarg_mark: tAMPER2 | tAMPER f_block_arg: blkarg_mark tIDENTIFIER { @static_env.declare val[1][0] result = @builder.blockarg(val[0], val[1]) } opt_f_block_arg: tCOMMA f_block_arg { result = [ val[1] ] } | # nothing { result = [] } singleton: var_ref | tLPAREN2 expr opt_nl tRPAREN { result = val[1] } assoc_list: # nothing { result = [] } | assocs trailer { result = val[0] } | args trailer { result = @builder.pair_list_18(val[0]) } assocs: assoc { result = [ val[0] ] } | assocs tCOMMA assoc { result = val[0] << val[2] } assoc: arg_value tASSOC arg_value { result = @builder.pair(val[0], val[1], val[2]) } operation: tIDENTIFIER | tCONSTANT | tFID operation2: tIDENTIFIER | tCONSTANT | tFID | op operation3: tIDENTIFIER | tFID | op dot_or_colon: tDOT | tCOLON2 opt_terms: | terms opt_nl: | tNL trailer: | tNL | tCOMMA term: tSEMI { yyerrok } | tNL terms: term | terms tSEMI none: # nothing { result = nil } end ---- header require 'parser' ---- inner def version 18 end def default_encoding Encoding::BINARY if defined? Encoding end