intel_hex 0.6.2 → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/bin/tapioca +27 -0
- data/lib/intel_hex/file_reader.rb +20 -8
- data/lib/intel_hex/record/data.rb +7 -0
- data/lib/intel_hex/record/ela.rb +6 -0
- data/lib/intel_hex/record/eof.rb +7 -0
- data/lib/intel_hex/record/esa.rb +6 -0
- data/lib/intel_hex/record/sla.rb +6 -0
- data/lib/intel_hex/record/ssa.rb +6 -0
- data/lib/intel_hex/record/value_record_uint16.rb +10 -1
- data/lib/intel_hex/record/value_record_uint32.rb +10 -1
- data/lib/intel_hex/record.rb +96 -42
- data/lib/intel_hex/version.rb +2 -1
- data/lib/intel_hex.rb +2 -0
- metadata +18 -3
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 421faab8cf0e7699367a703c7fd3782fab234f5ef35d453facfc1b25fbb23a70
|
|
4
|
+
data.tar.gz: d2b3dd68afd3f5496af8a61e73ba0af1548cb7f369e163b58f98abb8706bfd15
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: e2b32a593af94d8b054726bd2644960d65b3de50c6028048aa0adce90fc1a9012df609702c220ff65aa89d34dae50cb1dbbab3f8598804d0162102e6d4bcb3bf
|
|
7
|
+
data.tar.gz: 1fe3a0a68cd8d65c165e56c967aaa483156961b63f9f37df6cc977cf65b52d7bf4b2a5741d459393f1e589d27baadbf5cb8a435ace592c09c5bf6a33192ee807
|
data/bin/tapioca
ADDED
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
#!/usr/bin/env ruby
|
|
2
|
+
# frozen_string_literal: true
|
|
3
|
+
|
|
4
|
+
#
|
|
5
|
+
# This file was generated by Bundler.
|
|
6
|
+
#
|
|
7
|
+
# The application 'tapioca' is installed as part of a gem, and
|
|
8
|
+
# this file is here to facilitate running it.
|
|
9
|
+
#
|
|
10
|
+
|
|
11
|
+
ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
|
|
12
|
+
|
|
13
|
+
bundle_binstub = File.expand_path("bundle", __dir__)
|
|
14
|
+
|
|
15
|
+
if File.file?(bundle_binstub)
|
|
16
|
+
if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
|
|
17
|
+
load(bundle_binstub)
|
|
18
|
+
else
|
|
19
|
+
abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
|
|
20
|
+
Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
|
|
21
|
+
end
|
|
22
|
+
end
|
|
23
|
+
|
|
24
|
+
require "rubygems"
|
|
25
|
+
require "bundler/setup"
|
|
26
|
+
|
|
27
|
+
load Gem.bin_path("tapioca", "tapioca")
|
|
@@ -1,14 +1,25 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
module IntelHex
|
|
4
5
|
class FileReader
|
|
6
|
+
extend T::Sig
|
|
7
|
+
|
|
8
|
+
sig { returns(Integer) }
|
|
9
|
+
attr_reader :address_base
|
|
10
|
+
|
|
11
|
+
sig { returns(Integer) }
|
|
12
|
+
attr_reader :address_mask
|
|
13
|
+
|
|
14
|
+
sig { params(filename: String).void }
|
|
5
15
|
def initialize(filename)
|
|
6
16
|
@filename = filename
|
|
7
|
-
@address_base = 0
|
|
8
|
-
@address_mask = 0xffff
|
|
17
|
+
@address_base = T.let(0, Integer)
|
|
18
|
+
@address_mask = T.let(0xffff, Integer)
|
|
9
19
|
end
|
|
10
20
|
|
|
11
|
-
|
|
21
|
+
sig { params(block: T.nilable(T.proc.params(arg0: Record).void)).returns(T.nilable(T::Enumerator[Record])) }
|
|
22
|
+
def each_record(&block)
|
|
12
23
|
return enum_for(:each_record) unless block_given?
|
|
13
24
|
|
|
14
25
|
File.open(@filename, "r") do |file|
|
|
@@ -22,19 +33,20 @@ module IntelHex
|
|
|
22
33
|
nil
|
|
23
34
|
end
|
|
24
35
|
|
|
25
|
-
|
|
36
|
+
sig { params(block: T.nilable(T.proc.params(arg0: Integer, arg1: Integer).void)).returns(T.nilable(T::Enumerator[[Integer, Integer]])) }
|
|
37
|
+
def each_byte_with_address(&block)
|
|
26
38
|
return enum_for(:each_byte_with_address) unless block_given?
|
|
27
39
|
|
|
28
40
|
each_record do |record|
|
|
29
|
-
case record
|
|
30
|
-
when
|
|
41
|
+
case record
|
|
42
|
+
when Record::Data
|
|
31
43
|
record.each_byte_with_address do |byte, offset|
|
|
32
44
|
yield byte, (@address_base + (offset & 0xffff)) & @address_mask
|
|
33
45
|
end
|
|
34
|
-
when
|
|
46
|
+
when Record::Esa
|
|
35
47
|
@address_base = record.value << 4 # bits 4..19 of address
|
|
36
48
|
@address_mask = 0xfffff # 20 bit address size
|
|
37
|
-
when
|
|
49
|
+
when Record::Ela
|
|
38
50
|
@address_base = record.value << 16 # bits 16..31 of address
|
|
39
51
|
@address_mask = 0xffffffff # 32 bit address size
|
|
40
52
|
end
|
|
@@ -1,24 +1,30 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
module IntelHex
|
|
4
5
|
class Record
|
|
5
6
|
class Data < Record
|
|
7
|
+
sig { override.returns(Integer) }
|
|
6
8
|
def self.type_id
|
|
7
9
|
0
|
|
8
10
|
end
|
|
9
11
|
|
|
12
|
+
sig { override.returns(Symbol) }
|
|
10
13
|
def self.type_name
|
|
11
14
|
:data
|
|
12
15
|
end
|
|
13
16
|
|
|
17
|
+
sig { override.returns(T::Range[Integer]) }
|
|
14
18
|
def self.type_data_length
|
|
15
19
|
(1..255)
|
|
16
20
|
end
|
|
17
21
|
|
|
22
|
+
sig { override.returns(T::Array[Integer]) }
|
|
18
23
|
def value
|
|
19
24
|
data
|
|
20
25
|
end
|
|
21
26
|
|
|
27
|
+
sig { returns(String) }
|
|
22
28
|
def value_s
|
|
23
29
|
data_string = data.map { |b| format("%02x", b) }.join(" ")
|
|
24
30
|
|
|
@@ -26,6 +32,7 @@ module IntelHex
|
|
|
26
32
|
end
|
|
27
33
|
end
|
|
28
34
|
|
|
35
|
+
sig { params(data: T::Array[Integer]).returns(Data) }
|
|
29
36
|
def self.data(data = [])
|
|
30
37
|
record = Data.new
|
|
31
38
|
record.data = data
|
data/lib/intel_hex/record/ela.rb
CHANGED
|
@@ -1,19 +1,25 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
require "intel_hex/record/value_record_uint16"
|
|
4
5
|
|
|
5
6
|
module IntelHex
|
|
6
7
|
class Record
|
|
7
8
|
class Ela < ValueRecordUint16
|
|
9
|
+
extend T::Sig
|
|
10
|
+
|
|
11
|
+
sig { override.returns(Integer) }
|
|
8
12
|
def self.type_id
|
|
9
13
|
4
|
|
10
14
|
end
|
|
11
15
|
|
|
16
|
+
sig { override.returns(Symbol) }
|
|
12
17
|
def self.type_name
|
|
13
18
|
:ela
|
|
14
19
|
end
|
|
15
20
|
end
|
|
16
21
|
|
|
22
|
+
sig { params(value: T.nilable(Integer)).returns(Ela) }
|
|
17
23
|
def self.ela(value = nil)
|
|
18
24
|
record = Ela.new
|
|
19
25
|
record.value = value if value
|
data/lib/intel_hex/record/eof.rb
CHANGED
|
@@ -1,21 +1,28 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
module IntelHex
|
|
4
5
|
class Record
|
|
5
6
|
class Eof < Record
|
|
7
|
+
extend T::Sig
|
|
8
|
+
|
|
9
|
+
sig { returns(Integer).override }
|
|
6
10
|
def self.type_id
|
|
7
11
|
1
|
|
8
12
|
end
|
|
9
13
|
|
|
14
|
+
sig { returns(Symbol).override }
|
|
10
15
|
def self.type_name
|
|
11
16
|
:eof
|
|
12
17
|
end
|
|
13
18
|
|
|
19
|
+
sig { returns(Integer).override }
|
|
14
20
|
def self.type_data_length
|
|
15
21
|
0
|
|
16
22
|
end
|
|
17
23
|
end
|
|
18
24
|
|
|
25
|
+
sig { returns(Eof) }
|
|
19
26
|
def self.eof
|
|
20
27
|
Eof.new
|
|
21
28
|
end
|
data/lib/intel_hex/record/esa.rb
CHANGED
|
@@ -1,19 +1,25 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
require "intel_hex/record/value_record_uint16"
|
|
4
5
|
|
|
5
6
|
module IntelHex
|
|
6
7
|
class Record
|
|
7
8
|
class Esa < ValueRecordUint16
|
|
9
|
+
extend T::Sig
|
|
10
|
+
|
|
11
|
+
sig { override.returns(Integer) }
|
|
8
12
|
def self.type_id
|
|
9
13
|
2
|
|
10
14
|
end
|
|
11
15
|
|
|
16
|
+
sig { override.returns(Symbol) }
|
|
12
17
|
def self.type_name
|
|
13
18
|
:esa
|
|
14
19
|
end
|
|
15
20
|
end
|
|
16
21
|
|
|
22
|
+
sig { params(value: T.nilable(Integer)).returns(Esa) }
|
|
17
23
|
def self.esa(value = nil)
|
|
18
24
|
record = Esa.new
|
|
19
25
|
record.value = value if value
|
data/lib/intel_hex/record/sla.rb
CHANGED
|
@@ -1,19 +1,25 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
require "intel_hex/record/value_record_uint32"
|
|
4
5
|
|
|
5
6
|
module IntelHex
|
|
6
7
|
class Record
|
|
7
8
|
class Sla < ValueRecordUint32
|
|
9
|
+
extend T::Sig
|
|
10
|
+
|
|
11
|
+
sig { override.returns(Integer) }
|
|
8
12
|
def self.type_id
|
|
9
13
|
5
|
|
10
14
|
end
|
|
11
15
|
|
|
16
|
+
sig { override.returns(Symbol) }
|
|
12
17
|
def self.type_name
|
|
13
18
|
:sla
|
|
14
19
|
end
|
|
15
20
|
end
|
|
16
21
|
|
|
22
|
+
sig { params(value: T.nilable(Integer)).returns(Sla) }
|
|
17
23
|
def self.sla(value = nil)
|
|
18
24
|
record = Sla.new
|
|
19
25
|
record.value = value if value
|
data/lib/intel_hex/record/ssa.rb
CHANGED
|
@@ -1,19 +1,25 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
require "intel_hex/record/value_record_uint32"
|
|
4
5
|
|
|
5
6
|
module IntelHex
|
|
6
7
|
class Record
|
|
7
8
|
class Ssa < ValueRecordUint32
|
|
9
|
+
extend T::Sig
|
|
10
|
+
|
|
11
|
+
sig { override.returns(Integer) }
|
|
8
12
|
def self.type_id
|
|
9
13
|
3
|
|
10
14
|
end
|
|
11
15
|
|
|
16
|
+
sig { override.returns(Symbol) }
|
|
12
17
|
def self.type_name
|
|
13
18
|
:ssa
|
|
14
19
|
end
|
|
15
20
|
end
|
|
16
21
|
|
|
22
|
+
sig { params(value: T.nilable(Integer)).returns(Ssa) }
|
|
17
23
|
def self.ssa(value = nil)
|
|
18
24
|
record = Ssa.new
|
|
19
25
|
record.value = value if value
|
|
@@ -1,18 +1,27 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
module IntelHex
|
|
4
5
|
class Record
|
|
5
6
|
class ValueRecordUint16 < Record
|
|
7
|
+
extend T::Sig
|
|
8
|
+
extend T::Helpers
|
|
9
|
+
|
|
10
|
+
abstract!
|
|
11
|
+
|
|
12
|
+
sig { override.returns(Integer) }
|
|
6
13
|
def self.type_data_length
|
|
7
14
|
2
|
|
8
15
|
end
|
|
9
16
|
|
|
10
17
|
# Retrieve the 16-bit unsigned integer value from the record.
|
|
18
|
+
sig { override.returns(Integer) }
|
|
11
19
|
def value
|
|
12
|
-
(data[0] << 8) | data[1]
|
|
20
|
+
(T.must(data[0]) << 8) | T.must(data[1])
|
|
13
21
|
end
|
|
14
22
|
|
|
15
23
|
# Store a 32-bit unsigned integer value in the record.
|
|
24
|
+
sig { params(value: Integer).void }
|
|
16
25
|
def value=(value)
|
|
17
26
|
data[0..1] = [
|
|
18
27
|
(value & 0xff00) >> 8,
|
|
@@ -1,18 +1,27 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
module IntelHex
|
|
4
5
|
class Record
|
|
5
6
|
class ValueRecordUint32 < Record
|
|
7
|
+
extend T::Sig
|
|
8
|
+
extend T::Helpers
|
|
9
|
+
|
|
10
|
+
abstract!
|
|
11
|
+
|
|
12
|
+
sig { override.returns(Integer) }
|
|
6
13
|
def self.type_data_length
|
|
7
14
|
4
|
|
8
15
|
end
|
|
9
16
|
|
|
10
17
|
# Retrieve the 32-bit unsigned integer value from the record.
|
|
18
|
+
sig { override.returns(Integer) }
|
|
11
19
|
def value
|
|
12
|
-
(data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]
|
|
20
|
+
(T.must(data[0]) << 24) | (T.must(data[1]) << 16) | (T.must(data[2]) << 8) | T.must(data[3])
|
|
13
21
|
end
|
|
14
22
|
|
|
15
23
|
# Store a 32-bit unsigned integer value in the record.
|
|
24
|
+
sig { params(value: Integer).void }
|
|
16
25
|
def value=(value)
|
|
17
26
|
data[0..3] = [
|
|
18
27
|
(value & 0xff000000) >> 24,
|
data/lib/intel_hex/record.rb
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
# frozen_string_literal: true
|
|
2
|
+
# typed: strict
|
|
2
3
|
|
|
3
4
|
module IntelHex
|
|
4
5
|
class MisformattedFileError < RuntimeError; end
|
|
@@ -16,50 +17,64 @@ module IntelHex
|
|
|
16
17
|
class InvalidChecksumError < ValidationError; end
|
|
17
18
|
|
|
18
19
|
class Record
|
|
20
|
+
extend T::Sig
|
|
21
|
+
extend T::Helpers
|
|
22
|
+
|
|
23
|
+
abstract!
|
|
24
|
+
|
|
25
|
+
@type_by_id = T.let({}, T::Hash[Integer, T.class_of(Record)])
|
|
26
|
+
@type_by_name = T.let({}, T::Hash[Symbol, T.class_of(Record)])
|
|
27
|
+
|
|
19
28
|
class << self
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
@type_by_name ||= {}
|
|
29
|
+
extend T::Sig
|
|
30
|
+
extend T::Helpers
|
|
23
31
|
|
|
24
|
-
|
|
25
|
-
raise "Type name #{type.type_name} redefined" if @type_by_name.include?(type.type_name)
|
|
26
|
-
raise "Type id #{type.type_id} redefined" if @type_by_id.include?(type.type_id)
|
|
32
|
+
abstract!
|
|
27
33
|
|
|
28
|
-
|
|
29
|
-
|
|
34
|
+
sig { returns(T::Hash[Integer, T.class_of(Record)]) }
|
|
35
|
+
attr_reader :type_by_id
|
|
30
36
|
|
|
31
|
-
|
|
37
|
+
sig { returns(T::Hash[Symbol, T.class_of(Record)]) }
|
|
38
|
+
attr_reader :type_by_name
|
|
32
39
|
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
40
|
+
sig { params(type: T.class_of(Record)).void }
|
|
41
|
+
def register_type(type)
|
|
42
|
+
raise "Type name #{type.type_name} is not a symbol" unless type.type_name.is_a?(Symbol)
|
|
43
|
+
raise "Type name #{type.type_name} redefined" if type_by_name.include?(type.type_name)
|
|
44
|
+
raise "Type id #{type.type_id} redefined" if type_by_id.include?(type.type_id)
|
|
36
45
|
|
|
37
|
-
|
|
38
|
-
raise NotImplementedError
|
|
46
|
+
type_by_id[type.type_id] = type_by_name[type.type_name] = type
|
|
39
47
|
end
|
|
40
48
|
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
49
|
+
sig { returns(Integer).abstract }
|
|
50
|
+
def type_id; end
|
|
51
|
+
|
|
52
|
+
sig { returns(Symbol).abstract }
|
|
53
|
+
def type_name; end
|
|
44
54
|
|
|
55
|
+
sig { returns(T.any(Integer, T::Range[Integer])).abstract }
|
|
56
|
+
def type_data_length; end
|
|
57
|
+
|
|
58
|
+
sig { params(line: String).returns(Record) }
|
|
45
59
|
def parse(line)
|
|
46
60
|
raise MisformattedFileError, "Expected ':' at start of line" unless line[0] == ":"
|
|
47
61
|
raise MisformattedFileError, "Line length incorrect" unless line.size >= (1 + 2 + 4 + 2)
|
|
48
62
|
|
|
49
|
-
length = line[1..2].to_i(16)
|
|
63
|
+
length = T.must(line[1..2]).to_i(16)
|
|
50
64
|
data_end = (9 + (length * 2))
|
|
51
65
|
|
|
52
|
-
offset = line[3..6].to_i(16)
|
|
53
|
-
type_id = line[7..8].to_i(16)
|
|
54
|
-
data = line[9...data_end].chars.each_slice(2).map { |a| a.join.to_i(16) }
|
|
55
|
-
checksum = line[data_end..(data_end + 2)].to_i(16)
|
|
66
|
+
offset = T.must(line[3..6]).to_i(16)
|
|
67
|
+
type_id = T.must(line[7..8]).to_i(16)
|
|
68
|
+
data = T.must(line[9...data_end]).chars.each_slice(2).map { |a| a.join.to_i(16) }
|
|
69
|
+
checksum = T.must(line[data_end..(data_end + 2)]).to_i(16)
|
|
56
70
|
|
|
57
71
|
raise InvalidTypeError, "Unknown type #{type_id}" unless type_by_id.include?(type_id)
|
|
58
72
|
|
|
59
73
|
type = type_by_id[type_id]
|
|
60
|
-
type.new(length, offset, data, checksum, line: line, validate: true)
|
|
74
|
+
T.must(type).new(length, offset, data, checksum, line: line, validate: true)
|
|
61
75
|
end
|
|
62
76
|
|
|
77
|
+
sig { params(subclass: T::Class[T.anything]).void }
|
|
63
78
|
def inherited(subclass)
|
|
64
79
|
super
|
|
65
80
|
|
|
@@ -69,35 +84,61 @@ module IntelHex
|
|
|
69
84
|
|
|
70
85
|
private_class_method :new
|
|
71
86
|
|
|
72
|
-
|
|
87
|
+
sig { returns(Integer) }
|
|
88
|
+
attr_reader :length
|
|
89
|
+
|
|
90
|
+
sig { returns(Integer) }
|
|
91
|
+
attr_reader :offset
|
|
92
|
+
|
|
93
|
+
sig { returns(T::Array[Integer]) }
|
|
94
|
+
attr_reader :data
|
|
73
95
|
|
|
96
|
+
sig { returns(T.nilable(Integer)) }
|
|
97
|
+
attr_reader :checksum
|
|
98
|
+
|
|
99
|
+
sig { returns(T.nilable(String)) }
|
|
100
|
+
attr_reader :line
|
|
101
|
+
|
|
102
|
+
sig do
|
|
103
|
+
params(
|
|
104
|
+
length: Integer,
|
|
105
|
+
offset: Integer,
|
|
106
|
+
data: T::Array[Integer],
|
|
107
|
+
checksum: T.nilable(Integer),
|
|
108
|
+
line: T.nilable(String),
|
|
109
|
+
validate: T::Boolean
|
|
110
|
+
).void
|
|
111
|
+
end
|
|
74
112
|
def initialize(length = 0, offset = 0, data = [], checksum = nil, line: nil, validate: false)
|
|
75
113
|
@length = length
|
|
76
114
|
@offset = offset
|
|
77
115
|
@data = data
|
|
78
|
-
@calculated_checksum = nil
|
|
79
|
-
@checksum = checksum || calculate_checksum
|
|
116
|
+
@calculated_checksum = T.let(nil, T.nilable(Integer))
|
|
117
|
+
@checksum = T.let(checksum || calculate_checksum, T.nilable(Integer))
|
|
80
118
|
@line = line
|
|
81
119
|
|
|
82
120
|
self.validate if validate
|
|
83
121
|
end
|
|
84
122
|
|
|
123
|
+
sig { returns(Integer) }
|
|
85
124
|
def type_id
|
|
86
125
|
self.class.type_id
|
|
87
126
|
end
|
|
88
127
|
|
|
128
|
+
sig { returns(Symbol) }
|
|
89
129
|
def type_name
|
|
90
130
|
self.class.type_name
|
|
91
131
|
end
|
|
92
132
|
|
|
93
133
|
alias type type_name
|
|
94
134
|
|
|
135
|
+
sig { returns(T.any(Integer, T::Range[Integer])) }
|
|
95
136
|
def type_data_length
|
|
96
137
|
self.class.type_data_length
|
|
97
138
|
end
|
|
98
139
|
|
|
140
|
+
sig { params(value: T::Array[Integer]).void }
|
|
99
141
|
def data=(value)
|
|
100
|
-
raise InvalidDataError, "Incorrect data type" unless value.is_a?(Array)
|
|
101
142
|
raise InvalidLengthError, "Data length #{value.size} too large" unless value.size <= 255
|
|
102
143
|
|
|
103
144
|
@data = value
|
|
@@ -105,19 +146,21 @@ module IntelHex
|
|
|
105
146
|
@checksum = recalculate_checksum
|
|
106
147
|
end
|
|
107
148
|
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
end
|
|
149
|
+
sig { returns(T.nilable(T.any(Integer, T::Array[Integer]))) }
|
|
150
|
+
def value; end
|
|
111
151
|
|
|
152
|
+
sig { returns(String) }
|
|
112
153
|
def value_s
|
|
113
154
|
value.to_s
|
|
114
155
|
end
|
|
115
156
|
|
|
157
|
+
sig { returns(String) }
|
|
116
158
|
def to_s
|
|
117
|
-
type_value =
|
|
159
|
+
type_value = "#{type}=#{value_s}"
|
|
118
160
|
"#<#{self.class.name} type=#{type_name} offset=#{offset} length=#{length} #{type_value}>"
|
|
119
161
|
end
|
|
120
162
|
|
|
163
|
+
sig { returns(T::Hash[Symbol, T.untyped]) }
|
|
121
164
|
def to_h
|
|
122
165
|
{
|
|
123
166
|
type: type,
|
|
@@ -127,6 +170,7 @@ module IntelHex
|
|
|
127
170
|
}.merge({ type => value })
|
|
128
171
|
end
|
|
129
172
|
|
|
173
|
+
sig { returns(String) }
|
|
130
174
|
def to_ascii
|
|
131
175
|
format(
|
|
132
176
|
":%02X%04X%02X%s%02X",
|
|
@@ -138,6 +182,7 @@ module IntelHex
|
|
|
138
182
|
)
|
|
139
183
|
end
|
|
140
184
|
|
|
185
|
+
sig { returns(Integer) }
|
|
141
186
|
def calculate_checksum
|
|
142
187
|
return @calculated_checksum if @calculated_checksum
|
|
143
188
|
|
|
@@ -147,11 +192,13 @@ module IntelHex
|
|
|
147
192
|
@calculated_checksum = (((sum & 0xff) ^ 0xff) + 1) & 0xff
|
|
148
193
|
end
|
|
149
194
|
|
|
195
|
+
sig { returns(Integer) }
|
|
150
196
|
def recalculate_checksum
|
|
151
197
|
@calculated_checksum = nil
|
|
152
198
|
calculate_checksum
|
|
153
199
|
end
|
|
154
200
|
|
|
201
|
+
sig { returns(T::Boolean) }
|
|
155
202
|
def valid?
|
|
156
203
|
validate
|
|
157
204
|
true
|
|
@@ -159,44 +206,51 @@ module IntelHex
|
|
|
159
206
|
false
|
|
160
207
|
end
|
|
161
208
|
|
|
162
|
-
|
|
209
|
+
sig { returns(T::Boolean) }
|
|
210
|
+
def validate # rubocop:disable Naming/PredicateMethod
|
|
163
211
|
validate_length
|
|
164
212
|
validate_offset
|
|
165
213
|
validate_data
|
|
166
214
|
validate_checksum
|
|
215
|
+
|
|
216
|
+
true # We'll raise an exception if validation fails.
|
|
167
217
|
end
|
|
168
218
|
|
|
219
|
+
sig { void }
|
|
169
220
|
def validate_offset
|
|
170
221
|
raise InvalidOffsetError, "Offset #{offset} is negative" unless offset >= 0
|
|
171
|
-
raise InvalidOffsetError, "Offset #{offset} is too large" unless offset <
|
|
222
|
+
raise InvalidOffsetError, "Offset #{offset} is too large" unless offset < 65_536
|
|
172
223
|
end
|
|
173
224
|
|
|
225
|
+
sig { void }
|
|
174
226
|
def validate_length
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
raise InvalidTypeError, "Length for type #{type} is unhandled by validation"
|
|
227
|
+
tdl = type_data_length
|
|
228
|
+
|
|
229
|
+
if tdl.is_a?(Integer)
|
|
230
|
+
return if length == tdl
|
|
231
|
+
elsif tdl.is_a?(Range)
|
|
232
|
+
return if tdl.include?(length)
|
|
182
233
|
end
|
|
183
234
|
|
|
184
|
-
raise InvalidLengthError, "Length for type #{type} must be #{
|
|
235
|
+
raise InvalidLengthError, "Length for type #{type} must be #{tdl}; #{length} given"
|
|
185
236
|
end
|
|
186
237
|
|
|
238
|
+
sig { void }
|
|
187
239
|
def validate_data
|
|
188
240
|
return if data.size == length
|
|
189
241
|
|
|
190
242
|
raise InvalidDataError, "Data length #{data.size} does not match length #{length}"
|
|
191
243
|
end
|
|
192
244
|
|
|
245
|
+
sig { void }
|
|
193
246
|
def validate_checksum
|
|
194
247
|
return if calculate_checksum == checksum
|
|
195
248
|
|
|
196
249
|
raise InvalidChecksumError, "Checksum value #{checksum} does not match expected checksum #{calculate_checksum}"
|
|
197
250
|
end
|
|
198
251
|
|
|
199
|
-
|
|
252
|
+
sig { params(blk: T.untyped).returns(T.nilable(T::Enumerator[T.untyped])) }
|
|
253
|
+
def each_byte_with_address(&blk)
|
|
200
254
|
return enum_for(:each_byte_with_address) unless block_given?
|
|
201
255
|
|
|
202
256
|
data.each_with_index do |byte, i|
|
data/lib/intel_hex/version.rb
CHANGED
data/lib/intel_hex.rb
CHANGED
metadata
CHANGED
|
@@ -1,14 +1,28 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: intel_hex
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.
|
|
4
|
+
version: 0.7.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Jeremy Cole
|
|
8
8
|
bindir: bin
|
|
9
9
|
cert_chain: []
|
|
10
10
|
date: 1980-01-02 00:00:00.000000000 Z
|
|
11
|
-
dependencies:
|
|
11
|
+
dependencies:
|
|
12
|
+
- !ruby/object:Gem::Dependency
|
|
13
|
+
name: sorbet-runtime
|
|
14
|
+
requirement: !ruby/object:Gem::Requirement
|
|
15
|
+
requirements:
|
|
16
|
+
- - ">="
|
|
17
|
+
- !ruby/object:Gem::Version
|
|
18
|
+
version: '0'
|
|
19
|
+
type: :runtime
|
|
20
|
+
prerelease: false
|
|
21
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
22
|
+
requirements:
|
|
23
|
+
- - ">="
|
|
24
|
+
- !ruby/object:Gem::Version
|
|
25
|
+
version: '0'
|
|
12
26
|
description: An Intel hex file parser for (e.g. AVR) working with firmware files
|
|
13
27
|
email: jeremy@jcole.us
|
|
14
28
|
executables:
|
|
@@ -19,6 +33,7 @@ files:
|
|
|
19
33
|
- LICENSE.md
|
|
20
34
|
- README.md
|
|
21
35
|
- bin/intel_hex_reader
|
|
36
|
+
- bin/tapioca
|
|
22
37
|
- lib/intel_hex.rb
|
|
23
38
|
- lib/intel_hex/file_reader.rb
|
|
24
39
|
- lib/intel_hex/record.rb
|
|
@@ -50,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
50
65
|
- !ruby/object:Gem::Version
|
|
51
66
|
version: '0'
|
|
52
67
|
requirements: []
|
|
53
|
-
rubygems_version: 4.0.
|
|
68
|
+
rubygems_version: 4.0.23
|
|
54
69
|
specification_version: 4
|
|
55
70
|
summary: Parser for Intel hex files
|
|
56
71
|
test_files: []
|