# Class: com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern

IR expression multi\-pattern, consisting of one or more inputs, and zero or one output \(for replacement\). 

```

 Triggers for leaves:
   $      any (terminals and non-terminals)
   T      terminals (imm, var, range)
   N      non-terminals (mem, slice)
   V      variables
   #      immediates
   @x     special immediates; currently supported: `@LASTBITn` = (bitsize-1) of expression n
          (important: take note that n does not refer to the leaf itself, it refers to another previously matched leaf.)
   DIGITS a specific immediate (an optional id can be specified in curly braces after the value)

 Suffixes:
  {n}     Assign the id n to the leaf (must be the first suffix)
  [H1]    Select the first half of an expression (for a 32-bit leaf, the [0:16[ bits)
  [H2]    Select the second half of an expression (for a 32-bit leaf, the [16:32[ bits)

 Examples:
   $0     match any expression, assign the id 0
   V1     match any EVar, assign the id 1
   #2     match any immediate; assign the id 2 to it
   10     match an immediate holding the value 10, of any size; do not assign an id to it (will not be in the matchmap)
   10{2}  match an immediate holding the value 10; assign the id 2 to it

 Use parentheses. The parser is relatively simple and does not know about operator precedence.
 Therefore, an excess of parens around expressions is better than the reverse.

 Associativity for ADD, MUL, AND, OR, XOR: use the syntax (a OP b OP c OP d) instead of specific grouping like ((a OP b) OP (c OP d))
 to allow the matcher to try all possible combinations for associative and commutative operators.

 Immediate literals: should always start with a digit. Therefore, to use write in base 16, use the 0x prefix.
 Negative literals are allowed but must be enclosed in parens, e.g. (-3).

 Special BOL characters for multi-line patterns:
 > at beginning of line indicates the trigger (if unspecified,
   the most appropriate trigger statement will be determined heuristically)
 X at beginning of line indicates that the input expression should not be
   discarded during a replacement (if any). It can only be used for leading
   and trailing statements of an input pattern. Gaps are not allowed.

 When compiling an output pattern for replacement, immediates can reference existing matched-item ids,
 in which case their bitsize will be the one of the matched item.
 When an output pattern uses id-less immediates, the pattern-replacer engine will attempt to infer its bitsize
 from the surrounding expression. (Not recommended.)
 
```
 Flexible matching: 

```

 => (x + imm) will also be matched as (x - (-imm))
 => (x - imm) will also be matched as (x + (-imm))
 => (x * 2) will also be matched as (x << 1), and conversely, for all powers of 2
 => (x >= y) will also be matched as (y <= x), and the same goes for all inequality operators
 => (x OP y) with OP being a commutative operator will also be matched as (y OP x)
 => (x OP y OP z) can be used for associative operators +-&|^ and will match on any possible grouping
 
```

## Method: addInput
- parameter: `strings`, type: `java.lang.String[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: addInput
- parameter: `flags`, type: `int`
- parameter: `strings`, type: `java.lang.String[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: compile
- parameter: `compiler`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: compile
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: compile
- parameter: `flags`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: getCustomReplacer
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.IEPatternReplacer`


## Method: getInput
- parameter: `index`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern.P`


## Method: getInputs
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern.P>`


## Method: getName
- return type: `java.lang.String`


## Method: getOutput
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern.P`


## Method: getVerifier
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.IEMatchVerifier`


## Method: hasOutput
- return type: `boolean`


## Method: isCompiled
- return type: `boolean`


## Method: isPureInputExpression
- return type: `boolean`

Description: Indicate if a pattern has only pure input expressions \(meaning no assignment and only 1 expression\). Otherwise, at least an input contains full statement OR/AND several items.
return: 

## Method: isPureOuputExpression
- return type: `boolean`

Description: Indicate if the result of a pattern replacement is a pure expression \(only an expression is replaced\). Otherwise, the result will modify one or more statements.
return: 

## Method: setCustomReplacer
- parameter: `replacer`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.IEPatternReplacer`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: setInput
- parameter: `str`, type: `java.lang.String`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: setInput
- parameter: `flags`, type: `int`
- parameter: `str`, type: `java.lang.String`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: setOutput
- parameter: `strings`, type: `java.lang.String[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: setOutput
- parameter: `flags`, type: `int`
- parameter: `strings`, type: `java.lang.String[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: setVerifier
- parameter: `verifier`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.IEMatchVerifier`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Method: toString
- return type: `java.lang.String`


## Static Method: cc
- parameter: `inputStrings`, type: `java.lang.String[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`

Description: Convenience method to quickly create and compile a single\-input, no\-output pattern.
parameter: inputStrings: 
return: 

## Static Method: cc
- parameter: `inputFlags`, type: `int`
- parameter: `inputStrings`, type: `java.lang.String[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`

Description: Convenience method to quickly create and compile a single\-input, no\-output pattern.
parameter: inputFlags: 
parameter: inputStrings: 
return: 

## Static Method: create
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


## Static Method: create
- parameter: `name`, type: `java.lang.String`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.compiler.EPatternCompiler.EPattern`


