RipperLexer

java.lang.Object
- org.jruby.ext.ripper.RipperLexer

public class RipperLexer
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RipperLexer.Keyword

static class RipperLexer.LexState

Nested Classes
Modifier and Type	Class and Description
`static class`	`RipperLexer.Keyword`
`static class`	`RipperLexer.LexState`

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`__end__seen`
`static org.jcodings.Encoding`	`ASCII8BIT_ENCODING`
`private static org.jruby.util.ByteList`	`BEGIN_DOC_MARKER`
`private StackState`	`cmdArgumentState`
`private static org.jruby.util.ByteList`	`CODING`
`boolean`	`commandStart`
`private StackState`	`conditionState`
`private org.jcodings.Encoding`	`current_enc`
`protected org.jruby.util.ByteList`	`delayed`
`private int`	`delayed_col`
`private int`	`delayed_line`
`private static org.jruby.util.ByteList`	`END_DOC_MARKER`
`private static org.jruby.util.ByteList`	`END_MARKER`
`(package private) static int`	`EOF`
`protected boolean`	`eofp`
`private boolean`	`has_shebang`
`private int`	`heredoc_end`
`(package private) java.lang.String`	`identValue`
`boolean`	`ignoreNextScanEvent`
`private int`	`leftParenBegin`
`protected org.jruby.util.ByteList`	`lex_lastline`
`private org.jruby.util.ByteList`	`lex_nextline`
`protected int`	`lex_p`
`protected int`	`lex_pbeg`
`protected int`	`lex_pend`
`private RipperLexer.LexState`	`lex_state`
`private StrTerm`	`lex_strterm`
`protected org.jruby.util.ByteList`	`lexb`
`private int`	`line_count`
`private static org.joni.Regex`	`magicRegexp`
`private static java.lang.String`	`magicString`
`private static java.util.HashMap<java.lang.String,RipperLexer.Keyword>`	`map`
`private byte[]`	`mbcBuf`
`private int`	`parenNest`
`private RipperParser`	`parser`
`private int`	`ruby_sourceline`
`private LexerSource`	`src`
`private static int`	`str_dquote`
`private static int`	`str_dsym`
`(package private) static int`	`STR_FUNC_ESCAPE`
`(package private) static int`	`STR_FUNC_EXPAND`
`(package private) static int`	`STR_FUNC_INDENT`
`(package private) static int`	`STR_FUNC_QWORDS`
`(package private) static int`	`STR_FUNC_REGEXP`
`(package private) static int`	`STR_FUNC_SYMBOL`
`private static int`	`str_regexp`
`private static int`	`str_squote`
`private static int`	`str_ssym`
`private static int`	`str_xquote`
`private int`	`token`
`private java.lang.StringBuilder`	`tokenBuffer`
`protected int`	`tokp`
`static org.jcodings.Encoding`	`USASCII_ENCODING`
`static org.jcodings.Encoding`	`UTF8_ENCODING`
`(package private) java.lang.Object`	`yaccValue`

Constructor Summary

Constructors
Constructor and Description

RipperLexer(RipperParser parser, LexerSource src)

