RubyParserBase (JRuby Base 9.4.1.0 API)

java.lang.Object
- org.jruby.parser.RubyParserBase

Direct Known Subclasses:: RubyParser

public abstract class RubyParserBase
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RubyParserBase.IDType

Nested Classes
Modifier and Type	Class and Description
`static class`	`RubyParserBase.IDType`

Field Summary

Fields
Modifier and Type	Field and Description
`IRubyObject`	`case_labels`
`protected ParserConfiguration`	`configuration`
`protected StaticScope`	`currentScope`
`static ByteList`	`INTERNAL_ID`
`boolean`	`isNextBreak`
`protected RubyLexer`	`lexer`
`static ByteList`	`NIL`
`static ByteList`	`NOT`
`protected ScopedParserState`	`scopedParserState`
`protected IRubyWarnings`	`warnings`

Constructor Summary

Constructors
Constructor and Description

RubyParserBase(IRubyWarnings warnings)

Constructors
Constructor and Description
`RubyParserBase(IRubyWarnings warnings)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`add_forwarding_args()`
`Node`	`addRootNode(Node topOfAST)`
`Node`	`appendToBlock(Node head, Node tail)`
`Node`	`arg_append(Node node1, Node node2)`
`static Node`	`arg_blk_pass(Node firstNode, BlockPassNode secondNode)`
`static Node`	`arg_concat(Node node1, Node node2)`
`ArgumentNode`	`arg_var(ByteList byteName)`
`ArgumentNode`	`arg_var(RubySymbol name)`
`ArgsNode`	`args_with_numbered(ArgsNode args, int paramCount)`
`Node`	`aryset(Node receiver, Node index)` Define an array set condition so we can return lhs
`AssignableNode`	`assignableInCurr(ByteList nameBytes, Node value)`
`AssignableNode`	`assignableKeyword(ByteList name, Node value)`
`AssignableNode`	`assignableLabelOrIdentifier(ByteList byteName, Node value)`
`static int`	`associateEncoding(ByteList buffer, org.jcodings.Encoding newEncoding, int codeRange)`
`Node`	`asSymbol(int line, ByteList value)`
`Node`	`asSymbol(int line, Node value)`
`Node`	`attrset(Node receiver, ByteList name)` Define an attribute set condition so we can return lhs
`Node`	`attrset(Node receiver, ByteList callType, ByteList name)`
`void`	`backrefAssignError(Node node)`
`Node`	`call_bin_op(Node firstNode, ByteList operator, Node secondNode)`
`Node`	`call_bin_op(Node firstNode, ByteList operator, Node secondNode, int defaultPosition)`
`Node`	`call_uni_op(Node firstNode, ByteList operator)`
`boolean`	`check_forwarding_args()`
`void`	`check_literal_when(Node one)`
`void`	`compile_error(java.lang.String message)`
`Node`	`cond(Node node)`
`DStrNode`	`createDStrNode(int line)`
`KeyValuePair<Node,Node>`	`createKeyValue(Node key, Node value)`
`protected StrNode`	`createStr(ByteList buffer, int flags)`
`Node`	`declareIdentifier(ByteList byteName)`
`void`	`endless_method_name(DefHolder name)`
`void`	`error_duplicate_pattern_key(ByteList key)`
`void`	`error_duplicate_pattern_variable(ByteList variable)`
`protected ByteList`	`extractByteList(java.lang.Object value)`
`void`	`fixpos(Node node, Node orig)`
`ByteList`	`formal_argument(ByteList identifier, java.lang.Object _unused)`
`void`	`frobnicate_fcall_args(FCallNode fcall, Node args, Node iter)`
`RubySymbol`	`get_id(ByteList id)`
`protected int`	`getBraceNest()`
`protected StackState`	`getCmdArgumentState()`
`protected StackState`	`getConditionState()`
`ParserConfiguration`	`getConfiguration()`
`protected ByteList`	`getCurrentArg()`
`StaticScope`	`getCurrentScope()`
`protected org.jcodings.Encoding`	`getEncoding()`
`protected java.lang.String`	`getFile()`
`protected int`	`getHeredocIndent()`
`protected int`	`getLeftParenBegin()`
`protected LexContext`	`getLexContext()`
`protected int`	`getParenNest()`
`int`	`getPosition(Node start)`
`RubyParserResult`	`getResult()` Gets the result.
`Ruby`	`getRuntime()`
`protected int`	`getState()`
`protected StrTerm`	`getStrTerm()`
`Node`	`gettable(ByteList id)`
`Node`	`gettable2(Node node)` We know for callers of this that it cannot be any of the specials checked in gettable.
`protected void`	`getterIdentifierError(RubySymbol identifier)`
`protected void`	`heredoc_dedent(Node node)`
`static RubyParserBase.IDType`	`id_type(ByteList identifier)`
`void`	`initTopLocalVariables()` Description of the RubyMethod
`java.lang.String`	`internalId()` Deprecated.
`static boolean`	`is_local_id(ByteList name)`
`boolean`	`is_local_id(java.lang.String name)` Deprecated.
`static boolean`	`is_private_local_id(ByteList name)`
`boolean`	`isArgsInfoEmpty(ArgsNode argsNode)`
`boolean`	`isLazy(ByteList callType)`
`boolean`	`isLazy(java.lang.String callType)`
`Node`	`last_arg_append(Node args, Node lastArg)`
`ListNode`	`list_append(Node list, Node item)`
`ListNode`	`list_concat(Node first, Node second)`
`Node`	`literal_concat(Node head, Node tail)`
`boolean`	`local_id(ByteList value)`
`Node`	`logop(Node left, ByteList op, Node right)`
`protected Node`	`makeNullNil(Node node)`
`Node`	`match_op(Node firstNode, Node secondNode)`
`Node`	`method_cond(Node node)`
`void`	`nd_set_first_loc(Node node, int line)`
`ComplexNode`	`negateComplexNode(ComplexNode complexNode)`
`FloatNode`	`negateFloat(FloatNode floatNode)`
`NumericNode`	`negateInteger(NumericNode integerNode)`
`NumericNode`	`negateNumeric(NumericNode node)`
`RationalNode`	`negateRational(RationalNode rationalNode)`
`Node`	`new_args_forward_call(int line, Node leadingArgs)`
`ArgsTailHolder`	`new_args_tail(int line, ListNode keywordArg, ByteList keywordRestArgName, BlockArgNode blockArg)`
`protected ArgsTailHolder`	`new_args_tail(int line, ListNode keywordArg, ByteList keywordRestArgName, ByteList block)`
`ArgsNode`	`new_args(int line, ListNode pre, ListNode optional, RestArgNode rest, ListNode post, ArgsTailHolder tail)`
`ArrayPatternNode`	`new_array_pattern_tail(int line, ListNode preArgs, boolean hasRest, ByteList restArg, ListNode postArgs)`
`ArrayPatternNode`	`new_array_pattern(int line, Node constant, Node preArg, ArrayPatternNode arrayPattern)`
`Node`	`new_ary_op_assign(Node receiverNode, ByteList operatorName, Node argsNode, Node valueNode)`
`Node`	`new_attr_op_assign(Node receiverNode, ByteList callType, Node valueNode, ByteList variableName, ByteList operatorName)`
`Node`	`new_attrassign(int line, Node receiver, ByteList name, Node argsNode, boolean isLazy)`
`Node`	`new_bodystmt(Node head, RescueBodyNode rescue, Node rescueElse, Node ensure)`
`Node`	`new_bv(ByteList identifier)`
`Node`	`new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter)`
`Node`	`new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter, int line)`
`Node`	`new_call(Node receiver, ByteList name, Node argsNode, Node iter)`
`Colon2Node`	`new_colon2(int line, Node leftNode, ByteList name)`
`Colon3Node`	`new_colon3(int line, ByteList name)`
`Node`	`new_const_op_assign(int line, Node lhs, ByteList operatorName, Node rhs)`
`Node`	`new_defined(long line, Node node)`
`Node`	`new_fcall(ByteList operation)`
`Node`	`new_find_pattern_tail(int line, ByteList preRestArg, ListNode postArgs, ByteList postRestArg)`
`Node`	`new_find_pattern(Node constant, FindPatternNode findPattern)`
`HashPatternNode`	`new_hash_pattern_tail(int line, HashNode keywordArgs, ByteList keywordRestArg)`
`HashPatternNode`	`new_hash_pattern(Node constant, HashPatternNode hashPatternNode)`
`Node`	`new_if(int line, Node condition, Node thenNode, Node elseNode)`
`Node`	`new_op_assign(AssignableNode receiverNode, ByteList operatorName, Node valueNode)`
`Node`	`new_regexp(int line, Node contents, RegexpNode end)`
`Node`	`new_super(int line, Node args)`
`Node`	`new_yield(int line, Node node)`
`static Node`	`newAlias(int line, Node newNode, Node oldNode)`
`ArrayNode`	`newArrayNode(int line, Node node)`
`static CaseNode`	`newCaseNode(int line, Node expression, Node firstWhenNode)` We post-process a chain of when nodes and analyze them to re-insert them back into our new CaseNode as a list.
`Node`	`newEvStrNode(int line, Node node)`
`Node`	`newIn(int line, Node expression, Node body, Node nextCase)`
`Node`	`newline_node(Node node, int line)` Wraps node with NEWLINE node.
`static PatternCaseNode`	`newPatternCaseNode(int line, Node expression, Node firstWhenNode)`
`Node`	`newRescueModNode(Node body, Node rescueBody)`
`SplatNode`	`newSplatNode(Node node)`
`SValueNode`	`newSValueNode(int line, Node node)`
`static Node`	`newUndef(int line, Node nameNode)`
`WhenNode`	`newWhenNode(int line, Node expressionNodes, Node bodyNode, Node nextCase)`
`Node`	`nil()`
`static Node`	`node_assign(Node lhs, Node rhs)`
`HashNode`	`none()`
`void`	`numparam_name(ByteList name)`
`void`	`numparam_name(RubySymbol name)`
`void`	`numparam_pop(Node previousInner)`
`Node`	`numparam_push()`
`void`	`ordinalMaxNumParam()`
`RubyParserResult`	`parse(ParserConfiguration configuration)` The parse method use an lexer stream and parse it to an AST node structure
`void`	`pop_pktbl(java.util.Set<ByteList> table)`
`void`	`pop_pvtbl(java.util.Set<ByteList> table)`
`void`	`popCurrentScope()`
`int`	`position(Node one, Node two)`
`java.util.Set<ByteList>`	`push_pktbl()`
`java.util.Set<ByteList>`	`push_pvtbl()`
`void`	`pushBlockScope()`
`void`	`pushLocalScope()`
`Node`	`reduce_nodes(Node body)`
`Node`	`remove_begin(Node node)`
`Node`	`remove_duplicate_keys(HashNode hash)`
`Node`	`rescued_expr(int line, Node arg, Node rescue)`
`void`	`reset()`
`int`	`resetMaxNumParam()`
`Node`	`rest_arg_append(Node args, Node restArg)`
`void`	`restore_defun(DefHolder holder)`
`int`	`restoreMaxNumParam(int maxNum)`
`Node`	`ret_args(Node node, int line)`
`protected void`	`setBraceNest(int value)`
`protected void`	`setCommandStart(boolean value)`
`void`	`setConfiguration(ParserConfiguration configuration)` Sets the configuration.
`protected void`	`setCurrentArg(RubySymbol value)`
`protected void`	`setHeredocIndent(int value)`
`protected void`	`setHeredocLineIndent(int indent)`
`protected void`	`setLeftParenBegin(int value)`
`void`	`setLexer(RubyLexer lexer)`
`void`	`setResult(RubyParserResult result)` Sets the result.
`protected void`	`setState(int value)`
`protected void`	`setStrTerm(StrTerm value)`
`ByteList`	`shadowing_lvar(ByteList nameBytes)`
`Node`	`splat_array(Node node)` If node is a splat and it is splatting a literal array then return the literal array.
`protected int`	`src_line()`
`RubySymbol`	`symbolID(ByteList identifierValue)`
`boolean`	`value_expr(Node node)`
`void`	`void_expr(Node node)` Check to see if current node is an useless statement.
`Node`	`void_stmts(Node node)` Check all nodes but the last one in a BlockNode for useless (void context) statements.
`void`	`warn_experimental(int line, java.lang.String message)`
`void`	`warn(int line, java.lang.String message)`
`void`	`warn(java.lang.String message)`
`void`	`warning(int line, java.lang.String message)`
`void`	`warnUnlessEOption(IRubyWarnings.ID id, Node node, java.lang.String message)`
`void`	`yyerror(java.lang.String message)` generate parsing error
`void`	`yyerror(java.lang.String message, ProductionState state)`
`void`	`yyerror(java.lang.String message, java.lang.String[] expected, java.lang.String found)` generate parsing error
`protected abstract java.lang.Object`	`yyparse(RubyLexer lexer, java.lang.Object yyDebug)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

