StringLiteralLexer (Unofficial IntelliJ Community Edition API docs)

java.lang.Object
- com.intellij.lexer.Lexer
- - com.intellij.lexer.LexerBase
  - - com.intellij.lexer.StringLiteralLexer

public class StringLiteralLexer
extends LexerBase

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.lang.CharSequence`	`myBuffer`
`protected int`	`myBufferEnd`
`protected int`	`myEnd`
`protected IElementType`	`myOriginalLiteralToken`
`protected char`	`myQuoteChar`
`protected int`	`myStart`
`static char`	`NO_QUOTE_CHAR`

Constructor Summary

Constructors
Constructor and Description
`StringLiteralLexer(char quoteChar, IElementType originalLiteralToken)`
`StringLiteralLexer(char quoteChar, IElementType originalLiteralToken, boolean canEscapeEolOrFramingSpaces, java.lang.String additionalValidEscapes)`
`StringLiteralLexer(char quoteChar, IElementType originalLiteralToken, boolean canEscapeEolOrFramingSpaces, java.lang.String additionalValidEscapes, boolean allowOctal, boolean allowHex)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`advance()` Advances the lexer to the next token.
`int`	`getBufferEnd()` Returns the offset at which the lexer will stop lexing.
`java.lang.CharSequence`	`getBufferSequence()` Returns the buffer sequence over which the lexer is running.
`int`	`getState()` Returns the current state of the lexer.
`int`	`getTokenEnd()` Returns the end offset of the current token.
`int`	`getTokenStart()` Returns the start offset of the current token.
`IElementType`	`getTokenType()` Returns the token at the current position of the lexer or `null` if lexing is finished.
`protected IElementType`	`getUnicodeEscapeSequenceType()`
`protected IElementType`	`handleSingleSlashEscapeSequence()`
`protected int`	`locateAdditionalEscapeSequence(int start, int indexOfCharAfterSlash)` Locates the end of an additional (non-standard) escape sequence.
`protected int`	`locateHexEscapeSequence(int start, int i)`
`protected int`	`locateUnicodeEscapeSequence(int start, int i)`
`protected boolean`	`shouldAllowSlashZero()`
`void`	`start(java.lang.CharSequence buffer, int startOffset, int endOffset, int initialState)` Prepare for lexing character data from `buffer` passed.
`java.lang.String`	`toString()`

Methods inherited from class com.intellij.lexer.LexerBase
getCurrentPosition, restore

Methods inherited from class com.intellij.lexer.Lexer
getTokenSequence, getTokenText, start, start

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

- Field Detail
  - NO_QUOTE_CHAR
```
public static final char NO_QUOTE_CHAR
```
    See Also:
    
    Constant Field Values
  - myBuffer
```
protected java.lang.CharSequence myBuffer
```
  - myStart
```
protected int myStart
```
  - myEnd
```
protected int myEnd
```
  - myBufferEnd
```
protected int myBufferEnd
```
  - myQuoteChar
```
protected final char myQuoteChar
```
  - myOriginalLiteralToken
```
protected final IElementType myOriginalLiteralToken
```
- Constructor Detail
  - StringLiteralLexer
```
public StringLiteralLexer(char quoteChar,
                          IElementType originalLiteralToken)
```
  - StringLiteralLexer
```
public StringLiteralLexer(char quoteChar,
                          IElementType originalLiteralToken,
                          boolean canEscapeEolOrFramingSpaces,
                          java.lang.String additionalValidEscapes)
```
  - StringLiteralLexer
```
public StringLiteralLexer(char quoteChar,
                          IElementType originalLiteralToken,
                          boolean canEscapeEolOrFramingSpaces,
                          java.lang.String additionalValidEscapes,
                          boolean allowOctal,
                          boolean allowHex)
```
    Parameters:
    
    canEscapeEolOrFramingSpaces - true if following sequences are acceptable:
    * '\' at the end of the buffer (meaning escaped end of line)
    * '\ ' (escaped space) at the beginning and ath the end of the buffer (meaning escaped space, to avoid auto trimming on load)
- Method Detail
  - start