Constructors
Constructor and Description
`RipperLexer(RipperParser parser, LexerSource src)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private int`	`ampersand(boolean spaceSeen)`
`private void`	`arg_ambiguous()`
`private int`	`at()`
`private int`	`backtick(boolean commandState)`
`private int`	`bang()`
`private int`	`caret()`
`private int`	`colon(boolean spaceSeen)`
`int`	`column()`
`private int`	`comma(int c)`
`private boolean`	`comment_at_top()`
`void`	`compile_error(java.lang.String message)`
`IRubyObject`	`createStr(org.jruby.util.ByteList buffer, int flags)`
`private void`	`determineExpressionState()`
`void`	`dispatchDelayedToken(int token)`
`void`	`dispatchHeredocEnd()`
`void`	`dispatchIgnoredScanEvent(int token)`
`void`	`dispatchScanEvent(int token)`
`private int`	`doKeyword(RipperLexer.LexState state)`
`private int`	`dollar()`
`private int`	`dot()`
`private int`	`doubleQuote()`
`protected void`	`flush_string_content(org.jcodings.Encoding encoding)`
`private void`	`flush()`
`StackState`	`getCmdArgumentState()`
`StackState`	`getConditionState()`
`org.jcodings.Encoding`	`getEncoding()`
`private int`	`getFloatToken(java.lang.String number)`
`java.lang.String`	`getIdent()`
`private int`	`getIdentifier(int first)`
`private java.lang.Object`	`getInteger(java.lang.String value, int radix)`
`static RipperLexer.Keyword`	`getKeyword(java.lang.String str)`
`int`	`getLeftParenBegin()`
`private int`	`getNumberToken(java.lang.String number, boolean isFloat, int nondigit)`
`Ruby`	`getRuntime()`
`StrTerm`	`getStrTerm()`
`java.lang.StringBuilder`	`getTokenBuffer()`
`private int`	`greaterThan()`
`boolean`	`hasScanEvent()`
`boolean`	`hasStarted()` Has lexing started yet?
`void`	`heredoc_restore(HeredocTerm here)`
`private int`	`hereDocumentIdentifier()`
`private int`	`identifier(int c, boolean commandState)`
`private int`	`identifierToken(RipperLexer.LexState last_state, int result, java.lang.String value)`
`int`	`incrementParenNest()`
`private boolean`	`isARG()`
`private boolean`	`isBEG()`
`private boolean`	`isEND()`
`boolean`	`isEndSeen()`
`(package private) static boolean`	`isHexChar(int c)`
`boolean`	`isIdentifierChar(int c)` This is a valid character for an identifier?
`private boolean`	`isLabelPossible(boolean commandState)`
`protected boolean`	`isMultiByteChar(int c)` Is this a multibyte character from a multibyte encoding?
`private boolean`	`isNext_identchar()`
`(package private) static boolean`	`isOctChar(int c)`
`private boolean`	`isSpaceArg(int c, boolean spaceSeen)`
`boolean`	`isVerbose()`
`private int`	`leftBracket(boolean spaceSeen)`
`private int`	`leftCurly()`
`private int`	`leftParen(boolean spaceSeen)`
`private int`	`lessThan(boolean spaceSeen)`
`protected void`	`lex_goto_eol()`
`int`	`lineno()`
`private int`	`magicCommentMarker(org.jruby.util.ByteList str, int begin)`
`private int`	`minus(boolean spaceSeen)`
`int`	`nextc()`
`int`	`nextToken()`
`int`	`p(int offset)`
`protected boolean`	`parseMagicComment(org.jruby.util.ByteList magicLine)`
`private int`	`parseNumber(int c)` Parse a number from the input stream.
`private int`	`parseQuote(int c)` What type/kind of quote are we dealing with?
`void`	`parser_prepare()`
`boolean`	`peek(int c)`
`private boolean`	`peek(int c, int n)`
`private int`	`percent(boolean spaceSeen)`
`private int`	`pipe()`
`private int`	`plus(boolean spaceSeen)`
`private void`	`printState()`
`private java.lang.String`	`printToken(int token)`
`void`	`pushback(int c)`
`private int`	`questionMark()`
`int`	`readCodepoint(int first, org.jcodings.Encoding encoding)`
`int`	`readEscape()`
`private void`	`readUTF8EscapeIntoBuffer(int codepoint, org.jruby.util.ByteList buffer, boolean stringLiteral)`
`int`	`readUTFEscape(org.jruby.util.ByteList buffer, boolean stringLiteral, boolean symbolLiteral)`
`void`	`readUTFEscapeRegexpLiteral(org.jruby.util.ByteList buffer)`
`void`	`resetStacks()`
`private int`	`rightBracket()`
`private int`	`rightCurly()`
`private int`	`rightParen()`
`private IRubyObject`	`scanEventValue(int token)`
`private int`	`scanHex(int count, boolean strict, java.lang.String errorMessage)` Read up to count hexadecimal digits.
`private char`	`scanHexLiteral(org.jruby.util.ByteList buffer, int count, boolean strict, java.lang.String errorMessage)` Read up to count hexadecimal digits and store those digits in a token buffer.
`private char`	`scanOct(int count)`
`protected void`	`set_file_encoding(int str, int send)`
`private void`	`setEncoding(org.jruby.util.ByteList name)`
`void`	`setEncoding(org.jcodings.Encoding encoding)`
`void`	`setLeftParenBegin(int value)`
`void`	`setParser(RipperParser parserSupport)` Parse must pass its support object for some check at bottom of yylex().
`void`	`setState(RipperLexer.LexState state)`
`void`	`setStrTerm(StrTerm strterm)`
`void`	`setValue(java.lang.Object yaccValue)`
`private int`	`singleQuote()`
`private int`	`slash(boolean spaceSeen)`
`private int`	`star(boolean spaceSeen)`
`private boolean`	`strncmp(org.jruby.util.ByteList one, org.jruby.util.ByteList two, int length)`
`private int`	`tilde()`
`int`	`token()` Last token read from the lexer at the end of a call to yylex()
`int`	`tokenAddMBC(int codepoint, org.jruby.util.ByteList buffer)`
`void`	`tokenAddMBCFromSrc(int c, org.jruby.util.ByteList buffer)`
`private java.lang.String`	`tokenToEventId(int token)`
`java.lang.Object`	`value()` Value of last token (if it is a token which has a value).
`void`	`warn(java.lang.String message)`
`void`	`warning(java.lang.String message)`
`boolean`	`was_bol()`
`boolean`	`whole_match_p(org.jruby.util.ByteList eos, boolean indent)`
`private int`	`yylex()` Returns the next token.
`private int`	`yylex2()`

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