currentScope
```
protected StaticScope currentScope
```

scopedParserState

protected ScopedParserState scopedParserState

lexer
```
protected RubyLexer lexer
```

warnings
```
protected IRubyWarnings warnings
```

configuration

protected ParserConfiguration configuration

isNextBreak
```
public boolean isNextBreak
```

case_labels
```
public IRubyObject case_labels
```

INTERNAL_ID

public static final ByteList INTERNAL_ID

NIL
```
public static ByteList NIL
```

NOT
```
public static final ByteList NOT
```

Constructor Detail

RubyParserBase

public RubyParserBase(IRubyWarnings warnings)

Method Detail

reset
```
public void reset()
```

getCurrentScope
```
public StaticScope getCurrentScope()
```

getConfiguration

public ParserConfiguration getConfiguration()

popCurrentScope
```
public void popCurrentScope()
```

pushBlockScope
```
public void pushBlockScope()
```

pushLocalScope
```
public void pushLocalScope()
```

numparam_push
```
public Node numparam_push()
```

numparam_pop

public void numparam_pop(Node previousInner)

args_with_numbered

public ArgsNode args_with_numbered(ArgsNode args,
                                   int paramCount)

resetMaxNumParam
```
public int resetMaxNumParam()
```

restoreMaxNumParam

