AbstractBashLexer (ShellCheck Analyzer 2.0.0 API)

java.lang.Object
- com.github.sbaudoin.sonar.plugins.shellcheck.lexer.AbstractBashLexer

Direct Known Subclasses:

BashLexerBase
```
public abstract class AbstractBashLexer
extends Object
```
Abstract class the JFlex Bash lexer will extend to inherit methods required to properly analyze Bash scripts Heavily inspired by IntelliJ IDEA Bash Support plugin

See Also:

the IntelliJ IDEA Bash Support plugin

Constructor Summary

Constructors
Constructor and Description

AbstractBashLexer()

Constructors
Constructor and Description
`AbstractBashLexer()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`backToPreviousState()` Goes back to the previous state of the lexer.
`protected void`	`decOpenParenthesisCount()` Decrements the open parenthesis counter
`protected void`	`enterHereStringContent()` Notifies that the lexer is entering a here-string content
`protected void`	`goToState(int newState)` Goes to the given state and stores the previous state on the stack of states.
`protected HeredocLexingState`	`heredocState()` Returns the `HeredocLexingState` object used by the lexer to deal with here-docs
`protected void`	`incOpenParenthesisCount()` Increments the open parenthesis counter
`boolean`	`isBash4()` Tells if the lexer is applying the Bash 4 syntax to analyze the code
`protected boolean`	`isEmptyConditionalCommand()` Tells if an empty conditional command (`[ ]`) was met or not
`protected boolean`	`isInCaseBody()` Tells if the lexer is currently in a case statement
`protected boolean`	`isInHereStringContent()` Tells if the lexer is currently analyzing a in-here string
`protected boolean`	`isInState(int state)` Tells if the current lexical state is the passed state (possibly nesting/parent stated)
`protected boolean`	`isParamExpansionHash()` Tells if the lexer is currently considering a parameter expansion based on `#` (e.g.
`protected boolean`	`isParamExpansionOther()` Tells if the current token is a parameter expansion marker other than `#` (e.g.
`protected boolean`	`isParamExpansionWord()` Tells if the current lexer token is a parameter expansion word
`protected void`	`leaveHereStringContent()` Sets the in-here string state to `false`
`protected int`	`openParenthesisCount()` Returns the open parenthesis counter, i.e.
`protected void`	`popStates(int lastStateToPop)` Pops the passed state from the stack of nested states.
`protected void`	`setEmptyConditionalCommand(boolean emptyConditionalCommand)` Sets the flag that tracks empty conditional commands
`protected void`	`setInCaseBody(boolean inCaseBody)` Sets the flag that tells if the lexer is in a case statement
`protected void`	`setParamExpansionHash(boolean paramExpansionHash)` Sets the flag that tracks parameter expansion based on `#`
`protected void`	`setParamExpansionOther(boolean paramExpansionOther)` Sets the flag that tracks parameter expansion marker other than `#`
`protected void`	`setParamExpansionWord(boolean paramExpansionWord)` Sets the flag that tracks parameter expansion words
`protected StringLexingstate`	`stringParsingState()` Returns the `StringLexingState` object used by the lexer to deal with strings
`protected Token`	`token(TokenType type)` Create and return a `Token` of given type.
`protected Token`	`token(TokenType type, int start, int length)` Create and return a Token of given type from start with length offset is added to start
`protected abstract void`	`yybegin(int newState)` Enters a new lexical state.
`protected abstract int`	`yychar()` Returns the char number from beginning of input stream.
`protected abstract char`	`yycharat(int pos)` Returns the character at position `pos` from the matched text.
`protected abstract int`	`yycolumn()` Returns the column number from beginning of the line (starting from 0).
`protected abstract int`	`yylength()` Returns the length of the matched text region.
`protected abstract Token`	`yylex()` This is called to return the next Token from the input `Reader`
`protected abstract int`	`yyline()` Returns the start line number from beginning of input stream (starting from 0).
`protected abstract void`	`yyreset(Reader reader)` This will be called to reset the the lexer.
`protected abstract int`	`yystate()` Returns the current lexical state
`protected abstract String`	`yytext()` Returns the text matched by the current regular expression.

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

- Constructor Detail
  - AbstractBashLexer
```
public AbstractBashLexer()
```
- Method Detail
  - token
```
protected Token token(TokenType type,
                      int start,
                      int length)
```
    Create and return a Token of given type from start with length offset is added to start
    
    Parameters:
    
    type - the token type
    
    start - the offset at which the token starts
    
    length - the token length
    
    Returns:
    
    a Token built from the passed parameters
  - token
```
protected Token token(TokenType type)
```
    Create and return a Token of given type. The start offset is obtained from yychar(), the length from yylength(), the line number from yyline() and the column number from yycolumn().
    
    Parameters:
    
    type - the token type
    
    Returns:
    
    a Token of the given type
  - yyreset
```
protected abstract void yyreset(Reader reader)
```
    This will be called to reset the the lexer. This is created automatically by JFlex.
    
    Parameters:
    
    reader - a reader to the content to be analyzed
  - yylex
```
protected abstract Token yylex()
                        throws IOException
```
    This is called to return the next Token from the input Reader
    
    Returns:
    
    next token, or null if no more tokens.
    
    Throws:
    
    IOException - if the input reader cannot be read
  - yycharat
```
protected abstract char yycharat(int pos)
```
    Returns the character at position pos from the matched text. It is equivalent to yytext().charAt(pos), but faster.
    
    Parameters:
    
    pos - the position of the character to fetch. A value from 0 to yylength()-1.
    
    Returns:
    
    the character at position pos
  - yylength
```
protected abstract int yylength()
```
    Returns the length of the matched text region. This method is automatically implemented by JFlex lexers.
    
    Returns:
    
    the length of the matched text region
  - yytext
```
protected abstract String yytext()
```
    Returns the text matched by the current regular expression. This method is automatically implemented by JFlex lexers.
    
    Returns:
    
    the text matched by the current regular expression
  - yychar
```
protected abstract int yychar()
```
    Returns the char number from beginning of input stream. This is NOT implemented by JFlex, so the code must be added to create this and return the private yychar field.
    
    Returns:
    
    the char number from beginning of input stream
  - yyline
```
protected abstract int yyline()
```
    Returns the start line number from beginning of input stream (starting from 0). This is NOT implemented by JFlex, so the code must be added to create this and return the private yyline field.
    
    Returns:
    
    the start line number from beginning of input stream (starting from 0)
  - yycolumn
```
protected abstract int yycolumn()
```
    Returns the column number from beginning of the line (starting from 0). This is NOT implemented by JFlex, so the code must be added to create this and return the private yycolumn field
    
    Returns:
    
    the column number from beginning of the line (starting from 0)
  - yybegin
```
protected abstract void yybegin(int newState)
```
    Enters a new lexical state. This method is automatically implemented by JFlex lexers.
    
    Parameters:
    
    newState - the new nexical state
  - yystate
```
protected abstract int yystate()
```
    Returns the current lexical state
    
    Returns:
    
    the current lexical state
  - isInHereStringContent
```
protected boolean isInHereStringContent()
```
    Tells if the lexer is currently analyzing a in-here string
    
    Returns:
    
    true if the lexer is analyzing a in-here string, false if not
  - leaveHereStringContent
```
protected void leaveHereStringContent()
```
    Sets the in-here string state to false
  - backToPreviousState
```
protected void backToPreviousState()
```
    Goes back to the previous state of the lexer. If there is no previous state then YYINITIAL, the initial state, is chosen.
  - isInState
```
protected boolean isInState(int state)
```
    Tells if the current lexical state is the passed state (possibly nesting/parent stated)
    
    Parameters:
    
    state - a lexical state to test
    
    Returns:
    
    true if the passed state is in the current lexical state stack, false if not
  - heredocState
```
protected HeredocLexingState heredocState()
```
    Returns the HeredocLexingState object used by the lexer to deal with here-docs
    
    Returns:
    
    the HeredocLexingState object used by the lexer to deal with here-docs
  - goToState
```
protected void goToState(int newState)
```
    Goes to the given state and stores the previous state on the stack of states. This makes it possible to have several levels of lexing, e.g. for $(( 1+ $(echo 3) )).
    
    Parameters:
    
    newState - the new state to go to
  - stringParsingState
```
protected StringLexingstate stringParsingState()
```
    Returns the StringLexingState object used by the lexer to deal with strings
    
    Returns:
    
    the StringLexingState object used by the lexer to deal with strings
  - isEmptyConditionalCommand
```
protected boolean isEmptyConditionalCommand()
```
    Tells if an empty conditional command ([ ]) was met or not
    
    Returns:
    
    true if an empty conditional command ([ ]) was met, false if not
  - setEmptyConditionalCommand
```
protected void setEmptyConditionalCommand(boolean emptyConditionalCommand)
```
    Sets the flag that tracks empty conditional commands
    
    Parameters:
    
    emptyConditionalCommand - the value for the empty conditional command flag
  - decOpenParenthesisCount
```
protected void decOpenParenthesisCount()
```
    Decrements the open parenthesis counter
  - incOpenParenthesisCount
```
protected void incOpenParenthesisCount()
```
    Increments the open parenthesis counter
  - openParenthesisCount
```
protected int openParenthesisCount()
```
    Returns the open parenthesis counter, i.e. the parenthesis nesting level
    
    Returns:
    
    the open parenthesis counter
  - enterHereStringContent
```
protected void enterHereStringContent()
```
    Notifies that the lexer is entering a here-string content
  - isParamExpansionHash
```
protected boolean isParamExpansionHash()
```
    Tells if the lexer is currently considering a parameter expansion based on # (e.g. ${parameter##word})
    
    Returns:
    
    true if the lexer is currently analyzing parameter expansion with # or not (false)
  - setParamExpansionHash
```
protected void setParamExpansionHash(boolean paramExpansionHash)
```
    Sets the flag that tracks parameter expansion based on #
    
    Parameters:
    
    paramExpansionHash - the new value for the flag
  - isParamExpansionWord
```
protected boolean isParamExpansionWord()
```
    Tells if the current lexer token is a parameter expansion word
    
    Returns:
    
    true if the current token is a parameter expansion word, false if not
  - setParamExpansionWord
```
protected void setParamExpansionWord(boolean paramExpansionWord)
```
    Sets the flag that tracks parameter expansion words
    
    Parameters:
    
    paramExpansionWord - the new value for the flag
  - isParamExpansionOther
```
protected boolean isParamExpansionOther()
```
    Tells if the current token is a parameter expansion marker other than # (e.g. %)
    
    Returns:
    
    true if the current token is a parameter expansion other that a word, false if not
  - setParamExpansionOther
```
protected void setParamExpansionOther(boolean paramExpansionOther)
```
    Sets the flag that tracks parameter expansion marker other than #
    
    Parameters:
    
    paramExpansionOther - the new value for the flag
  - popStates
```
protected void popStates(int lastStateToPop)
```
    Pops the passed state from the stack of nested states. Child states are also popped out.
    
    Parameters:
    
    lastStateToPop - the state to be popped
  - isBash4
```
public boolean isBash4()
```
    Tells if the lexer is applying the Bash 4 syntax to analyze the code
    
    Returns:
    
    true if the lexer is usgin the Bash 4 grammar, false if not
  - isInCaseBody
```
protected boolean isInCaseBody()
```
    Tells if the lexer is currently in a case statement
    
    Returns:
    
    true if the lexer is in a case statement, false if not
  - setInCaseBody
```
protected void setInCaseBody(boolean inCaseBody)
```
    Sets the flag that tells if the lexer is in a case statement
    
    Parameters:
    
    inCaseBody - the new value for the flag

Class AbstractBashLexer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractBashLexer

Method Detail

token

token

yyreset

yylex

yycharat

yylength

yytext

yychar

yyline

yycolumn

yybegin

yystate

isInHereStringContent

leaveHereStringContent

backToPreviousState

isInState

heredocState

goToState

stringParsingState

isEmptyConditionalCommand

setEmptyConditionalCommand

decOpenParenthesisCount

incOpenParenthesisCount

openParenthesisCount

enterHereStringContent

isParamExpansionHash

setParamExpansionHash

isParamExpansionWord

setParamExpansionWord

isParamExpansionOther

setParamExpansionOther

popStates

isBash4

isInCaseBody

setInCaseBody