Field Detail

UTF8_ENCODING

public static final org.jcodings.Encoding UTF8_ENCODING

USASCII_ENCODING

public static final org.jcodings.Encoding USASCII_ENCODING

ASCII8BIT_ENCODING

public static final org.jcodings.Encoding ASCII8BIT_ENCODING

END_MARKER

private static org.jruby.util.ByteList END_MARKER

BEGIN_DOC_MARKER

private static org.jruby.util.ByteList BEGIN_DOC_MARKER

END_DOC_MARKER

private static org.jruby.util.ByteList END_DOC_MARKER

CODING

private static org.jruby.util.ByteList CODING

map

private static final java.util.HashMap<java.lang.String,RipperLexer.Keyword> map

current_enc

private org.jcodings.Encoding current_enc

ignoreNextScanEvent
```
public boolean ignoreNextScanEvent
```

token
```
private int token
```

yaccValue
```
java.lang.Object yaccValue
```

identValue
```
java.lang.String identValue
```

src
```
private LexerSource src
```

parser
```
private RipperParser parser
```

lex_state
```
private RipperLexer.LexState lex_state
```

tokenBuffer

private java.lang.StringBuilder tokenBuffer

conditionState
```
private StackState conditionState
```

cmdArgumentState
```
private StackState cmdArgumentState
```

lex_strterm
```
private StrTerm lex_strterm
```

commandStart
```
public boolean commandStart
```

EOF
```
static final int EOF
```
See Also:

Constant Field Values

STR_FUNC_ESCAPE
```
static final int STR_FUNC_ESCAPE
```
See Also:

Constant Field Values

STR_FUNC_EXPAND
```
static final int STR_FUNC_EXPAND
```
See Also:

Constant Field Values

STR_FUNC_REGEXP
```
static final int STR_FUNC_REGEXP
```
See Also:

Constant Field Values

STR_FUNC_QWORDS
```
static final int STR_FUNC_QWORDS
```
See Also:

Constant Field Values

STR_FUNC_SYMBOL
```
static final int STR_FUNC_SYMBOL
```
See Also:

Constant Field Values

STR_FUNC_INDENT
```
static final int STR_FUNC_INDENT
```
See Also:

Constant Field Values

str_squote
```
private static final int str_squote
```
See Also:

Constant Field Values

str_dquote
```
private static final int str_dquote
```
See Also:

Constant Field Values

str_xquote
```
private static final int str_xquote
```
See Also:

Constant Field Values

str_regexp
```
private static final int str_regexp
```
See Also:

Constant Field Values

str_ssym
```
private static final int str_ssym
```
See Also:

Constant Field Values

str_dsym
```
private static final int str_dsym
```
See Also:

Constant Field Values

parenNest
```
private int parenNest
```

leftParenBegin
```
private int leftParenBegin
```

tokp
```
protected int tokp
```

lexb
```
protected org.jruby.util.ByteList lexb
```

lex_p
```
protected int lex_p
```

lex_pbeg
```
protected int lex_pbeg
```

lex_pend
```
protected int lex_pend
```

lex_lastline

protected org.jruby.util.ByteList lex_lastline

lex_nextline

private org.jruby.util.ByteList lex_nextline

__end__seen
```
private boolean __end__seen
```

eofp
```
protected boolean eofp
```

