java.lang.Object
- edu.umd.cs.findbugs.ba.bcp.PatternMatcher.State

Enclosing class:

PatternMatcher
```
private class PatternMatcher.State
extends java.lang.Object
```
Object representing the current state of the matching algorithm. Provides convenient methods to implement the various steps of the algorithm.

Field Summary

Fields
Modifier and Type	Field	Description
`private BasicBlock`	`basicBlock`
`private BindingSet`	`bindingSet`
`private boolean`	`canFork`
`private PatternElementMatch`	`currentMatch`
`private BasicBlock.InstructionIterator`	`instructionIterator`
`private int`	`matchCount`
`private int`	`parentPath`
`private int`	`path`
`private PatternElement`	`patternElement`

Constructor Summary

Constructors
Constructor	Description
`State(BasicBlock basicBlock, BasicBlock.InstructionIterator instructionIterator, PatternElement patternElement)`	Constructor.
`State(PatternMatcher.State parent, BasicBlock basicBlock, BasicBlock.InstructionIterator instructionIterator, PatternElement patternElement, int matchCount, PatternElementMatch currentMatch, BindingSet bindingSet, boolean canFork)`	Constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`PatternMatcher.State`	`advanceToNextElement()`	Try to produce a new state that will finish matching the current element and start matching the next element.
`PatternMatcher.State`	`advanceToSuccessor(Edge edge, MatchResult matchResult)`	Return a new State for continuing the overall pattern match in a successor basic block.
`boolean`	`canAdvanceToNextBasicBlock()`	Determine if it is possible to continue matching in a successor basic block.
`boolean`	`currentElementCanContinue()`	Determine if the current pattern element can continue to match instructions.
`java.lang.Iterable<PatternMatcher.State>`	`dominatedInstructionStateIterable()`	Return Iterator over states representing dominated instructions that continue the match.
`PatternMatcher.State`	`duplicate()`	Make an exact copy of this object.
`BasicBlock`	`getBasicBlock()`	Get basic block.
`PatternElementMatch`	`getCurrentMatch()`	Get current pattern element match.
`org.apache.bcel.generic.InstructionHandle`	`getLastMatchedInstruction()`	Get most recently matched instruction.
`PatternElement`	`getPatternElement()`	Get current pattern element.
`ByteCodePatternMatch`	`getResult()`	Get a ByteCodePatternMatch representing the complete match.
`boolean`	`isComplete()`	Determine if the match is complete.
`boolean`	`lookForDominatedInstruction()`	Determine if we need to look for a dominated instruction at this point in the search.
`private MatchResult`	`matchLocation(Location location)`
`MatchResult`	`matchNextInBasicBlock()`	Match current pattern element with next instruction in basic block.
`boolean`	`moreInstructionsInBasicBlock()`	Determine if there are more instructions in the same basic block.
`java.lang.String`	`toString()`

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

Field Detail

basicBlock
```
private final BasicBlock basicBlock
```

instructionIterator

private final BasicBlock.InstructionIterator instructionIterator

patternElement

private final PatternElement patternElement

matchCount
```
private int matchCount
```

currentMatch

private PatternElementMatch currentMatch

bindingSet
```
private BindingSet bindingSet
```

canFork
```
private boolean canFork
```

parentPath
```
private final int parentPath
```

path
```
private final int path
```

Constructor Detail

State
```
public State(BasicBlock basicBlock,
             BasicBlock.InstructionIterator instructionIterator,
             PatternElement patternElement)
```
Constructor. Builds the start state.

Parameters:

basicBlock - the initial basic block

instructionIterator - the instructionIterator indicating where to start matching

patternElement - the first PatternElement of the pattern

State

public State(@Nullable
             PatternMatcher.State parent,
             BasicBlock basicBlock,
             BasicBlock.InstructionIterator instructionIterator,
             PatternElement patternElement,
             int matchCount,
             @Nullable
             PatternElementMatch currentMatch,
             @Nullable
             BindingSet bindingSet,
             boolean canFork)

Constructor.

Method Detail
- toString
```
public java.lang.String toString()
```
  Overrides:
  
  toString in class java.lang.Object
- duplicate
```
public PatternMatcher.State duplicate()
```
  Make an exact copy of this object.
- getBasicBlock
```
public BasicBlock getBasicBlock()
```
  Get basic block.
- getPatternElement
```
public PatternElement getPatternElement()
```
  Get current pattern element.
- getCurrentMatch
```
public PatternElementMatch getCurrentMatch()
```
  Get current pattern element match.
- isComplete
```
public boolean isComplete()
```
  Determine if the match is complete.
- getResult
```
public ByteCodePatternMatch getResult()
```
  Get a ByteCodePatternMatch representing the complete match.
- advanceToNextElement
```
public PatternMatcher.State advanceToNextElement()
```
  Try to produce a new state that will finish matching the current element and start matching the next element. Returns null if the current element is not complete.
- currentElementCanContinue
```
public boolean currentElementCanContinue()
```
  Determine if the current pattern element can continue to match instructions.
- moreInstructionsInBasicBlock
```
public boolean moreInstructionsInBasicBlock()
```
  Determine if there are more instructions in the same basic block.
- matchNextInBasicBlock
```
public MatchResult matchNextInBasicBlock()
                                  throws DataflowAnalysisException
```
  Match current pattern element with next instruction in basic block. Returns MatchResult if match succeeds, null otherwise.
  
  Throws:
  
  DataflowAnalysisException
- canAdvanceToNextBasicBlock
```
public boolean canAdvanceToNextBasicBlock()
```
  Determine if it is possible to continue matching in a successor basic block.
- getLastMatchedInstruction
```
public org.apache.bcel.generic.InstructionHandle getLastMatchedInstruction()
```
  Get most recently matched instruction.
- advanceToSuccessor
```
public PatternMatcher.State advanceToSuccessor(Edge edge,
                                               MatchResult matchResult)
```
  Return a new State for continuing the overall pattern match in a successor basic block.
  
  Parameters:
  
  edge - the Edge leading to the successor basic block
  
  matchResult - a MatchResult representing the match of the last instruction in the predecessor block; null if none
- lookForDominatedInstruction
```
public boolean lookForDominatedInstruction()
```
  Determine if we need to look for a dominated instruction at this point in the search.
- dominatedInstructionStateIterable
```
public java.lang.Iterable<PatternMatcher.State> dominatedInstructionStateIterable()
                                                                           throws DataflowAnalysisException
```
  Return Iterator over states representing dominated instructions that continue the match.
  
  Throws:
  
  DataflowAnalysisException
- matchLocation
```
private MatchResult matchLocation(Location location)
                           throws DataflowAnalysisException
```
  Throws:
  
  DataflowAnalysisException

Class PatternMatcher.State

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

basicBlock

instructionIterator

patternElement

matchCount

currentMatch

bindingSet

canFork

parentPath

path

Constructor Detail

State

State

Method Detail

toString

duplicate

getBasicBlock

getPatternElement

getCurrentMatch

isComplete

getResult

advanceToNextElement

currentElementCanContinue

moreInstructionsInBasicBlock

matchNextInBasicBlock

canAdvanceToNextBasicBlock

getLastMatchedInstruction

advanceToSuccessor

lookForDominatedInstruction

dominatedInstructionStateIterable

matchLocation