public int restoreMaxNumParam(int maxNum)

ordinalMaxNumParam
```
public void ordinalMaxNumParam()
```

arg_concat

public static Node arg_concat(Node node1,
                              Node node2)

arg_blk_pass

public static Node arg_blk_pass(Node firstNode,
                                BlockPassNode secondNode)

gettable2
```
public Node gettable2(Node node)
```
We know for callers of this that it cannot be any of the specials checked in gettable.

Parameters:

node - to check its variable type

Returns:

an AST node representing this new variable

numparam_name

public void numparam_name(RubySymbol name)

numparam_name

public void numparam_name(ByteList name)

declareIdentifier

public Node declareIdentifier(ByteList byteName)

isArgsInfoEmpty

public boolean isArgsInfoEmpty(ArgsNode argsNode)

assignableLabelOrIdentifier

public AssignableNode assignableLabelOrIdentifier(ByteList byteName,
                                                  Node value)

assignableKeyword

public AssignableNode assignableKeyword(ByteList name,
                                        Node value)

getterIdentifierError

protected void getterIdentifierError(RubySymbol identifier)

newline_node

public Node newline_node(Node node,
                         int line)

Wraps node with NEWLINE node.

addRootNode

public Node addRootNode(Node topOfAST)

appendToBlock

public Node appendToBlock(Node head,
                          Node tail)