has_shebang
```
private boolean has_shebang
```

delayed

protected org.jruby.util.ByteList delayed

delayed_line
```
private int delayed_line
```

delayed_col
```
private int delayed_col
```

ruby_sourceline
```
private int ruby_sourceline
```

heredoc_end
```
private int heredoc_end
```

line_count
```
private int line_count
```

magicString

private static final java.lang.String magicString

See Also:: Constant Field Values

magicRegexp

private static final org.joni.Regex magicRegexp

mbcBuf
```
private byte[] mbcBuf
```

Constructor Detail

RipperLexer

public RipperLexer(RipperParser parser,
                   LexerSource src)

Method Detail

getEncoding

public org.jcodings.Encoding getEncoding()

getFloatToken

private int getFloatToken(java.lang.String number)

isVerbose
```
public boolean isVerbose()
```

warn

public void warn(java.lang.String message)

warning

public void warning(java.lang.String message)

getKeyword

public static RipperLexer.Keyword getKeyword(java.lang.String str)

incrementParenNest
```
public int incrementParenNest()
```

getLeftParenBegin
```
public int getLeftParenBegin()
```

setLeftParenBegin

public void setLeftParenBegin(int value)

hasStarted
```
public boolean hasStarted()
```
Has lexing started yet?

isEndSeen
```
public boolean isEndSeen()
```

flush_string_content

protected void flush_string_content(org.jcodings.Encoding encoding)

p
```
public int p(int offset)
```

nextc
```
public int nextc()
```

peek
```
public boolean peek(int c)
```

peek

private boolean peek(int c,
                     int n)

lex_goto_eol
```
protected void lex_goto_eol()
```

column
```
public int column()
```

lineno
```
public int lineno()
```

dispatchHeredocEnd
```
public void dispatchHeredocEnd()
```

was_bol
```
public boolean was_bol()
```

strncmp

private boolean strncmp(org.jruby.util.ByteList one,
                        org.jruby.util.ByteList two,
                        int length)

pushback
```
public void pushback(int c)
```

flush
```
private void flush()
```

compile_error

public void compile_error(java.lang.String message)

readCodepoint

public int readCodepoint(int first,
                         org.jcodings.Encoding encoding)
                  throws java.io.IOException

Throws:: java.io.IOException

heredoc_restore

public void heredoc_restore(HeredocTerm here)

parser_prepare
```
public void parser_prepare()
```

nextToken

public int nextToken()
              throws java.io.IOException

Throws:: java.io.IOException

getIdent
```
public java.lang.String getIdent()
```

token
```
public int token()
```
Last token read from the lexer at the end of a call to yylex()

Returns:

last token read

getTokenBuffer

public java.lang.StringBuilder getTokenBuffer()

value
```
public java.lang.Object value()
```
Value of last token (if it is a token which has a value).

Returns:

value of last value-laden token

whole_match_p

public boolean whole_match_p(org.jruby.util.ByteList eos,
                             boolean indent)

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

setParser
```
public void setParser(RipperParser parserSupport)
```
Parse must pass its support object for some check at bottom of yylex(). Ruby does it this way as well (i.e. a little parsing logic in the lexer).

Parameters:

parserSupport -

setEncoding

private void setEncoding(org.jruby.util.ByteList name)

setEncoding

public void setEncoding(org.jcodings.Encoding encoding)

getStrTerm
```
public StrTerm getStrTerm()
```

setStrTerm

public void setStrTerm(StrTerm strterm)

resetStacks
```
public void resetStacks()
```

printState
```
private void printState()
```

setState

public void setState(RipperLexer.LexState state)

getCmdArgumentState

public StackState getCmdArgumentState()

getConditionState
```
public StackState getConditionState()
```

setValue

public void setValue(java.lang.Object yaccValue)

isNext_identchar

private boolean isNext_identchar()
                          throws java.io.IOException

Throws:: java.io.IOException

isBEG
```
private boolean isBEG()
```

isEND
```
private boolean isEND()
```

isARG
```
private boolean isARG()
```

isLabelPossible

private boolean isLabelPossible(boolean commandState)

isSpaceArg

private boolean isSpaceArg(int c,
                           boolean spaceSeen)

determineExpressionState

private void determineExpressionState()

getInteger

private java.lang.Object getInteger(java.lang.String value,
                                    int radix)

isHexChar
```
static boolean isHexChar(int c)
```
Parameters:

