🥮 mooncakes.io

    firmware-image-toolkit

    Validated Intel HEX and Motorola S-record firmware image toolkit

    intel-hex
    s-record
    firmware
    embedded
    codec
    Download zip
    Author
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    48

    No dependencies

    #Zzqy-yi/firmware-image-toolkit

    Validated Intel HEX and Motorola S-record codecs plus canonical sparse firmware-image operations for MoonBit.

    let parsed = @firmware.parse_firmware_image(
      ":03001000010203E7\n:00000001FF",
    ).unwrap()
    let image = parsed.image()
    println(@firmware.render_statistics_text(@firmware.analyze_image(image)))

    The package validates Intel HEX types 00-05 and S-record types S0, S1, S2, S3, S5, S6, S7, S8 and S9. It supports sparse image conversion, bounded range operations, comparison, manifests, verified patches, memory-map checks, batch processing and deterministic evidence reports.

    The package operates on caller-provided text and bytes. It does not communicate with hardware or parse executable object and vendor container formats. Full usage, commands and boundaries are documented in the repository README.md.

    AddressGap

    source
    pub(all) struct AddressGap {
      start_value : UInt64
      end_exclusive_value : UInt64
    } derive(Eq, 
    Debug    )

    AddressGap::end_exclusive

    source
    fn AddressGap::end_exclusive(self : AddressGap) -> UInt64

    AddressGap::length

    source
    fn AddressGap::length(self : AddressGap) -> UInt64

    AddressGap::start

    source
    fn AddressGap::start(self : AddressGap) -> UInt64

    AuditFinding

    source
    pub struct AuditFinding {
      code_value : String
      severity_value : AuditSeverity
      message_value : String
      address_value : UInt64?
    } derive(Eq, 
    Debug    )

    AuditFinding::address

    source
    fn AuditFinding::address(self : AuditFinding) -> UInt64?

    AuditFinding::code

    source
    fn AuditFinding::code(self : AuditFinding) -> String

    AuditFinding::message

    source
    fn AuditFinding::message(self : AuditFinding) -> String

    AuditFinding::severity

    source
    fn AuditFinding::severity(self : AuditFinding) -> AuditSeverity

    AuditPolicy

    source
    pub struct AuditPolicy {
      max_gap_bytes_value : UInt64?
      allowed_start_value : UInt64?
      allowed_end_exclusive_value : UInt64?
      max_segments_value : Int?
      max_total_bytes_value : Int?
      require_entry_in_data_value : Bool
    } derive(Eq, 
    Debug    )

    AuditPolicy::new

    source
    fn AuditPolicy::new(max_gap_bytes? : UInt64?, allowed_start? : UInt64?, allowed_end_exclusive? : UInt64?, max_segments? : Int?, max_total_bytes? : Int?, require_entry_in_data? : Bool) -> Result[AuditPolicy, FirmwareError]

    AuditPolicy::standard

    source
    fn AuditPolicy::standard() -> AuditPolicy

    AuditSeverity

    source
    pub(all) enum AuditSeverity {
      AuditInfo
      AuditWarning
      AuditError
    } derive(Eq, 
    Debug    )

    ByteDifference

    source
    pub struct ByteDifference {
      address_value : UInt64
      kind_value : ByteDifferenceKind
      left_value : Byte?
      right_value : Byte?
    } derive(Eq, 
    Debug    )

    ByteDifference::address

    source
    fn ByteDifference::address(self : ByteDifference) -> UInt64

    ByteDifference::kind

    source

    ByteDifference::left

    source
    fn ByteDifference::left(self : ByteDifference) -> Byte?

    ByteDifference::right

    source
    fn ByteDifference::right(self : ByteDifference) -> Byte?

    ByteDifferenceKind

    source
    pub(all) enum ByteDifferenceKind {
      ByteAdded
      ByteRemoved
      ByteChanged
    } derive(Eq, 
    Debug    )

    DocumentStatistics

    source
    pub struct DocumentStatistics {
      format_value : FirmwareFormat
      total_records_value : Int
      data_records_value : Int
      metadata_records_value : Int
      data_bytes_value : Int
      largest_data_record_value : Int
      entry_point_value : UInt64?
      has_header_value : Bool
      declared_data_records_value : Int?
      category_values : Array[RecordCategoryStatistics]
    } derive(Eq, 
    Debug    )

    DocumentStatistics::categories

    source

    DocumentStatistics::data_bytes

    source
    fn DocumentStatistics::data_bytes(self : DocumentStatistics) -> Int

    DocumentStatistics::data_records

    source
    fn DocumentStatistics::data_records(self : DocumentStatistics) -> Int

    DocumentStatistics::declared_data_records

    source
    fn DocumentStatistics::declared_data_records(self : DocumentStatistics) -> Int?

    DocumentStatistics::entry_point

    source
    fn DocumentStatistics::entry_point(self : DocumentStatistics) -> UInt64?

    DocumentStatistics::format

    source

    DocumentStatistics::has_header

    source
    fn DocumentStatistics::has_header(self : DocumentStatistics) -> Bool

    DocumentStatistics::largest_data_record

    source
    fn DocumentStatistics::largest_data_record(self : DocumentStatistics) -> Int

    DocumentStatistics::metadata_records

    source
    fn DocumentStatistics::metadata_records(self : DocumentStatistics) -> Int

    DocumentStatistics::total_records

    source
    fn DocumentStatistics::total_records(self : DocumentStatistics) -> Int

    FirmwareBatch

    source
    pub struct FirmwareBatch {
      item_values : Array[FirmwareBatchItem]
      success_count_value : Int
      failure_count_value : Int
      total_bytes_value : Int
    } derive(Eq, 
    Debug    )

    FirmwareBatch::failure_count

    source
    fn FirmwareBatch::failure_count(self : FirmwareBatch) -> Int

    FirmwareBatch::items

    source

    FirmwareBatch::success_count

    source
    fn FirmwareBatch::success_count(self : FirmwareBatch) -> Int

    FirmwareBatch::total_bytes

    source
    fn FirmwareBatch::total_bytes(self : FirmwareBatch) -> Int

    FirmwareBatchItem

    source
    pub struct FirmwareBatchItem {
      label_value : String
      format_value : FirmwareFormat?
      image_value : FirmwareImage?
      error_value : FirmwareError?
    } derive(Eq, 
    Debug    )

    FirmwareBatchItem::error

    source

    FirmwareBatchItem::format

    source

    FirmwareBatchItem::image

    source

    FirmwareBatchItem::label

    source
    fn FirmwareBatchItem::label(self : FirmwareBatchItem) -> String

    FirmwareChunk

    source
    pub struct FirmwareChunk {
      address_value : UInt64
      data_value : Bytes
      line_index_value : Int
    } derive(Eq, 
    Debug    )

    A validated contiguous byte range with its source line.

    FirmwareChunk::address

    source
    fn FirmwareChunk::address(self : FirmwareChunk) -> UInt64

    FirmwareChunk::create

    source
    fn FirmwareChunk::create(address : UInt64, data : Bytes, line_index? : Int) -> Result[FirmwareChunk, FirmwareError]

    Create a chunk after checking that its address range is representable.

    FirmwareChunk::data

    source
    fn FirmwareChunk::data(self : FirmwareChunk) -> Bytes

    FirmwareChunk::end_exclusive

    source
    fn FirmwareChunk::end_exclusive(self : FirmwareChunk) -> UInt64

    FirmwareChunk::length

    source
    fn FirmwareChunk::length(self : FirmwareChunk) -> Int

    FirmwareChunk::line_index

    source
    fn FirmwareChunk::line_index(self : FirmwareChunk) -> Int

    FirmwareError

    source
    pub struct FirmwareError {
      code_value : String
      message_value : String
      position_value : SourcePosition
    } derive(Eq, 
    Debug    )

    FirmwareError::code

    source
    fn FirmwareError::code(self : FirmwareError) -> String

    FirmwareError::column_index

    source
    fn FirmwareError::column_index(self : FirmwareError) -> Int?

    FirmwareError::line_index

    source
    fn FirmwareError::line_index(self : FirmwareError) -> Int

    FirmwareError::message

    source
    fn FirmwareError::message(self : FirmwareError) -> String

    FirmwareError::new

    source
    fn FirmwareError::new(code : FirmwareErrorCode, message : String, position : SourcePosition) -> FirmwareError

    FirmwareError::position

    source

    FirmwareErrorCode

    source
    pub(all) enum FirmwareErrorCode {
      HexOddLength
      HexInvalidDigit
      RecordEmpty
      RecordInvalidPrefix
      RecordInvalidType
      RecordLengthMismatch
      RecordTooLong
      ChecksumMismatch
      AddressOutOfRange
      ImageOverlap
      ImageInvalidRange
      IntegrityViolation
      DocumentMissingTerminator
      DocumentRecordAfterTerminator
      DocumentDuplicateMetadata
    } derive(Eq, 
    Debug    )

    FirmwareErrorCode::code

    source
    fn FirmwareErrorCode::code(self : FirmwareErrorCode) -> String

    FirmwareFormat

    source
    pub(all) enum FirmwareFormat {
      IntelHexFormat
      SRecordFormat
    } derive(Eq, 
    Debug    )

    FirmwareImage

    source
    pub struct FirmwareImage {
      segment_values : Array[ImageSegment]
      entry_point_value : UInt64?
    } derive(Eq, 
    Debug    )

    FirmwareImage::byte_at

    source
    fn FirmwareImage::byte_at(self : FirmwareImage, address : UInt64) -> Byte?

    FirmwareImage::coverage

    source
    fn FirmwareImage::coverage(self : FirmwareImage, start : UInt64, end_exclusive : UInt64) -> Result[RangeCoverage, FirmwareError]

    Measure byte coverage within a non-empty half-open address range.

    FirmwareImage::entry_point

    source
    fn FirmwareImage::entry_point(self : FirmwareImage) -> UInt64?

    FirmwareImage::erase

    source
    fn FirmwareImage::erase(self : FirmwareImage, start : UInt64, end_exclusive : UInt64) -> Result[FirmwareImage, FirmwareError]

    Remove bytes in [start, end) and re-canonicalize remaining segments.

    FirmwareImage::fill_gaps

    source
    fn FirmwareImage::fill_gaps(self : FirmwareImage, value : Byte, max_fill_bytes : Int) -> Result[FirmwareImage, FirmwareError]

    Fill only gaps between existing segments, subject to an allocation bound.

    FirmwareImage::from_chunks

    source
    fn FirmwareImage::from_chunks(chunks : Array[FirmwareChunk], policy? : OverlapPolicy, entry_point? : UInt64?) -> Result[FirmwareImage, FirmwareError]

    FirmwareImage::from_intel_document

    source
    fn FirmwareImage::from_intel_document(document : IntelHexDocument, policy? : OverlapPolicy) -> Result[FirmwareImage, FirmwareError]

    FirmwareImage::from_srecord_document

    source
    fn FirmwareImage::from_srecord_document(document : SRecordDocument, policy? : OverlapPolicy) -> Result[FirmwareImage, FirmwareError]

    FirmwareImage::gaps

    source

    FirmwareImage::highest_address

    source
    fn FirmwareImage::highest_address(self : FirmwareImage) -> UInt64?

    FirmwareImage::lowest_address

    source
    fn FirmwareImage::lowest_address(self : FirmwareImage) -> UInt64?

    FirmwareImage::merge

    source
    fn FirmwareImage::merge(self : FirmwareImage, other : FirmwareImage, policy? : OverlapPolicy) -> Result[FirmwareImage, FirmwareError]

    Merge two images while applying an explicit byte-overlap policy.

    FirmwareImage::read_range

    source
    fn FirmwareImage::read_range(self : FirmwareImage, start : UInt64, length : Int, missing : MissingBytePolicy, max_bytes : Int) -> Result[Bytes, FirmwareError]

    Read a bounded contiguous range with an explicit sparse-byte policy.

    FirmwareImage::relocate

    source
    fn FirmwareImage::relocate(self : FirmwareImage, new_base : UInt64) -> Result[FirmwareImage, FirmwareError]

    Move the lowest image address to new_base while preserving distances.

    FirmwareImage::segments

    source

    FirmwareImage::slice

    source
    fn FirmwareImage::slice(self : FirmwareImage, start : UInt64, end_exclusive : UInt64) -> Result[FirmwareImage, FirmwareError]

    Return bytes intersecting the half-open address range [start, end).

    FirmwareImage::to_intel_hex

    source
    fn FirmwareImage::to_intel_hex(self : FirmwareImage, record_bytes? : Int) -> Result[String, FirmwareError]

    Deterministically export an image as 32-bit Intel HEX.

    FirmwareImage::to_srecord

    source
    fn FirmwareImage::to_srecord(self : FirmwareImage, record_bytes? : Int, header? : String) -> Result[String, FirmwareError]

    Deterministically export an image as Motorola S-record text.

    FirmwareImage::total_bytes

    source
    fn FirmwareImage::total_bytes(self : FirmwareImage) -> Int

    FirmwareImage::write

    source
    fn FirmwareImage::write(self : FirmwareImage, address : UInt64, data : Bytes) -> Result[FirmwareImage, FirmwareError]

    Write bytes using replacement semantics while preserving the original image.

    FirmwareInput

    source
    pub struct FirmwareInput {
      label_value : String
      text_value : String
      format_value : FirmwareFormat?
      policy_value : OverlapPolicy
    } derive(Eq, 
    Debug    )

    FirmwareInput::new

    source
    fn FirmwareInput::new(label : String, text : String, format? : FirmwareFormat?, policy? : OverlapPolicy) -> FirmwareInput

    ImageAudit

    source
    pub struct ImageAudit {
      finding_values : Array[AuditFinding]
      segment_count_value : Int
      total_bytes_value : Int
      gap_count_value : Int
    } derive(Eq, 
    Debug    )

    ImageAudit::accepted

    source
    fn ImageAudit::accepted(self : ImageAudit) -> Bool

    ImageAudit::error_count

    source
    fn ImageAudit::error_count(self : ImageAudit) -> Int

    ImageAudit::findings

    source
    fn ImageAudit::findings(self : ImageAudit) -> Array[AuditFinding]

    ImageAudit::gap_count

    source
    fn ImageAudit::gap_count(self : ImageAudit) -> Int

    ImageAudit::segment_count

    source
    fn ImageAudit::segment_count(self : ImageAudit) -> Int

    ImageAudit::total_bytes

    source
    fn ImageAudit::total_bytes(self : ImageAudit) -> Int

    ImageAudit::warning_count

    source
    fn ImageAudit::warning_count(self : ImageAudit) -> Int

    ImageComparison

    source
    pub struct ImageComparison {
      difference_values : Array[ByteDifference]
      added_count_value : Int
      removed_count_value : Int
      changed_count_value : Int
    } derive(Eq, 
    Debug    )

    ImageComparison::added_count

    source
    fn ImageComparison::added_count(self : ImageComparison) -> Int

    ImageComparison::changed_count

    source
    fn ImageComparison::changed_count(self : ImageComparison) -> Int

    ImageComparison::differences

    source

    ImageComparison::identical

    source
    fn ImageComparison::identical(self : ImageComparison) -> Bool

    ImageComparison::removed_count

    source
    fn ImageComparison::removed_count(self : ImageComparison) -> Int

    ImageLayout

    source
    pub struct ImageLayout {
      placement_values : Array[SegmentPlacement]
      mapped_bytes_value : UInt64
      unmapped_bytes_value : UInt64
      fully_mapped_segments_value : Int
      partially_mapped_segments_value : Int
      unmapped_segments_value : Int
      entry_region_value : String?
      entry_was_present_value : Bool
    } derive(Eq, 
    Debug    )

    ImageLayout::accepted

    source
    fn ImageLayout::accepted(self : ImageLayout) -> Bool

    ImageLayout::entry_region

    source
    fn ImageLayout::entry_region(self : ImageLayout) -> String?

    ImageLayout::fully_mapped_segments

    source
    fn ImageLayout::fully_mapped_segments(self : ImageLayout) -> Int

    ImageLayout::mapped_bytes

    source
    fn ImageLayout::mapped_bytes(self : ImageLayout) -> UInt64

    ImageLayout::partially_mapped_segments

    source
    fn ImageLayout::partially_mapped_segments(self : ImageLayout) -> Int

    ImageLayout::placements

    source
    fn ImageLayout::placements(self : ImageLayout) -> Array[SegmentPlacement]

    ImageLayout::segment_count

    source
    fn ImageLayout::segment_count(self : ImageLayout) -> Int

    ImageLayout::unmapped_bytes

    source
    fn ImageLayout::unmapped_bytes(self : ImageLayout) -> UInt64

    ImageLayout::unmapped_segments

    source
    fn ImageLayout::unmapped_segments(self : ImageLayout) -> Int

    ImageManifest

    source
    pub struct ImageManifest {
      segment_digest_values : Array[SegmentDigest]
      total_bytes_value : Int
      entry_point_value : UInt64?
      fingerprint_value : UInt
    } derive(Eq, 
    Debug    )

    ImageManifest::entry_point

    source
    fn ImageManifest::entry_point(self : ImageManifest) -> UInt64?

    ImageManifest::fingerprint

    source
    fn ImageManifest::fingerprint(self : ImageManifest) -> UInt

    ImageManifest::segment_digests

    source
    fn ImageManifest::segment_digests(self : ImageManifest) -> Array[SegmentDigest]

    ImageManifest::total_bytes

    source
    fn ImageManifest::total_bytes(self : ImageManifest) -> Int

    ImagePatch

    source
    pub struct ImagePatch {
      hunk_values : Array[PatchHunk]
      old_entry_value : UInt64?
      new_entry_value : UInt64?
      added_bytes_value : Int
      removed_bytes_value : Int
      changed_bytes_value : Int
    } derive(Eq, 
    Debug    )

    ImagePatch::added_bytes

    source
    fn ImagePatch::added_bytes(self : ImagePatch) -> Int

    ImagePatch::apply

    source
    fn ImagePatch::apply(self : ImagePatch, source : FirmwareImage) -> Result[FirmwareImage, FirmwareError]

    Apply a patch only when all recorded source bytes and entry metadata match.

    ImagePatch::changed_bytes

    source
    fn ImagePatch::changed_bytes(self : ImagePatch) -> Int

    ImagePatch::hunks

    source
    fn ImagePatch::hunks(self : ImagePatch) -> Array[PatchHunk]

    ImagePatch::new_entry

    source
    fn ImagePatch::new_entry(self : ImagePatch) -> UInt64?

    ImagePatch::old_entry

    source
    fn ImagePatch::old_entry(self : ImagePatch) -> UInt64?

    ImagePatch::removed_bytes

    source
    fn ImagePatch::removed_bytes(self : ImagePatch) -> Int

    ImageSegment

    source
    pub struct ImageSegment {
      address_value : UInt64
      data_value : Bytes
    } derive(Eq, 
    Debug    )

    ImageSegment::address

    source
    fn ImageSegment::address(self : ImageSegment) -> UInt64

    ImageSegment::data

    source
    fn ImageSegment::data(self : ImageSegment) -> Bytes

    ImageSegment::end_exclusive

    source
    fn ImageSegment::end_exclusive(self : ImageSegment) -> UInt64

    ImageSegment::length

    source
    fn ImageSegment::length(self : ImageSegment) -> Int

    ImageStatistics

    source
    pub struct ImageStatistics {
      segment_count_value : Int
      occupied_bytes_value : Int
      address_span_value : UInt64
      gap_bytes_value : UInt64
      largest_segment_bytes_value : Int
      largest_gap_bytes_value : UInt64
      lowest_address_value : UInt64?
      highest_address_value : UInt64?
    } derive(Eq, 
    Debug    )

    ImageStatistics::address_span

    source
    fn ImageStatistics::address_span(self : ImageStatistics) -> UInt64

    ImageStatistics::average_segment_bytes

    source
    fn ImageStatistics::average_segment_bytes(self : ImageStatistics) -> Double

    ImageStatistics::density

    source
    fn ImageStatistics::density(self : ImageStatistics) -> Double

    ImageStatistics::gap_bytes

    source
    fn ImageStatistics::gap_bytes(self : ImageStatistics) -> UInt64

    ImageStatistics::highest_address

    source
    fn ImageStatistics::highest_address(self : ImageStatistics) -> UInt64?

    ImageStatistics::largest_gap_bytes

    source
    fn ImageStatistics::largest_gap_bytes(self : ImageStatistics) -> UInt64

    ImageStatistics::largest_segment_bytes

    source
    fn ImageStatistics::largest_segment_bytes(self : ImageStatistics) -> Int

    ImageStatistics::lowest_address

    source
    fn ImageStatistics::lowest_address(self : ImageStatistics) -> UInt64?

    ImageStatistics::occupied_bytes

    source
    fn ImageStatistics::occupied_bytes(self : ImageStatistics) -> Int

    ImageStatistics::segment_count

    source
    fn ImageStatistics::segment_count(self : ImageStatistics) -> Int

    IntelHexDocument

    source
    pub struct IntelHexDocument {
      record_values : Array[IntelHexRecord]
      chunk_values : Array[FirmwareChunk]
      entry_point_value : UInt64?
    } derive(Eq, 
    Debug    )

    IntelHexDocument::data_chunks

    source

    IntelHexDocument::entry_point

    source
    fn IntelHexDocument::entry_point(self : IntelHexDocument) -> UInt64?

    IntelHexDocument::records

    source

    IntelHexRecord

    source
    pub struct IntelHexRecord {
      record_type_value : IntelRecordType
      address_value : Int
      data_value : Bytes
      checksum_value : Byte
      line_index_value : Int
    } derive(Eq, 
    Debug    )

    IntelHexRecord::address

    source
    fn IntelHexRecord::address(self : IntelHexRecord) -> Int

    IntelHexRecord::byte_count

    source
    fn IntelHexRecord::byte_count(self : IntelHexRecord) -> Int

    IntelHexRecord::checksum

    source
    fn IntelHexRecord::checksum(self : IntelHexRecord) -> Byte

    IntelHexRecord::data

    source
    fn IntelHexRecord::data(self : IntelHexRecord) -> Bytes

    IntelHexRecord::encode

    source
    fn IntelHexRecord::encode(self : IntelHexRecord) -> String

    Encode a validated record using uppercase hexadecimal digits.

    IntelHexRecord::line_index

    source
    fn IntelHexRecord::line_index(self : IntelHexRecord) -> Int

    IntelHexRecord::record_type

    source
    fn IntelHexRecord::record_type(self : IntelHexRecord) -> IntelRecordType

    IntelRecordType

    source
    pub(all) enum IntelRecordType {
      IntelData
      IntelEndOfFile
      IntelExtendedSegmentAddress
      IntelStartSegmentAddress
      IntelExtendedLinearAddress
      IntelStartLinearAddress
    } derive(Eq, 
    Debug    )

    MemoryMap

    source
    pub struct MemoryMap {
      region_values : Array[MemoryRegion]
    } derive(Eq, 
    Debug    )

    MemoryMap::create

    source
    fn MemoryMap::create(regions : Array[MemoryRegion]) -> Result[MemoryMap, FirmwareError]

    MemoryMap::executable_capacity

    source
    fn MemoryMap::executable_capacity(self : MemoryMap) -> UInt64

    MemoryMap::region_at

    source
    fn MemoryMap::region_at(self : MemoryMap, address : UInt64) -> MemoryRegion?

    MemoryMap::region_containing_range

    source
    fn MemoryMap::region_containing_range(self : MemoryMap, start : UInt64, end_exclusive : UInt64) -> MemoryRegion?

    Find one region that completely contains a non-empty half-open range.

    MemoryMap::region_count

    source
    fn MemoryMap::region_count(self : MemoryMap) -> Int

    MemoryMap::regions

    source
    fn MemoryMap::regions(self : MemoryMap) -> Array[MemoryRegion]

    MemoryMap::total_capacity

    source
    fn MemoryMap::total_capacity(self : MemoryMap) -> UInt64

    MemoryMap::writable_capacity

    source
    fn MemoryMap::writable_capacity(self : MemoryMap) -> UInt64

    MemoryRegion

    source
    pub struct MemoryRegion {
      name_value : String
      start_value : UInt64
      end_exclusive_value : UInt64
      writable_value : Bool
      executable_value : Bool
    } derive(Eq, 
    Debug    )

    MemoryRegion::contains_address

    source
    fn MemoryRegion::contains_address(self : MemoryRegion, address : UInt64) -> Bool

    MemoryRegion::contains_range

    source
    fn MemoryRegion::contains_range(self : MemoryRegion, start : UInt64, end_exclusive : UInt64) -> Bool

    MemoryRegion::create

    source
    fn MemoryRegion::create(name : String, start : UInt64, end_exclusive : UInt64, writable? : Bool, executable? : Bool) -> Result[MemoryRegion, FirmwareError]

    MemoryRegion::end_exclusive

    source
    fn MemoryRegion::end_exclusive(self : MemoryRegion) -> UInt64

    MemoryRegion::executable

    source
    fn MemoryRegion::executable(self : MemoryRegion) -> Bool

    MemoryRegion::length

    source
    fn MemoryRegion::length(self : MemoryRegion) -> UInt64

    MemoryRegion::name

    source
    fn MemoryRegion::name(self : MemoryRegion) -> String

    MemoryRegion::start

    source
    fn MemoryRegion::start(self : MemoryRegion) -> UInt64

    MemoryRegion::writable

    source
    fn MemoryRegion::writable(self : MemoryRegion) -> Bool

    MissingBytePolicy

    source
    pub(all) enum MissingBytePolicy {
      RejectMissing
      FillMissing(Byte)
    } derive(Eq, 
    Debug    )

    OverlapPolicy

    source
    pub(all) enum OverlapPolicy {
      RejectOverlap
      AllowIdentical
      ReplaceExisting
    } derive(Eq, 
    Debug    )

    ParsedFirmware

    source
    pub struct ParsedFirmware {
      format_value : FirmwareFormat
      image_value : FirmwareImage
      record_count_value : Int
    } derive(Eq, 
    Debug    )

    ParsedFirmware::format

    source

    ParsedFirmware::image

    source

    ParsedFirmware::record_count

    source
    fn ParsedFirmware::record_count(self : ParsedFirmware) -> Int

    PatchHunk

    source
    pub struct PatchHunk {
      kind_value : PatchKind
      address_value : UInt64
      before_value : Bytes
      after_value : Bytes
    } derive(Eq, 
    Debug    )

    PatchHunk::address

    source
    fn PatchHunk::address(self : PatchHunk) -> UInt64

    PatchHunk::after

    source
    fn PatchHunk::after(self : PatchHunk) -> Bytes

    PatchHunk::before

    source
    fn PatchHunk::before(self : PatchHunk) -> Bytes

    PatchHunk::kind

    source
    fn PatchHunk::kind(self : PatchHunk) -> PatchKind

    PatchHunk::length

    source
    fn PatchHunk::length(self : PatchHunk) -> Int

    PatchKind

    source
    pub(all) enum PatchKind {
      PatchAdd
      PatchRemove
      PatchReplace
    } derive(Eq, 
    Debug    )

    RangeCoverage

    source
    pub(all) struct RangeCoverage {
      start_value : UInt64
      end_exclusive_value : UInt64
      present_bytes_value : UInt64
      missing_bytes_value : UInt64
    } derive(Eq, 
    Debug    )

    RangeCoverage::complete

    source
    fn RangeCoverage::complete(self : RangeCoverage) -> Bool

    RangeCoverage::end_exclusive

    source
    fn RangeCoverage::end_exclusive(self : RangeCoverage) -> UInt64

    RangeCoverage::missing_bytes

    source
    fn RangeCoverage::missing_bytes(self : RangeCoverage) -> UInt64

    RangeCoverage::present_bytes

    source
    fn RangeCoverage::present_bytes(self : RangeCoverage) -> UInt64

    RangeCoverage::ratio

    source
    fn RangeCoverage::ratio(self : RangeCoverage) -> Double

    RangeCoverage::start

    source
    fn RangeCoverage::start(self : RangeCoverage) -> UInt64

    RecordCategoryStatistics

    source
    pub struct RecordCategoryStatistics {
      name_value : String
      record_count_value : Int
      data_bytes_value : Int
    } derive(Eq, 
    Debug    )

    RecordCategoryStatistics::data_bytes

    source

    RecordCategoryStatistics::name

    source

    RecordCategoryStatistics::record_count

    source
    fn RecordCategoryStatistics::record_count(self : RecordCategoryStatistics) -> Int

    SRecord

    source
    pub struct SRecord {
      record_type_value : SRecordType
      address_value : UInt64
      data_value : Bytes
      checksum_value : Byte
      line_index_value : Int
    } derive(Eq, 
    Debug    )

    SRecord::address

    source
    fn SRecord::address(self : SRecord) -> UInt64

    SRecord::byte_count

    source
    fn SRecord::byte_count(self : SRecord) -> Int

    SRecord::checksum

    source
    fn SRecord::checksum(self : SRecord) -> Byte

    SRecord::data

    source
    fn SRecord::data(self : SRecord) -> Bytes

    SRecord::encode

    source
    fn SRecord::encode(self : SRecord) -> String

    Encode a validated record using uppercase hexadecimal digits.

    SRecord::line_index

    source
    fn SRecord::line_index(self : SRecord) -> Int

    SRecord::record_type

    source
    fn SRecord::record_type(self : SRecord) -> SRecordType

    SRecordDocument

    source
    pub struct SRecordDocument {
      record_values : Array[SRecord]
      header_value : Bytes?
      chunk_values : Array[FirmwareChunk]
      declared_data_count_value : Int?
      entry_point_value : UInt64?
    } derive(Eq, 
    Debug    )

    SRecordDocument::data_chunks

    source

    SRecordDocument::declared_data_count

    source
    fn SRecordDocument::declared_data_count(self : SRecordDocument) -> Int?

    SRecordDocument::entry_point

    source
    fn SRecordDocument::entry_point(self : SRecordDocument) -> UInt64?

    SRecordDocument::header

    source
    fn SRecordDocument::header(self : SRecordDocument) -> Bytes?

    SRecordDocument::records

    source

    SRecordType

    source
    pub(all) enum SRecordType {
      SHeader
      SData16
      SData24
      SData32
      SCount16
      SCount24
      STerminate32
      STerminate24
      STerminate16
    } derive(Eq, 
    Debug    )

    SRecordType::address_bytes

    source
    fn SRecordType::address_bytes(self : SRecordType) -> Int

    SRecordType::is_count

    source
    fn SRecordType::is_count(self : SRecordType) -> Bool

    SRecordType::is_data

    source
    fn SRecordType::is_data(self : SRecordType) -> Bool

    SRecordType::is_termination

    source
    fn SRecordType::is_termination(self : SRecordType) -> Bool

    SegmentDigest

    source
    pub(all) struct SegmentDigest {
      address_value : UInt64
      length_value : Int
      crc32_value : UInt
      crc16_value : Int
    } derive(Eq, 
    Debug    )

    SegmentDigest::address

    source
    fn SegmentDigest::address(self : SegmentDigest) -> UInt64

    SegmentDigest::crc16

    source
    fn SegmentDigest::crc16(self : SegmentDigest) -> Int

    SegmentDigest::crc32

    source
    fn SegmentDigest::crc32(self : SegmentDigest) -> UInt

    SegmentDigest::length

    source
    fn SegmentDigest::length(self : SegmentDigest) -> Int

    SegmentPlacement

    source
    pub struct SegmentPlacement {
      start_value : UInt64
      end_exclusive_value : UInt64
      mapped_bytes_value : UInt64
      unmapped_bytes_value : UInt64
      region_name_values : Array[String]
    } derive(Eq, 
    Debug    )

    SegmentPlacement::end_exclusive

    source
    fn SegmentPlacement::end_exclusive(self : SegmentPlacement) -> UInt64

    SegmentPlacement::mapped_bytes

    source
    fn SegmentPlacement::mapped_bytes(self : SegmentPlacement) -> UInt64

    SegmentPlacement::region_names

    source
    fn SegmentPlacement::region_names(self : SegmentPlacement) -> Array[String]

    SegmentPlacement::start

    source
    fn SegmentPlacement::start(self : SegmentPlacement) -> UInt64

    SegmentPlacement::unmapped_bytes

    source
    fn SegmentPlacement::unmapped_bytes(self : SegmentPlacement) -> UInt64

    SourcePosition

    source
    pub(all) struct SourcePosition {
      line_index_value : Int
      column_index_value : Int?
    } derive(Eq, 
    Debug    )

    SourcePosition::column

    source
    fn SourcePosition::column(line_index : Int, column_index : Int) -> SourcePosition

    SourcePosition::column_index

    source
    fn SourcePosition::column_index(self : SourcePosition) -> Int?

    SourcePosition::line

    source
    fn SourcePosition::line(line_index : Int) -> SourcePosition

    SourcePosition::line_index

    source
    fn SourcePosition::line_index(self : SourcePosition) -> Int

    analyze_image

    source
    fn analyze_image(image : FirmwareImage) -> ImageStatistics

    Calculate sparse-image metrics without materializing missing addresses.

    analyze_image_layout

    source
    fn analyze_image_layout(image : FirmwareImage, map : MemoryMap) -> ImageLayout

    Compare each sparse image segment with a validated non-overlapping map.

    analyze_intel_document

    source
    fn analyze_intel_document(document : IntelHexDocument) -> DocumentStatistics

    analyze_srecord_document

    source
    fn analyze_srecord_document(document : SRecordDocument) -> DocumentStatistics

    audit_image

    source
    fn audit_image(image : FirmwareImage, policy : AuditPolicy) -> ImageAudit

    Evaluate deterministic image acceptance rules without modifying the image.

    build_manifest

    source
    fn build_manifest(image : FirmwareImage) -> ImageManifest

    Build reproducible per-segment checksums and an address-sensitive fingerprint.

    checksum_sum

    source
    fn checksum_sum(bytes : Bytes) -> Int

    Return the low eight bits of the sum of all bytes.

    compare_images

    source
    fn compare_images(left : FirmwareImage, right : FirmwareImage, max_differences? : Int) -> Result[ImageComparison, FirmwareError]

    Compare sparse images without treating absent addresses as zero bytes.

    crc16_ccitt_false

    source
    fn crc16_ccitt_false(data : Bytes) -> Int

    Calculate CRC-16/CCITT-FALSE with initial value 0xFFFF.

    crc32

    source
    fn crc32(data : Bytes) -> UInt

    Calculate the reflected IEEE CRC-32 checksum.

    create_image_patch

    source
    fn create_image_patch(source : FirmwareImage, target : FirmwareImage, max_differences? : Int) -> Result[ImagePatch, FirmwareError]

    Build ordered contiguous patch hunks from exact sparse-byte differences.

    decode_firmware_chunks

    source
    fn decode_firmware_chunks(chunks : Array[Bytes], format? : FirmwareFormat?, policy? : OverlapPolicy, max_line_bytes? : Int) -> Result[ParsedFirmware, FirmwareError]

    Decode caller-provided byte chunks without depending on chunk boundaries. Input must be ASCII and each logical record is bounded independently.

    decode_hex_bytes

    source
    fn decode_hex_bytes(text : String, line_index? : Int) -> Result[Bytes, FirmwareError]

    Decode an even-length hexadecimal string without ignoring whitespace.

    detect_firmware_format

    source
    fn detect_firmware_format(text : String) -> Result[FirmwareFormat, FirmwareError]

    Detect Intel HEX or S-record from the first non-line-ending code unit.

    encode_hex_bytes

    source
    fn encode_hex_bytes(bytes : Bytes) -> String

    Encode bytes using two uppercase hexadecimal digits per byte.

    ones_complement_checksum

    source
    fn ones_complement_checksum(bytes : Bytes) -> Byte

    Calculate the Motorola S-record one's-complement checksum byte.

    ones_complement_valid

    source
    fn ones_complement_valid(bytes : Bytes) -> Bool

    Verify a byte sequence that includes its S-record checksum byte.

    parse_firmware_image

    source
    fn parse_firmware_image(text : String, format? : FirmwareFormat?, policy? : OverlapPolicy) -> Result[ParsedFirmware, FirmwareError]

    Parse either supported format and build a canonical sparse image.

    parse_intel_hex_document

    source
    fn parse_intel_hex_document(text : String) -> Result[IntelHexDocument, FirmwareError]

    Parse a complete Intel HEX document and resolve data addresses.

    parse_intel_hex_record

    source
    fn parse_intel_hex_record(line : String, line_index? : Int) -> Result[IntelHexRecord, FirmwareError]

    Parse and validate one Intel HEX line without accepting surrounding spaces.

    parse_srecord

    source
    fn parse_srecord(line : String, line_index? : Int) -> Result[SRecord, FirmwareError]

    Parse and validate one Motorola S-record line.

    parse_srecord_document

    source
    fn parse_srecord_document(text : String) -> Result[SRecordDocument, FirmwareError]

    Parse a complete S-record document and validate its bookkeeping records.

    process_firmware_batch

    source
    fn process_firmware_batch(inputs : Array[FirmwareInput]) -> FirmwareBatch

    Process inputs independently and retain ordered error evidence.

    render_comparison_json

    source
    fn render_comparison_json(comparison : ImageComparison) -> String

    Render byte-level comparison evidence using the standard JSON type.

    render_document_statistics_json

    source
    fn render_document_statistics_json(statistics : DocumentStatistics) -> String

    render_document_statistics_text

    source
    fn render_document_statistics_text(statistics : DocumentStatistics) -> String

    render_image_json

    source
    fn render_image_json(image : FirmwareImage, audit : ImageAudit) -> String

    Render image structure and audit findings using the standard JSON type.

    render_image_text

    source
    fn render_image_text(image : FirmwareImage, audit : ImageAudit) -> String

    Render a compact deterministic human-readable image audit.

    render_layout_json

    source
    fn render_layout_json(layout : ImageLayout) -> String

    render_layout_text

    source
    fn render_layout_text(layout : ImageLayout) -> String

    render_patch_json

    source
    fn render_patch_json(patch : ImagePatch) -> String

    render_patch_text

    source
    fn render_patch_text(patch : ImagePatch) -> String

    render_statistics_json

    source
    fn render_statistics_json(statistics : ImageStatistics) -> String

    render_statistics_text

    source
    fn render_statistics_text(statistics : ImageStatistics) -> String

    twos_complement_checksum

    source
    fn twos_complement_checksum(bytes : Bytes) -> Byte

    Calculate the Intel HEX two's-complement checksum byte.

    twos_complement_valid

    source
    fn twos_complement_valid(bytes : Bytes) -> Bool

    Verify a byte sequence that includes its Intel HEX checksum byte.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io