assignableInCurr

public AssignableNode assignableInCurr(ByteList nameBytes,
                                       Node value)

call_uni_op

public Node call_uni_op(Node firstNode,
                        ByteList operator)

call_bin_op

public Node call_bin_op(Node firstNode,
                        ByteList operator,
                        Node secondNode)

call_bin_op

public Node call_bin_op(Node firstNode,
                        ByteList operator,
                        Node secondNode,
                        int defaultPosition)

new_defined

public Node new_defined(long line,
                        Node node)

match_op

public Node match_op(Node firstNode,
                     Node secondNode)

aryset
```
public Node aryset(Node receiver,
                   Node index)
```
Define an array set condition so we can return lhs

Parameters:

receiver - array being set

index - node which should evalute to index of array set

Returns:

an AttrAssignNode

attrset
```
public Node attrset(Node receiver,
                    ByteList name)
```
Define an attribute set condition so we can return lhs

Parameters:

receiver - object which contains attribute

name - of the attribute being set

Returns:

an AttrAssignNode

attrset

public Node attrset(Node receiver,
                    ByteList callType,
                    ByteList name)

backrefAssignError

public void backrefAssignError(Node node)

node_assign

public static Node node_assign(Node lhs,
                               Node rhs)

ret_args

public Node ret_args(Node node,
                     int line)

