org.jruby.parser

Class ParserSupport

java.lang.Object

org.jruby.parser.ParserSupport

public class ParserSupport
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
protected ParserConfiguration	configuration
protected StaticScope	currentScope
static ByteList	INTERNAL_ID
protected RubyLexer	lexer
protected IRubyWarnings	warnings

Constructor Summary

Constructors

Constructor and Description
ParserSupport()

Method Summary

Modifier and Type	Method and Description
Node	addRootNode(Node topOfAST)
Node	appendToBlock(Node head, Node tail)
Node	arg_add(ISourcePosition position, Node node1, Node node2)
Node	arg_append(Node node1, Node node2)
Node	arg_blk_pass(Node firstNode, BlockPassNode secondNode)
Node	arg_concat(ISourcePosition position, Node node1, Node node2)
ArgumentNode	arg_var(ByteList id)
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 name, Node value)
static int	associateEncoding(ByteList buffer, org.jcodings.Encoding newEncoding, int codeRange)
Node	asSymbol(ISourcePosition position, ByteList value)
Node	asSymbol(ISourcePosition position, 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)
boolean	checkExpression(Node node) Deprecated.
void	checkUselessStatement(Node node) Check to see if current node is an useless statement.
void	checkUselessStatements(BlockNode blockNode) Check all nodes but the last one in a BlockNode for useless (void context) statements.
void	compile_error(java.lang.String message)
DStrNode	createDStrNode(ISourcePosition position)
KeyValuePair<Node,Node>	createKeyValue(Node key, Node value)
Node	declareIdentifier(ByteList name)
void	fixpos(Node node, Node orig)
ByteList	formal_argument(ByteList identifier)
java.lang.String	formal_argument(java.lang.String identifier) Deprecated.
void	frobnicate_fcall_args(FCallNode fcall, Node args, Node iter)
Node	getConditionNode(Node node)
ParserConfiguration	getConfiguration()
StaticScope	getCurrentScope()
Node	getMatchNode(Node firstNode, Node secondNode)
Node	getOperatorCallNode(Node firstNode, ByteList operator)
Node	getOperatorCallNode(Node firstNode, ByteList operator, Node secondNode)
Node	getOperatorCallNode(Node firstNode, ByteList operator, Node secondNode, ISourcePosition defaultPosition)
ISourcePosition	getPosition(ISourcePositionHolder start)
RubyParserResult	getResult() Gets the result.
Node	gettable2(Node node) We know for callers of this that it cannot be any of the specials checked in gettable.
protected void	getterIdentifierError(ISourcePosition position, RubySymbol identifier)
void	initTopLocalVariables() Description of the RubyMethod
java.lang.String	internalId() Deprecated.
boolean	is_local_id(ByteList name)
boolean	is_local_id(java.lang.String name) Deprecated.
boolean	isBlockTopLevel() Is the top of this scope a block scope (which happens in evals).
boolean	isBreakStatement(Node node) Is the supplied node a break/control statement?
boolean	isInClass()
boolean	isInDef()
boolean	isLazy(ByteList callType)
boolean	isLazy(java.lang.String callType)
boolean	isLiteral(Node node) Is this a literal in the sense that MRI has a NODE_LIT for.
KeywordArgNode	keyword_arg(ISourcePosition position, AssignableNode assignable)
ListNode	list_append(Node list, Node item)
ListNode	list_concat(Node first, Node second)
Node	literal_concat(ISourcePosition position, Node head, Node tail)
protected Node	makeNullNil(Node node)
ComplexNode	negateComplexNode(ComplexNode complexNode)
FloatNode	negateFloat(FloatNode floatNode)
NumericNode	negateInteger(NumericNode integerNode)
NumericNode	negateNumeric(NumericNode node)
RationalNode	negateRational(RationalNode rationalNode)
ArgsTailHolder	new_args_tail(ISourcePosition position, ListNode keywordArg, ByteList keywordRestArgName, BlockArgNode blockArg)
Node	new_args(ISourcePosition position, ListNode pre, ListNode optional, RestArgNode rest, ListNode post, ArgsTailHolder tail)
Node	new_attrassign(ISourcePosition position, Node receiver, ByteList name, Node args, boolean isLazy)
Node	new_bv(ByteList identifier)
Node	new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter)
Node	new_call(Node receiver, ByteList name, Node argsNode, Node iter)
Colon2Node	new_colon2(ISourcePosition position, Node leftNode, ByteList name)
Colon3Node	new_colon3(ISourcePosition position, ByteList name)
Node	new_defined(ISourcePosition position, Node something)
Node	new_fcall(ByteList operation)
Node	new_opElementAsgnNode(Node receiverNode, ByteList operatorName, Node argsNode, Node valueNode)
Node	new_super(ISourcePosition position, Node args)
Node	new_yield(ISourcePosition position, Node node)
Node	newAlias(ISourcePosition position, Node newNode, Node oldNode)
AndNode	newAndNode(ISourcePosition position, Node left, Node right)
ArrayNode	newArrayNode(ISourcePosition position, Node firstNode)
CaseNode	newCaseNode(ISourcePosition position, Node expression, Node firstWhenNode) Ok I admit that this is somewhat ugly.
Node	newEvStrNode(ISourcePosition position, Node node)
Node	newline_node(Node node, ISourcePosition position) Wraps node with NEWLINE node.
Node	newOpAsgn(ISourcePosition position, Node receiverNode, ByteList callType, Node valueNode, ByteList variableName, ByteList operatorName)
Node	newOpConstAsgn(ISourcePosition position, Node lhs, ByteList operatorName, Node rhs)
OrNode	newOrNode(ISourcePosition position, Node left, Node right)
Node	newRegexpNode(ISourcePosition position, Node contents, RegexpNode end)
Node	newRescueModNode(Node body, Node rescueBody)
SplatNode	newSplatNode(ISourcePosition position, Node node)
SValueNode	newSValueNode(ISourcePosition position, Node node)
Node	newUndef(ISourcePosition position, Node nameNode)
WhenNode	newWhenNode(ISourcePosition position, Node expressionNodes, Node bodyNode, Node nextCase)
Node	node_assign(Node lhs, Node rhs)
void	popCurrentScope()
ISourcePosition	position(ISourcePositionHolder one, ISourcePositionHolder two)
void	pushBlockScope()
void	pushLocalScope()
Node	remove_duplicate_keys(HashNode hash)
void	reset()
Node	ret_args(Node node, ISourcePosition position)
void	setConfiguration(ParserConfiguration configuration) Sets the configuration.
void	setInDef(boolean inDef)
void	setIsInClass(boolean inClass)
void	setLexer(RubyLexer lexer)
void	setResult(RubyParserResult result) Sets the result.
void	setWarnings(IRubyWarnings warnings)
ByteList	shadowing_lvar(ByteList nameBytes)
java.lang.String	shadowing_lvar(java.lang.String name) Deprecated.
Node	splat_array(Node node) If node is a splat and it is splatting a literal array then return the literal array.
RubySymbol	symbolID(ByteList identifierValue)
static boolean	value_expr(RubyLexer lexer, Node node)
void	warn(IRubyWarnings.ID id, ISourcePosition position, java.lang.String message, java.lang.Object... data)
void	warning(IRubyWarnings.ID id, ISourcePosition position, java.lang.String message, java.lang.Object... data)
void	warningUnlessEOption(IRubyWarnings.ID id, Node node, 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, java.lang.String[] expected, java.lang.String found) generate parsing error

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

