🥮 mooncakes.io

firmware-image-toolkit

Validated Intel HEX and Motorola S-record firmware image toolkit

intel-hex
s-record
firmware
embedded
codec
moon add Zzqy-yi/firmware-image-toolkit@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
7 days ago
Downloads
3
README

#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 issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io