```
public void start(java.lang.CharSequence buffer,
                  int startOffset,
                  int endOffset,
                  int initialState)
```
    Description copied from class: Lexer
    
    Prepare for lexing character data from buffer passed. Internal lexer state is supposed to be initialState. It is guaranteed that the value of initialState is the same as returned by Lexer.getState() method of this lexer at condition startOffset=getTokenStart(). This method is used to incrementally re-lex changed characters using lexing data acquired from this particular lexer sometime in the past.
    
    Specified by:
    
    start in class Lexer
    
    Parameters:
    
    buffer - character data for lexing.
    
    startOffset - offset to start lexing from
    
    endOffset - offset to stop lexing at
    
    initialState - the initial state of the lexer.
  - getState
```
public int getState()
```
    Description copied from class: Lexer
    
    Returns the current state of the lexer.
    
    Specified by:
    
    getState in class Lexer
    
    Returns:
    
    the lexer state.
  - getTokenType
```
public IElementType getTokenType()
```
    Description copied from class: Lexer
    
    Returns the token at the current position of the lexer or null if lexing is finished.
    
    Specified by:
    
    getTokenType in class Lexer
    
    Returns:
    
    the current token.
  - shouldAllowSlashZero
```
protected boolean shouldAllowSlashZero()
```
  - handleSingleSlashEscapeSequence
```
protected IElementType handleSingleSlashEscapeSequence()
```
  - getUnicodeEscapeSequenceType
```
protected IElementType getUnicodeEscapeSequenceType()
```
  - getTokenStart
```
public int getTokenStart()
```
    Description copied from class: Lexer
    
    Returns the start offset of the current token.
    
    Specified by:
    
    getTokenStart in class Lexer
    
    Returns:
    
    the current token start offset.
  - getTokenEnd
```
public int getTokenEnd()
```
    Description copied from class: Lexer
    
    Returns the end offset of the current token.
    
    Specified by:
    
    getTokenEnd in class Lexer
    
    Returns:
    
    the current token end offset.
  - locateHexEscapeSequence
```
protected int locateHexEscapeSequence(int start,
                                      int i)
```
  - locateUnicodeEscapeSequence
```
protected int locateUnicodeEscapeSequence(int start,
                                          int i)
```
  - locateAdditionalEscapeSequence
```
protected int locateAdditionalEscapeSequence(int start,
                                             int indexOfCharAfterSlash)
```
    Locates the end of an additional (non-standard) escape sequence. The sequence is considered to begin with a backslash symbol located at the start index of the lexer's buffer.
    
    Override this method if your language supports non-standard escape sequences. For example, in Go language Unicode escapes look like '\U12345678'. To locate this escape sequence, the implementation should check that indexOfCharAfterSlash points to the 'U' symbol in the buffer and return start + 8 (or the end index of the buffer if it is too short). Otherwise, the implementations should return -1 to indicate that the current buffer starting at the index start doesn't represent an additional escape sequence.
    
    When overriding this method, you most likely will need to also override getTokenType() to return proper type for the sequences located here.
  - advance
```
public void advance()
```
    Description copied from class: Lexer
    
    Advances the lexer to the next token.
    
    Specified by:
    
    advance in class Lexer
  - getBufferSequence
```
public java.lang.CharSequence getBufferSequence()
```
    Description copied from class: Lexer
    
    Returns the buffer sequence over which the lexer is running. This method should return the same buffer instance which was passed to the start() method.
    
    Specified by:
    
    getBufferSequence in class Lexer
    
    Returns:
    
    the lexer buffer.
  - getBufferEnd
```
public int getBufferEnd()
```
    Description copied from class: Lexer
    
    Returns the offset at which the lexer will stop lexing. This method should return the length of the buffer or the value passed in the endOffset parameter to the start() method.
    
    Specified by:
    
    getBufferEnd in class Lexer
    
    Returns:
    
    the lexing end offset
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class StringLiteralLexer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.intellij.lexer.LexerBase

Methods inherited from class com.intellij.lexer.Lexer

Methods inherited from class java.lang.Object

Field Detail

NO_QUOTE_CHAR

myBuffer

myStart

myEnd

myBufferEnd

myQuoteChar

myOriginalLiteralToken

Constructor Detail

StringLiteralLexer

StringLiteralLexer

StringLiteralLexer

Method Detail

start

getState

getTokenType

shouldAllowSlashZero

handleSingleSlashEscapeSequence

getUnicodeEscapeSequenceType

getTokenStart

getTokenEnd

locateHexEscapeSequence

locateUnicodeEscapeSequence

locateAdditionalEscapeSequence

advance

getBufferSequence

getBufferEnd

toString