Enum OffsetSpec 

#[non_exhaustive]
pub enum OffsetSpec {
    Absolute(i64),
    Indirect {
        base_offset: i64,
        base_relative: bool,
        pointer_type: TypeKind,
        adjustment: i64,
        adjustment_op: IndirectAdjustmentOp,
        result_relative: bool,
        endian: Endianness,
    },
    Relative(i64),
    FromEnd(i64),
}

Offset specification for locating data in files

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.

Absolute(i64)

Absolute offset from file start (or from file end if negative)

Positive values are offsets from the start of the file. Negative values are offsets from the end of the file (same as FromEnd).

Examples

use libmagic_rs::parser::ast::OffsetSpec;

let offset = OffsetSpec::Absolute(0x10); // Read at byte 16 from start
let from_end = OffsetSpec::Absolute(-4); // 4 bytes before end of file

Indirect

Indirect offset through pointer dereferencing

Reads a pointer value at base_offset, interprets it according to pointer_type and endian, then combines adjustment with the pointer value using adjustment_op to get the final offset. The default adjustment_op is IndirectAdjustmentOp::Add, so (base.type) and (base.type+N) / (base.type-N) use addition (subtraction is encoded as Add with a negative adjustment). magic(5) also supports multiplicative and bitwise forms inside the parens, e.g. (0x200.s*2) (IndirectAdjustmentOp::Mul).

Examples

use libmagic_rs::parser::ast::{OffsetSpec, TypeKind, Endianness, IndirectAdjustmentOp};

let indirect = OffsetSpec::Indirect {
    base_offset: 0x20,
    base_relative: false,
    pointer_type: TypeKind::Long { endian: Endianness::Little, signed: false },
    adjustment: 4,
    adjustment_op: IndirectAdjustmentOp::Add,
    result_relative: false,
    endian: Endianness::Little,
};

Fields

base_offset: i64

Base offset to read pointer from. When base_relative is true, this value is added to the current anchor (last-match position) rather than being treated as an absolute file position.

base_relative: bool

If true, base_offset is relative to the current anchor (i.e., (&N.X) syntax in magic files). Defaults to false for backwards compatibility with existing AST snapshots; the serde default attribute lets older serialized AST round-trip.

pointer_type: TypeKind

Type of pointer value

adjustment: i64

Operand combined with the pointer value via adjustment_op.

For IndirectAdjustmentOp::Add, the operand is signed (negative values encode subtraction). For multiplicative and bitwise ops the operand is interpreted as i64 but typically magic files supply non-negative literals.

adjustment_op: IndirectAdjustmentOp

Arithmetic operation applied to the pointer value with adjustment as the operand. Defaults to IndirectAdjustmentOp::Add for legacy AST consumers via serde’s default attribute.

result_relative: bool

If true, the resolved offset is added to the current anchor instead of being treated as an absolute file position. This corresponds to magic-file &(...) syntax wrapping an indirect spec, e.g., &(0x10.l).

endian: Endianness

Endianness for pointer reading

Relative(i64)

Relative offset from previous match position

Examples

use libmagic_rs::parser::ast::OffsetSpec;

let relative = OffsetSpec::Relative(8); // 8 bytes after previous match

FromEnd(i64)

Offset from end of file (negative values move towards start)

Examples

use libmagic_rs::parser::ast::OffsetSpec;

let from_end = OffsetSpec::FromEnd(-16); // 16 bytes before end of file

Trait Implementations

impl Clone for OffsetSpec

fn clone(&self) -> OffsetSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OffsetSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OffsetSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OffsetSpec

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OffsetSpec

impl StructuralPartialEq for OffsetSpec