Enum ParseStage 

#[non_exhaustive]
pub enum ParseStage {
    DosHeader,
    PeSignature,
    CoffHeader,
    OptionalHeader,
    SectionTable,
    Cor20Header,
    MetadataRoot,
    StreamHeader,
    TildeStream,
    TableRow,
    Heap,
    DataDirectory,
    Resources,
    VTableFixup,
    StrongName,
    Signature,
    MethodBody,
    CustomAttribute,
    PermissionSet,
    InstructionDecoder,
    InstructionEncoder,
    AssemblyWriter,
    ImportsExports,
    TypeSystem,
    Validation,
    EmulationLoader,
    Generic,
}

dotscope Error type.

The main error type for all operations in this crate. Provides detailed error information for file parsing, metadata validation, and disassembly operations.

Usage Examples

use dotscope::{Error, CilObject};

match CilObject::from_path(std::path::Path::new("tests/samples/crafted_2.exe")) {
    Ok(assembly) => println!("Loaded successfully"),
    Err(Error::NotSupported) => println!("File format not supported"),
    Err(Error::Parse(parse_err)) => println!("Malformed: {}", parse_err),
    Err(e) => println!("Error: {}", e),
}

Pipeline stage at which a parse error originated.

Returned as part of ParseFailure. Lets consumers act on the error category (e.g. retry an upgrade only for Cor20Header/MetadataRoot failures) without parsing string messages.

#[non_exhaustive] — additional stages may be added as the parser surface grows.

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.

DosHeader

DOS / MZ header at the very start of the PE file.

PeSignature

PE signature (“PE\0\0”) immediately following the DOS stub.

CoffHeader

COFF file header following the PE signature.

OptionalHeader

Optional header (PE32 / PE32+).

SectionTable

Section table immediately after the optional header.

Cor20Header

CLI / COR20 runtime header located via the data-directory entry.

MetadataRoot

Metadata root header (signature, versions, stream count).

StreamHeader

Per-stream header inside the metadata root.

TildeStream

Tilde (#~) stream containing metadata table rows.

TableRow

Per-table row layout/decoding within the tilde stream.

Heap

One of the heap streams (#Strings, #US, #Blob, #GUID).

DataDirectory

Generic data-directory entry traversal.

Resources

Resource directory (.NET embedded resources).

VTableFixup

VTableFixup directory.

StrongName

Strong-name signature blob.

Signature

Signature parsing within blobs (method/field/etc.).

MethodBody

Method body header / code / EH-clause parsing.

CustomAttribute

Custom-attribute decoding from the blob heap.

PermissionSet

DeclSecurity permission-set decoding.

InstructionDecoder

CIL instruction decoding (disassembly).

InstructionEncoder

CIL instruction encoding (assembler/serializer write paths).

AssemblyWriter

Assembly / metadata writer paths (crate::cilassembly::writer).

ImportsExports

Imports/exports table decoding.

TypeSystem

Type system construction post-parse (crate::metadata::tables, owned-type construction).

Validation

Validation passes (crate::metadata::validation).

EmulationLoader

Emulation/runtime loader (crate::emulation::loader).

Generic

Generic byte-parser primitives — used by helpers that have no inherent stage (e.g. crate::file::parser::Parser).

Trait Implementations

impl Clone for ParseStage

fn clone(&self) -> ParseStage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ParseStage

impl Debug for ParseStage

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

Formats the value using the given formatter.

impl Display for ParseStage

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

Formats the value using the given formatter.

impl Eq for ParseStage

impl Hash for ParseStage

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ParseStage

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