Enum MetaType 

#[non_exhaustive]
pub enum MetaType {
    Default,
    Clear,
    Name(String),
    Use {
        name: String,
        flip_endian: bool,
    },
    Indirect,
    Offset,
}

Control-flow directive carried by TypeKind::Meta.

These are not value-reading types – they correspond to magic(5) control-flow keywords (default, clear, name, use, indirect, offset) that modify how a rule set is traversed rather than reading bytes from the buffer. All six variants are fully evaluated by the engine: default/clear manage per-level sibling-matched state; name/use implement subroutine dispatch; indirect re-applies the root rule database at a resolved offset; and offset emits the current file position as Value::Uint for printf-style formatting.

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.

Default

default directive: fires when no sibling at the same indentation level has matched at the current offset. See magic(5) for the “default” type semantics.

Examples

use libmagic_rs::parser::ast::MetaType;
let meta = MetaType::Default;
assert_eq!(meta, MetaType::Default);

Clear

clear directive: resets the sibling-matched flag so a later default sibling can fire even if an earlier sibling matched. See magic(5) for the “clear” type semantics.

Examples

use libmagic_rs::parser::ast::MetaType;
let meta = MetaType::Clear;
assert_eq!(meta, MetaType::Clear);

Name(String)

name <identifier> directive: declares a named subroutine that can be invoked later via MetaType::Use. See magic(5) for the “name” type semantics.

Examples

use libmagic_rs::parser::ast::MetaType;
let meta = MetaType::Name("part2".to_string());
assert_eq!(meta, MetaType::Name("part2".to_string()));

Use

use <identifier> directive: invokes a named subroutine previously declared via MetaType::Name. See magic(5) for the “use” type semantics.

flip_endian records the magic(5) \^ prefix (use \^name), which flips the endianness of every endian-bearing read inside the invoked subroutine (libmagic softmagic.c cvt_flip; the flip toggles and propagates into nested use calls). A plain use name has flip_endian: false. See the evaluator’s flip_type_endian and the SubroutineScope guard for the runtime semantics.

Examples

use libmagic_rs::parser::ast::MetaType;
let meta = MetaType::Use { name: "part2".to_string(), flip_endian: false };
assert_eq!(
    meta,
    MetaType::Use { name: "part2".to_string(), flip_endian: false }
);

Fields

name: String

Identifier of the named subroutine to invoke.

flip_endian: bool

Whether to flip endianness of reads inside the subroutine (the magic(5) \^ prefix).

Indirect

indirect directive: re-applies the entire magic database at the resolved offset. See magic(5) for the “indirect” type semantics.

Examples

use libmagic_rs::parser::ast::MetaType;
let meta = MetaType::Indirect;
assert_eq!(meta, MetaType::Indirect);

Offset

offset type keyword: reports the current file offset rather than reading a typed value from the buffer. See magic(5) for the “offset” type semantics.

Evaluation: the engine resolves the rule’s offset specification to an absolute position and emits a RuleMatch whose value is Value::Uint(position). Message templates can reference that value through printf-style format specifiers (e.g. %lld), which are substituted by crate::output::format::format_magic_message at description- assembly time. The only supported operator is x (AnyValue); any other operator is debug!-logged and skipped.

Examples

use libmagic_rs::parser::ast::MetaType;
let meta = MetaType::Offset;
assert_eq!(meta, MetaType::Offset);

Trait Implementations

impl Clone for MetaType

fn clone(&self) -> MetaType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MetaType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MetaType

impl PartialEq for MetaType

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for MetaType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MetaType