currentScope

protected StaticScope currentScope

lexer

protected RubyLexer lexer

warnings

protected IRubyWarnings warnings

configuration

protected ParserConfiguration configuration

INTERNAL_ID

public static final ByteList INTERNAL_ID

Constructor Detail

ParserSupport

public ParserSupport()

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()

arg_concat

public Node arg_concat(ISourcePosition position,
                       Node node1,
                       Node node2)

arg_blk_pass

public 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

declareIdentifier

public Node declareIdentifier(ByteList name)

assignableLabelOrIdentifier

public AssignableNode assignableLabelOrIdentifier(ByteList name,
                                                  Node value)

assignableKeyword

public AssignableNode assignableKeyword(ByteList name,
                                        Node value)

getterIdentifierError

protected void getterIdentifierError(ISourcePosition position,
                                     RubySymbol identifier)

newline_node

public Node newline_node(Node node,
                         ISourcePosition position)

Wraps node with NEWLINE node.

Parameters:

node -

addRootNode

public Node addRootNode(Node topOfAST)

appendToBlock

public Node appendToBlock(Node head,
                          Node tail)

assignableInCurr

public AssignableNode assignableInCurr(ByteList nameBytes,
                                       Node value)

getOperatorCallNode

public Node getOperatorCallNode(Node firstNode,
                                ByteList operator)

