Enum ValueTransformOp 

#[non_exhaustive]
pub enum ValueTransformOp {
    Add,
    Sub,
    Mul,
    Div,
    Mod,
    BitAnd,
    Or,
    Xor,
}

Arithmetic operation applied to a value read from the file before the rule’s comparison operator is evaluated.

magic(5) supports +, -, *, /, %, |, and ^ between the type keyword and the comparison value (e.g., lelong+1 x volume %d reads a long, adds 1, and formats the transformed value into the message). Bitwise AND (&MASK) is not part of this enum because it is already represented at the operator level via Operator::BitwiseAndMask.

The operand is signed (i64) so that subtraction and negative multipliers round-trip cleanly. Bitwise ops reinterpret the operand as a u64 bit pattern at evaluation time, matching libmagic’s apprentice.c::mconvert.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Add

Addition (type+N).

Sub

Subtraction (type-N).

Mul

Multiplication (type*N).

Div

Truncating integer division (type/N). Division by zero is rejected at evaluation time.

Mod

Remainder (type%N). Modulo by zero is rejected at evaluation time.

BitAnd

Bitwise AND (type&N).

magic(5) &MASK was historically encoded at the operator level via Operator::BitwiseAndMask (which combines mask+equal in one step). That encoding cannot represent rules like lelong&0xff x %d (mask + any-value, with the masked value used in format substitution). The parser promotes &MASK to this BitAnd transform when followed by another operator (x, >, !=, …) so the read value is masked before comparison and before printf substitution. The legacy &MASK VALUE form (mask + implicit equal) keeps using Operator::BitwiseAndMask for backwards compatibility.

Or

Bitwise OR (type|N).

Xor

Bitwise XOR (type^N).

Trait Implementations

impl Clone for ValueTransformOp

fn clone(&self) -> ValueTransformOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValueTransformOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ValueTransformOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ValueTransformOp

fn eq(&self, other: &ValueTransformOp) -> 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 Serialize for ValueTransformOp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ValueTransformOp

impl Eq for ValueTransformOp

impl StructuralPartialEq for ValueTransformOp