warnUnlessEOption

public void warnUnlessEOption(IRubyWarnings.ID id,
                              Node node,
                              java.lang.String message)

value_expr
```
public boolean value_expr(Node node)
```

void_expr
```
public void void_expr(Node node)
```
Check to see if current node is an useless statement. If useless a warning if printed.

Parameters:

node - to be checked.

gettable
```
public Node gettable(ByteList id)
```

void_stmts
```
public Node void_stmts(Node node)
```
Check all nodes but the last one in a BlockNode for useless (void context) statements.

Parameters:

node - to be checked.

makeNullNil

protected Node makeNullNil(Node node)

cond
```
public Node cond(Node node)
```

method_cond
```
public Node method_cond(Node node)
```

new_if

public Node new_if(int line,
                   Node condition,
                   Node thenNode,
                   Node elseNode)

newSValueNode

public SValueNode newSValueNode(int line,
                                Node node)

newSplatNode

public SplatNode newSplatNode(Node node)

newArrayNode

public ArrayNode newArrayNode(int line,
                              Node node)

position

public int position(Node one,
                    Node two)

logop

public Node logop(Node left,
                  ByteList op,
                  Node right)

newCaseNode
```
public static CaseNode newCaseNode(int line,
                                   Node expression,
                                   Node firstWhenNode)
```
We post-process a chain of when nodes and analyze them to re-insert them back into our new CaseNode as a list. The grammar is more amenable to linked list style so we correct it at this point.

Parameters:

expression - of the case node (e.g. case foo)

firstWhenNode - first when (which could also be the else)

Returns:

a new case node

newPatternCaseNode

public static PatternCaseNode newPatternCaseNode(int line,
                                                 Node expression,
                                                 Node firstWhenNode)

newWhenNode

public WhenNode newWhenNode(int line,
                            Node expressionNodes,
                            Node bodyNode,
                            Node nextCase)

new_op_assign

public Node new_op_assign(AssignableNode receiverNode,
                          ByteList operatorName,
                          Node valueNode)

new_ary_op_assign

public Node new_ary_op_assign(Node receiverNode,
                              ByteList operatorName,
                              Node argsNode,
                              Node valueNode)

new_attr_op_assign

public Node new_attr_op_assign(Node receiverNode,
                               ByteList callType,
                               Node valueNode,
                               ByteList variableName,
                               ByteList operatorName)