getOperatorCallNode

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

getOperatorCallNode

public Node getOperatorCallNode(Node firstNode,
                                ByteList operator,
                                Node secondNode,
                                ISourcePosition defaultPosition)

getMatchNode

public Node getMatchNode(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)

arg_add

public Node arg_add(ISourcePosition position,
                    Node node1,
                    Node node2)

node_assign

public Node node_assign(Node lhs,
                        Node rhs)

ret_args

public Node ret_args(Node node,
                     ISourcePosition position)

isBreakStatement

public boolean isBreakStatement(Node node)

Is the supplied node a break/control statement?

Parameters:

node - to be checked

Returns:

true if a control node, false otherwise

warnUnlessEOption

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

warningUnlessEOption

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

value_expr

public static boolean value_expr(RubyLexer lexer,
                                 Node node)

checkExpression

@Deprecated
public boolean checkExpression(Node node)

Deprecated.

isLiteral

public boolean isLiteral(Node node)

Is this a literal in the sense that MRI has a NODE_LIT for. This is different than ILiteralNode. We should pick a different name since ILiteralNode is something we created which is similiar but used for a slightly different condition (can I do singleton things).

Parameters:

node - to be tested

Returns:

true if it is a literal

checkUselessStatement

public void checkUselessStatement(Node node)

Check to see if current node is an useless statement. If useless a warning if printed.

Parameters:

node - to be checked.

checkUselessStatements

public void checkUselessStatements(BlockNode blockNode)

Check all nodes but the last one in a BlockNode for useless (void context) statements.

Parameters:

blockNode - to be checked.

makeNullNil

protected Node makeNullNil(Node node)

getConditionNode

public Node getConditionNode(Node node)

newSValueNode

public SValueNode newSValueNode(ISourcePosition position,
                                Node node)

newSplatNode

public SplatNode newSplatNode(ISourcePosition position,
                              Node node)

newArrayNode

public ArrayNode newArrayNode(ISourcePosition position,
                              Node firstNode)

position

public ISourcePosition position(ISourcePositionHolder one,
                                ISourcePositionHolder two)

newAndNode

public AndNode newAndNode(ISourcePosition position,
                          Node left,
                          Node right)

newOrNode

public OrNode newOrNode(ISourcePosition position,
                        Node left,
                        Node right)

newCaseNode

public CaseNode newCaseNode(ISourcePosition position,
                            Node expression,
                            Node firstWhenNode)

Ok I admit that this is somewhat ugly. We post-process a chain of when nodes and analyze them to re-insert them back into our new CaseNode the way we want. The grammar is being difficult and until I go back into the depths of that this is where things are.

Parameters:

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

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

Returns:

a new case node

newWhenNode

public WhenNode newWhenNode(ISourcePosition position,
                            Node expressionNodes,
                            Node bodyNode,
                            Node nextCase)

new_opElementAsgnNode

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

symbolID

public RubySymbol symbolID(ByteList identifierValue)

newOpAsgn

public Node newOpAsgn(ISourcePosition position,
                      Node receiverNode,
                      ByteList callType,
                      Node valueNode,
                      ByteList variableName,
                      ByteList operatorName)

newOpConstAsgn

