Enum Match

pub enum Match<'a> {
    Substitution {
        span: SourceSpan,
        name: VariableName,
        pattern: Option<Span<Cow<'a, str>>>,
    },
    Numeric {
        span: SourceSpan,
        format: NumberFormat,
        capture: Option<VariableName>,
        constraint: Constraint,
        expr: Option<Expr>,
    },
}

This type represents a match rule wrapped in [[ ]]

Variants

Substitution

Match the given regular expression pattern, optionally binding name to the matched value.

Corresponds to expressions such as [[REG]] and [[REG:r[0-9]+]].

The precise format of this match type is [[<name>:<pattern>]], where:

• <name> is a local variable name of the form [A-Za-z_][A-Za-z0-9_]*, or a global variable name (prefixed with $). However, you are not permitted to (re)bind global variables.

• :<pattern>, is any valid, non-empty, regular expression pattern. When present, it changes the semantics of this match type from string substitution to string capture - i.e. name will be bound to the matched input string.

If :<pattern> is not present, then the entire [[<name>]] block will be substituted with the value of <name> as a literal pattern. The value will be formatted according to its type.

Variables bound using this syntax are available immediately on the same line, you can do things like CHECK: op [[REG:r[0-9]+]], [[REG]] to bind REG to the register name of the first operand of op, e.g., r1; and verify that the same register is used as the second operand.

NOTE: You should prefer the standard regular expression pattern matching syntax, i.e. {{<pattern>}} if you don’t need to bind a variable.

Fields

span: SourceSpan

name: VariableName

pattern: Option<Span<Cow<'a, str>>>

Numeric

Match the given numeric pattern, and optionally defines a variable if the match succeeds.

Corresponds to expressions such as [[#]] or [[#%.8X]] or [[#REG + 1]], as well as [[#REG:]] and [[#%X,OFFSET:12]]. The former are matches, while the latter both match and define the given variable.

The unified format is [[#%<fmtspec>,<NUMVAR>: <constraint> <expr]] where:

• %<fmtspec> is the same format specifier as used for defining a variable, but in this context it indicates how the numeric value should be matched. It is optional, and if not present, both components of the format spec are inferred from the matching format of the numeric variables used by the expression constraint (if any), and defaults to %u (unsigned, no leading zeros) if no numeric variable is used. In case of conflict between format specifiers of several numeric variables, the conversion specifier becomes mandatory, but the precision specifier remains optional.

• <NUMVAR>:, when present, indicates that NUMVAR will be (re)bound to the matched value, if the match succeeds. If not present, no variable is defined.

• <constraint> describes how the value to match must relate to the value of the given expression. Currently, the only constraint type is == for equality. If present, <expr> is mandatory; however the inverse is not true, <expr> can be provided without <constraint>, implying a default equality constraint.

• <expr> is an expression. An expression is in turn recursively defined as:

  • A numeric operand
  • An expression followed by an operator and a numeric operand

  A numeric operand is a previously defined numeric variable, an integer literal, or one of a set of built-in functions. Whitespace are allowed around these elements. Numeric operands are 64-bit values. Overflow and underflow are rejected. The original lit does not support operator precedence, but litcheck supports the standard precedence of the supported operators, and parentheses can be used to manually manage precedence.

  The operators supported are:

  • +, addition
  • -, subtraction

  The built-in functions supported are:

  • add, addition
  • sub, subtraction
  • mul, multiplication
  • div, integer division
  • min, minimum
  • max, maximum

All components can be omitted except the #, i.e. [[#]] is a valid numeric match, which defaults to matching an unsigned integer, with no leading zeros, of up to 64 bit precision.

Fields

span: SourceSpan

format: NumberFormat

The format of the value to match.

If not specified, it is implied by the format of any numeric operands in expr, otherwise it defaults to an unsigned integer with no leading zeros.

capture: Option<VariableName>

If set, contains the name of the variable to bind to the matched value if the match succeeds.

constraint: Constraint

If specified, this changes the meaning of expr in relation to the matched value.

expr: Option<Expr>

The numeric expression to evaluate

If constraint is not set, this expression produces a value which must match the input.

Trait Implementations

impl<'a> Clone for Match<'a>

fn clone(&self) -> Match<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Match<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Ord for Match<'a>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Match<'a>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for Match<'a>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Spanned for Match<'a>

fn span(&self) -> SourceSpan

fn start(&self) -> usize

fn end(&self) -> usize

fn range(&self) -> Range<usize>

impl<'a> Eq for Match<'a>