new_const_op_assign

public Node new_const_op_assign(int line,
                                Node lhs,
                                ByteList operatorName,
                                Node rhs)

new_bodystmt

public Node new_bodystmt(Node head,
                         RescueBodyNode rescue,
                         Node rescueElse,
                         Node ensure)

symbolID

public RubySymbol symbolID(ByteList identifierValue)

isLazy

public boolean isLazy(java.lang.String callType)

isLazy

public boolean isLazy(ByteList callType)

new_attrassign

public Node new_attrassign(int line,
                           Node receiver,
                           ByteList name,
                           Node argsNode,
                           boolean isLazy)

new_call

public Node new_call(Node receiver,
                     ByteList callType,
                     ByteList name,
                     Node argsNode,
                     Node iter)

new_call

public Node new_call(Node receiver,
                     ByteList callType,
                     ByteList name,
                     Node argsNode,
                     Node iter,
                     int line)

new_call

public Node new_call(Node receiver,
                     ByteList name,
                     Node argsNode,
                     Node iter)

new_colon2

public Colon2Node new_colon2(int line,
                             Node leftNode,
                             ByteList name)

new_colon3

public Colon3Node new_colon3(int line,
                             ByteList name)

frobnicate_fcall_args

public void frobnicate_fcall_args(FCallNode fcall,
                                  Node args,
                                  Node iter)

fixpos

public void fixpos(Node node,
                   Node orig)

new_fcall

public Node new_fcall(ByteList operation)

new_super

public Node new_super(int line,
                      Node args)

initTopLocalVariables
```
public void initTopLocalVariables()
```
Description of the RubyMethod

getResult
```
public RubyParserResult getResult()
```
Gets the result.

Returns:

Returns a RubyParserResult

setResult
```
public void setResult(RubyParserResult result)
```
Sets the result.

Parameters:

result - The result to set

setConfiguration
```
public void setConfiguration(ParserConfiguration configuration)
```
Sets the configuration.

Parameters:

configuration - The configuration to set

setLexer

public void setLexer(RubyLexer lexer)

createDStrNode

public DStrNode createDStrNode(int line)

createKeyValue

public KeyValuePair<Node,Node> createKeyValue(Node key,
                                              Node value)

asSymbol

public Node asSymbol(int line,
                     ByteList value)

asSymbol

public Node asSymbol(int line,
                     Node value)

literal_concat

public Node literal_concat(Node head,
                           Node tail)

newRescueModNode

public Node newRescueModNode(Node body,
                             Node rescueBody)

newEvStrNode

public Node newEvStrNode(int line,
                         Node node)

new_yield

public Node new_yield(int line,
                      Node node)

negateInteger

public NumericNode negateInteger(NumericNode integerNode)

negateFloat

public FloatNode negateFloat(FloatNode floatNode)

negateComplexNode

public ComplexNode negateComplexNode(ComplexNode complexNode)

negateRational

public RationalNode negateRational(RationalNode rationalNode)

new_args

public ArgsNode new_args(int line,
                         ListNode pre,
                         ListNode optional,
                         RestArgNode rest,
                         ListNode post,
                         ArgsTailHolder tail)

new_args_tail

public ArgsTailHolder new_args_tail(int line,
                                    ListNode keywordArg,
                                    ByteList keywordRestArgName,
                                    BlockArgNode blockArg)

new_args_tail

protected ArgsTailHolder new_args_tail(int line,
                                       ListNode keywordArg,
                                       ByteList keywordRestArgName,
                                       ByteList block)

remove_duplicate_keys

public Node remove_duplicate_keys(HashNode hash)

newAlias

public static Node newAlias(int line,
                            Node newNode,
                            Node oldNode)

newUndef

public static Node newUndef(int line,
                            Node nameNode)

yyerror

public void yyerror(java.lang.String message)

generate parsing error

yyerror