c - the character to test

Returns:

true if character is a hex value (0-9a-f)

isOctChar
```
static boolean isOctChar(int c)
```
Parameters:

c - the character to test

Returns:

true if character is an octal value (0-7)

isIdentifierChar
```
public boolean isIdentifierChar(int c)
```
This is a valid character for an identifier?

Parameters:

c - is character to be compared

Returns:

whether c is an identifier or not mri: is_identchar

isMultiByteChar
```
protected boolean isMultiByteChar(int c)
```
Is this a multibyte character from a multibyte encoding?

Parameters:

c -

Returns:

whether c is an multibyte char or not

createStr

public IRubyObject createStr(org.jruby.util.ByteList buffer,
                             int flags)

parseQuote
```
private int parseQuote(int c)
                throws java.io.IOException
```
What type/kind of quote are we dealing with?

Parameters:

c - first character the the quote construct

Returns:

a token that specifies the quote type

Throws:

java.io.IOException

hereDocumentIdentifier

private int hereDocumentIdentifier()
                            throws java.io.IOException

Throws:: java.io.IOException

arg_ambiguous
```
private void arg_ambiguous()
```

magicCommentMarker

private int magicCommentMarker(org.jruby.util.ByteList str,
                               int begin)

comment_at_top
```
private boolean comment_at_top()
```

parseMagicComment

protected boolean parseMagicComment(org.jruby.util.ByteList magicLine)
                             throws java.io.IOException

Throws:: java.io.IOException

set_file_encoding

protected void set_file_encoding(int str,
                                 int send)

printToken

private java.lang.String printToken(int token)

hasScanEvent
```
public boolean hasScanEvent()
```

dispatchDelayedToken

public void dispatchDelayedToken(int token)

dispatchIgnoredScanEvent

public void dispatchIgnoredScanEvent(int token)

dispatchScanEvent

public void dispatchScanEvent(int token)

scanEventValue

private IRubyObject scanEventValue(int token)

tokenToEventId

private java.lang.String tokenToEventId(int token)

yylex2

private int yylex2()
            throws java.io.IOException

Throws:: java.io.IOException

yylex
```
private int yylex()
           throws java.io.IOException
```
Returns the next token. Also sets yyVal is needed.

Returns:

Description of the Returned Value

Throws:

java.io.IOException

identifierToken

private int identifierToken(RipperLexer.LexState last_state,
                            int result,
                            java.lang.String value)

getIdentifier

private int getIdentifier(int first)
                   throws java.io.IOException

Throws:: java.io.IOException

ampersand

private int ampersand(boolean spaceSeen)
               throws java.io.IOException

Throws:: java.io.IOException

at

private int at()
        throws java.io.IOException

Throws:: java.io.IOException

backtick

private int backtick(boolean commandState)
              throws java.io.IOException

Throws:: java.io.IOException

bang

private int bang()
          throws java.io.IOException

Throws:: java.io.IOException

caret

private int caret()
           throws java.io.IOException

Throws:: java.io.IOException

colon

private int colon(boolean spaceSeen)
           throws java.io.IOException

Throws:: java.io.IOException

comma

private int comma(int c)
           throws java.io.IOException

Throws:: java.io.IOException

doKeyword

private int doKeyword(RipperLexer.LexState state)

dollar

private int dollar()
            throws java.io.IOException

Throws:: java.io.IOException

dot

private int dot()
         throws java.io.IOException

Throws:: java.io.IOException

doubleQuote

private int doubleQuote()
                 throws java.io.IOException

Throws:: java.io.IOException

greaterThan

private int greaterThan()
                 throws java.io.IOException

Throws:: java.io.IOException

identifier

private int identifier(int c,
                       boolean commandState)
                throws java.io.IOException

Throws:: java.io.IOException

leftBracket

private int leftBracket(boolean spaceSeen)
                 throws java.io.IOException

Throws:: java.io.IOException

leftCurly
```
private int leftCurly()
```

leftParen

private int leftParen(boolean spaceSeen)
               throws java.io.IOException

Throws:: java.io.IOException

lessThan

private int lessThan(boolean spaceSeen)
              throws java.io.IOException

Throws:: java.io.IOException

minus

private int minus(boolean spaceSeen)
           throws java.io.IOException

Throws:: java.io.IOException

percent

private int percent(boolean spaceSeen)
             throws java.io.IOException

Throws:: java.io.IOException