public Node newOpConstAsgn(ISourcePosition position,
                           Node lhs,
                           ByteList operatorName,
                           Node rhs)

isLazy

public boolean isLazy(java.lang.String callType)

isLazy

public boolean isLazy(ByteList callType)

new_attrassign

public Node new_attrassign(ISourcePosition position,
                           Node receiver,
                           ByteList name,
                           Node args,
                           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 name,
                     Node argsNode,
                     Node iter)

new_colon2

public Colon2Node new_colon2(ISourcePosition position,
                             Node leftNode,
                             ByteList name)

new_colon3

public Colon3Node new_colon3(ISourcePosition position,
                             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(ISourcePosition position,
                      Node args)

initTopLocalVariables

public void initTopLocalVariables()

Description of the RubyMethod

isInDef

public boolean isInDef()

setInDef

public void setInDef(boolean inDef)

isInClass

public boolean isInClass()

setIsInClass

public void setIsInClass(boolean inClass)

isBlockTopLevel

public boolean isBlockTopLevel()

Is the top of this scope a block scope (which happens in evals). This is supposed to serve same purpose as MRIs: dyna_in_block but I don't quite get why it is so complicated. All non-eval parsers have local scopes except eval but they combine in_main || compile_for_eval?

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

setWarnings

public void setWarnings(IRubyWarnings warnings)

setLexer

public void setLexer(RubyLexer lexer)

createDStrNode

public DStrNode createDStrNode(ISourcePosition position)

createKeyValue

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

asSymbol

public Node asSymbol(ISourcePosition position,
                     ByteList value)

asSymbol

public Node asSymbol(ISourcePosition position,
                     Node value)

literal_concat

public Node literal_concat(ISourcePosition position,
                           Node head,
                           Node tail)

newRescueModNode

public Node newRescueModNode(Node body,
                             Node rescueBody)

newEvStrNode

public Node newEvStrNode(ISourcePosition position,
                         Node node)

new_yield

public Node new_yield(ISourcePosition position,
                      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 Node new_args(ISourcePosition position,
                     ListNode pre,
                     ListNode optional,
                     RestArgNode rest,
                     ListNode post,
                     ArgsTailHolder tail)

new_args_tail

public ArgsTailHolder new_args_tail(ISourcePosition position,
                                    ListNode keywordArg,
                                    ByteList keywordRestArgName,
                                    BlockArgNode blockArg)

remove_duplicate_keys

public Node remove_duplicate_keys(HashNode hash)

newAlias

public Node newAlias(ISourcePosition position,
                     Node newNode,
                     Node oldNode)

newUndef

public Node newUndef(ISourcePosition position,
                     Node nameNode)

yyerror

public void yyerror(java.lang.String message)

generate parsing error

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 ISourcePosition getPosition(ISourcePositionHolder start)

warn

public void warn(IRubyWarnings.ID id,
                 ISourcePosition position,
                 java.lang.String message,
                 java.lang.Object... data)

warning

public void warning(IRubyWarnings.ID id,
                    ISourcePosition position,
                    java.lang.String message,
                    java.lang.Object... data)

is_local_id

public 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(ByteList id)

formal_argument

public ByteList formal_argument(ByteList identifier)

formal_argument

@Deprecated
public java.lang.String formal_argument(java.lang.String identifier)

Deprecated.

shadowing_lvar

public ByteList shadowing_lvar(ByteList nameBytes)

shadowing_lvar

@Deprecated
public java.lang.String shadowing_lvar(java.lang.String name)

Deprecated.

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)

newRegexpNode

public Node newRegexpNode(ISourcePosition position,
                          Node contents,
                          RegexpNode end)

associateEncoding

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

keyword_arg

public KeywordArgNode keyword_arg(ISourcePosition position,
                                  AssignableNode assignable)

negateNumeric

public NumericNode negateNumeric(NumericNode node)

new_defined

public Node new_defined(ISourcePosition position,
                        Node something)

internalId

@Deprecated
public java.lang.String internalId()

Deprecated.