public void yyerror(java.lang.String message,
                    ProductionState state)

yyerror

public void yyerror(java.lang.String message,
                    java.lang.String[] expected,
                    java.lang.String found)

generate parsing error

Parameters:: message - text to be displayed.; expected - list of acceptable tokens, if available.

getPosition
```
public int getPosition(Node start)
```

warn

public void warn(java.lang.String message)

warn

public void warn(int line,
                 java.lang.String message)

warning

public void warning(int line,
                    java.lang.String message)

is_local_id

public static boolean is_local_id(ByteList name)

is_local_id

@Deprecated
public boolean is_local_id(java.lang.String name)

Deprecated.

list_append

public ListNode list_append(Node list,
                            Node item)

new_bv

public Node new_bv(ByteList identifier)

arg_var

public ArgumentNode arg_var(RubySymbol name)

arg_var

public ArgumentNode arg_var(ByteList byteName)

formal_argument

public ByteList formal_argument(ByteList identifier,
                                java.lang.Object _unused)

id_type

public static RubyParserBase.IDType id_type(ByteList identifier)

is_private_local_id

public static boolean is_private_local_id(ByteList name)

shadowing_lvar

public ByteList shadowing_lvar(ByteList nameBytes)

list_concat

public ListNode list_concat(Node first,
                            Node second)

splat_array
```
public Node splat_array(Node node)
```
If node is a splat and it is splatting a literal array then return the literal array. Otherwise return null. This allows grammar to not splat into a Ruby Array if splatting a literal array.

arg_append

public Node arg_append(Node node1,
                       Node node2)

compile_error

public void compile_error(java.lang.String message)

new_regexp

public Node new_regexp(int line,
                       Node contents,
                       RegexpNode end)

associateEncoding

public static int associateEncoding(ByteList buffer,
                                    org.jcodings.Encoding newEncoding,
                                    int codeRange)

negateNumeric

public NumericNode negateNumeric(NumericNode node)

internalId

@Deprecated
public java.lang.String internalId()

Deprecated.

push_pvtbl

public java.util.Set<ByteList> push_pvtbl()

pop_pvtbl

public void pop_pvtbl(java.util.Set<ByteList> table)

push_pktbl

public java.util.Set<ByteList> push_pktbl()

pop_pktbl

public void pop_pktbl(java.util.Set<ByteList> table)

newIn

public Node newIn(int line,
                  Node expression,
                  Node body,
                  Node nextCase)

endless_method_name

public void endless_method_name(DefHolder name)

reduce_nodes
```
public Node reduce_nodes(Node body)
```

restore_defun

public void restore_defun(DefHolder holder)

new_array_pattern

public ArrayPatternNode new_array_pattern(int line,
                                          Node constant,
                                          Node preArg,
                                          ArrayPatternNode arrayPattern)

new_hash_pattern

public HashPatternNode new_hash_pattern(Node constant,
                                        HashPatternNode hashPatternNode)

none
```
public HashNode none()
```

new_hash_pattern_tail

public HashPatternNode new_hash_pattern_tail(int line,
                                             HashNode keywordArgs,
                                             ByteList keywordRestArg)

warn_experimental

public void warn_experimental(int line,
                              java.lang.String message)

rescued_expr

public Node rescued_expr(int line,
                         Node arg,
                         Node rescue)

new_array_pattern_tail

public ArrayPatternNode new_array_pattern_tail(int line,
                                               ListNode preArgs,
                                               boolean hasRest,
                                               ByteList restArg,
                                               ListNode postArgs)

error_duplicate_pattern_key

public void error_duplicate_pattern_key(ByteList key)

error_duplicate_pattern_variable

public void error_duplicate_pattern_variable(ByteList variable)

new_find_pattern

public Node new_find_pattern(Node constant,
                             FindPatternNode findPattern)

new_find_pattern_tail

public Node new_find_pattern_tail(int line,
                                  ByteList preRestArg,
                                  ListNode postArgs,
                                  ByteList postRestArg)