pipe

private int pipe()
          throws java.io.IOException

Throws:: java.io.IOException

plus

private int plus(boolean spaceSeen)
          throws java.io.IOException

Throws:: java.io.IOException

questionMark

private int questionMark()
                  throws java.io.IOException

Throws:: java.io.IOException

rightBracket
```
private int rightBracket()
```

rightCurly
```
private int rightCurly()
```

rightParen
```
private int rightParen()
```

singleQuote

private int singleQuote()
                 throws java.io.IOException

Throws:: java.io.IOException

slash

private int slash(boolean spaceSeen)
           throws java.io.IOException

Throws:: java.io.IOException

star

private int star(boolean spaceSeen)
          throws java.io.IOException

Throws:: java.io.IOException

tilde

private int tilde()
           throws java.io.IOException

Throws:: java.io.IOException

parseNumber
```
private int parseNumber(int c)
                 throws java.io.IOException
```
Parse a number from the input stream.

Parameters:

c - The first character of the number.

Returns:

A int constant wich represents a token.

Throws:

java.io.IOException

getNumberToken

private int getNumberToken(java.lang.String number,
                           boolean isFloat,
                           int nondigit)

readUTFEscapeRegexpLiteral

public void readUTFEscapeRegexpLiteral(org.jruby.util.ByteList buffer)
                                throws java.io.IOException

Throws:: java.io.IOException

tokenAddMBC

public int tokenAddMBC(int codepoint,
                       org.jruby.util.ByteList buffer)

tokenAddMBCFromSrc

public void tokenAddMBCFromSrc(int c,
                               org.jruby.util.ByteList buffer)
                        throws java.io.IOException

Throws:: java.io.IOException

readUTFEscape

public int readUTFEscape(org.jruby.util.ByteList buffer,
                         boolean stringLiteral,
                         boolean symbolLiteral)
                  throws java.io.IOException

Throws:: java.io.IOException

readUTF8EscapeIntoBuffer

private void readUTF8EscapeIntoBuffer(int codepoint,
                                      org.jruby.util.ByteList buffer,
                                      boolean stringLiteral)

readEscape

public int readEscape()
               throws java.io.IOException

Throws:: java.io.IOException

scanHexLiteral
```
private char scanHexLiteral(org.jruby.util.ByteList buffer,
                            int count,
                            boolean strict,
                            java.lang.String errorMessage)
                     throws java.io.IOException
```
Read up to count hexadecimal digits and store those digits in a token buffer. If strict is provided then count number of hex digits must be present. If no digits can be read a syntax exception will be thrown. This will also return the codepoint as a value so codepoint ranges can be checked.

Throws:

java.io.IOException

scanHex
```
private int scanHex(int count,
                    boolean strict,
                    java.lang.String errorMessage)
             throws java.io.IOException
```
Read up to count hexadecimal digits. If strict is provided then count number of hex digits must be present. If no digits can be read a syntax exception will be thrown.

Throws:

java.io.IOException

scanOct

private char scanOct(int count)
              throws java.io.IOException

Throws:: java.io.IOException

Class RipperLexer

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

UTF8_ENCODING

USASCII_ENCODING

ASCII8BIT_ENCODING

END_MARKER

BEGIN_DOC_MARKER

END_DOC_MARKER

CODING

map

current_enc

ignoreNextScanEvent

token

yaccValue

identValue

src

parser

lex_state

tokenBuffer

conditionState

cmdArgumentState

lex_strterm

commandStart

EOF

STR_FUNC_ESCAPE

STR_FUNC_EXPAND

STR_FUNC_REGEXP

STR_FUNC_QWORDS

STR_FUNC_SYMBOL

STR_FUNC_INDENT

str_squote

str_dquote

str_xquote

str_regexp

str_ssym

str_dsym

parenNest

leftParenBegin

tokp

lexb

lex_p

lex_pbeg

lex_pend

lex_lastline

lex_nextline

__end__seen

eofp

has_shebang

delayed

delayed_line

delayed_col

ruby_sourceline

heredoc_end

line_count

magicString

magicRegexp

mbcBuf

Constructor Detail

RipperLexer

Method Detail

getEncoding

getFloatToken

isVerbose

warn

warning

getKeyword

incrementParenNest

getLeftParenBegin

setLeftParenBegin

hasStarted

isEndSeen

flush_string_content

p

nextc

peek

endseen