local_id

public boolean local_id(ByteList value)

check_forwarding_args

public boolean check_forwarding_args()

add_forwarding_args
```
public void add_forwarding_args()
```

new_args_forward_call

public Node new_args_forward_call(int line,
                                  Node leadingArgs)

check_literal_when

public void check_literal_when(Node one)

last_arg_append

public Node last_arg_append(Node args,
                            Node lastArg)

rest_arg_append

public Node rest_arg_append(Node args,
                            Node restArg)

remove_begin
```
public Node remove_begin(Node node)
```

nd_set_first_loc

public void nd_set_first_loc(Node node,
                             int line)

parse

public RubyParserResult parse(ParserConfiguration configuration)
                       throws java.io.IOException

The parse method use an lexer stream and parse it to an AST node structure

Throws:: java.io.IOException

yyparse

protected abstract java.lang.Object yyparse(RubyLexer lexer,
                                            java.lang.Object yyDebug)
                                     throws java.io.IOException

Throws:: java.io.IOException

getLexContext
```
protected LexContext getLexContext()
```

src_line
```
protected int src_line()
```

getHeredocIndent
```
protected int getHeredocIndent()
```

setHeredocIndent

protected void setHeredocIndent(int value)

getBraceNest
```
protected int getBraceNest()
```

setBraceNest

protected void setBraceNest(int value)

getState
```
protected int getState()
```

setState
```
protected void setState(int value)
```

getEncoding

protected org.jcodings.Encoding getEncoding()

setCommandStart

protected void setCommandStart(boolean value)

getCurrentArg
```
protected ByteList getCurrentArg()
```

setCurrentArg

protected void setCurrentArg(RubySymbol value)

createStr

protected StrNode createStr(ByteList buffer,
                            int flags)

getCmdArgumentState

protected StackState getCmdArgumentState()

getConditionState

protected StackState getConditionState()

getLeftParenBegin
```
protected int getLeftParenBegin()
```

getParenNest
```
protected int getParenNest()
```

extractByteList

protected ByteList extractByteList(java.lang.Object value)

setLeftParenBegin

protected void setLeftParenBegin(int value)

getFile
```
protected java.lang.String getFile()
```

heredoc_dedent

protected void heredoc_dedent(Node node)

getStrTerm
```
protected StrTerm getStrTerm()
```

setStrTerm

protected void setStrTerm(StrTerm value)

setHeredocLineIndent

protected void setHeredocLineIndent(int indent)

getRuntime
```
public Ruby getRuntime()
```

nil
```
public Node nil()
```

get_id

public RubySymbol get_id(ByteList id)

Class RubyParserBase

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

currentScope

scopedParserState

lexer

warnings

configuration

isNextBreak

case_labels

INTERNAL_ID

NIL

NOT

Constructor Detail

RubyParserBase

Method Detail

reset

getCurrentScope

getConfiguration

popCurrentScope

pushBlockScope

pushLocalScope

numparam_push

numparam_pop

args_with_numbered

resetMaxNumParam

restoreMaxNumParam

ordinalMaxNumParam

arg_concat

arg_blk_pass

gettable2

numparam_name

numparam_name

declareIdentifier

isArgsInfoEmpty

assignableLabelOrIdentifier

assignableKeyword

getterIdentifierError

newline_node

addRootNode

appendToBlock

assignableInCurr

call_uni_op

call_bin_op

call_bin_op

new_defined

match_op

aryset

attrset

attrset

backrefAssignError

node_assign

ret_args

warnUnlessEOption

value_expr

void_expr

gettable

void_stmts

makeNullNil

cond

method_cond

new_if

newSValueNode

newSplatNode

newArrayNode

position

logop

newCaseNode

newPatternCaseNode

newWhenNode

new_op_assign

new_ary_op_assign

new_attr_op_assign

new_const_op_assign

new_bodystmt

symbolID