openmath 0.1.1 → 0.2.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/README.adoc +45 -5
- data/data/binding-table-1.yml +76 -0
- data/data/pmquant.ocd +89 -0
- data/data/pmquant.sts +60 -0
- data/data/portable-bindings.json +1 -0
- data/data/replay-vectors.yml +70 -0
- data/lib/openmath/base/omforeign.rb +18 -4
- data/lib/openmath/base/omobj.rb +7 -0
- data/lib/openmath/binary.rb +699 -0
- data/lib/openmath/canonical.rb +127 -0
- data/lib/openmath/cd/cds_namespace.rb +13 -0
- data/lib/openmath/cd/group_collection.rb +160 -0
- data/lib/openmath/cd/group_document.rb +50 -0
- data/lib/openmath/cd/namespace.rb +6 -0
- data/lib/openmath/cd/signature_document.rb +53 -0
- data/lib/openmath/cd/signatures.rb +63 -0
- data/lib/openmath/cd.rb +10 -0
- data/lib/openmath/common_elements.rb +9 -0
- data/lib/openmath/content_mathml.rb +443 -0
- data/lib/openmath/content_mathml_operators.rb +51 -0
- data/lib/openmath/evaluation/closure.rb +11 -0
- data/lib/openmath/evaluation/errors.rb +30 -0
- data/lib/openmath/evaluation/evaluator.rb +192 -32
- data/lib/openmath/evaluation/interval.rb +17 -0
- data/lib/openmath/evaluation/operations.rb +394 -12
- data/lib/openmath/evaluation/portable.rb +114 -0
- data/lib/openmath/evaluation/signature_checker.rb +173 -0
- data/lib/openmath/evaluation/stochastic.rb +113 -0
- data/lib/openmath/evaluation/uncertain.rb +64 -0
- data/lib/openmath/evaluation.rb +12 -2
- data/lib/openmath/foreign.rb +146 -0
- data/lib/openmath/tagged.rb +41 -0
- data/lib/openmath/v2.rb +1 -1
- data/lib/openmath/v3.rb +1 -1
- data/lib/openmath/version.rb +1 -1
- data/lib/openmath.rb +41 -3
- data/schemas/PROVENANCE.md +3 -0
- data/schemas/omcdgroup2.rnc +33 -0
- data/schemas/omcdgroup2.rng +86 -0
- metadata +26 -2
|
@@ -0,0 +1,699 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require "base64"
|
|
4
|
+
|
|
5
|
+
module Openmath
|
|
6
|
+
# The OpenMath 2 binary encoding (omstd20, the binary encoding chapter):
|
|
7
|
+
# a compact tagged byte format with the shared-object optimization.
|
|
8
|
+
#
|
|
9
|
+
# The writer emits the [88] framing (references enabled) when the object
|
|
10
|
+
# carries a version attribute, the plain [24] framing otherwise. It never
|
|
11
|
+
# streams packets and shares exactly the OMR-referenced targets; the id
|
|
12
|
+
# strings themselves have no carrier in the binary format, so the reader
|
|
13
|
+
# synthesizes ids for referenced targets. The reader honors both framings,
|
|
14
|
+
# streaming packets for the basic objects, internal references, cdbase
|
|
15
|
+
# scopes, and refuses everything it cannot decode with a typed error.
|
|
16
|
+
module Binary
|
|
17
|
+
# Malformed binary: truncation, bad tags, bad sign/base bytes, invalid
|
|
18
|
+
# or forward references.
|
|
19
|
+
class Error < StandardError; end
|
|
20
|
+
|
|
21
|
+
TAG_INTEGER = 1
|
|
22
|
+
TAG_BIG_INTEGER = 2
|
|
23
|
+
TAG_FLOAT = 3
|
|
24
|
+
TAG_BYTEARRAY = 4
|
|
25
|
+
TAG_VARIABLE = 5
|
|
26
|
+
TAG_STRING8 = 6
|
|
27
|
+
TAG_STRING16 = 7
|
|
28
|
+
TAG_SYMBOL = 8
|
|
29
|
+
TAG_CDBASE = 9
|
|
30
|
+
TAG_FOREIGN = 12
|
|
31
|
+
TAG_APPLICATION = 16
|
|
32
|
+
TAG_ATTRIBUTION = 18
|
|
33
|
+
TAG_ATTRPAIRS = 20
|
|
34
|
+
TAG_ERROR = 22
|
|
35
|
+
TAG_BINDING = 26
|
|
36
|
+
TAG_BVARS = 28
|
|
37
|
+
TAG_INTERNAL_REFERENCE = 30
|
|
38
|
+
TAG_EXTERNAL_REFERENCE = 31
|
|
39
|
+
TAG_END_OBJECT = 25
|
|
40
|
+
|
|
41
|
+
STREAMING_BIT = 0x20
|
|
42
|
+
SHARED_BIT = 0x40
|
|
43
|
+
LONG_BIT = 0x80
|
|
44
|
+
|
|
45
|
+
ELEMENT_TAGS = {
|
|
46
|
+
"OMI" => TAG_INTEGER, "OMF" => TAG_FLOAT, "OMV" => TAG_VARIABLE,
|
|
47
|
+
"OMB" => TAG_BYTEARRAY, "OMSTR" => TAG_STRING8, "OMS" => TAG_SYMBOL,
|
|
48
|
+
"OMFOREIGN" => TAG_FOREIGN,
|
|
49
|
+
}.freeze
|
|
50
|
+
|
|
51
|
+
module_function
|
|
52
|
+
|
|
53
|
+
# Encodes the model (or XML text) to the binary encoding.
|
|
54
|
+
def encode(object_or_xml, version: 2)
|
|
55
|
+
object = object_or_xml.is_a?(String) ? Openmath.parse(object_or_xml, version: version) : object_or_xml
|
|
56
|
+
Writer.new(object).bytes
|
|
57
|
+
end
|
|
58
|
+
|
|
59
|
+
# Decodes the binary encoding into the versioned OMOBJ model; the
|
|
60
|
+
# framing's major version selects the hierarchy unless overridden.
|
|
61
|
+
def decode(bytes, version: nil)
|
|
62
|
+
Decoder.new(bytes).decode(version: version)
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
def length_bytes(long)
|
|
66
|
+
long ? 4 : 1
|
|
67
|
+
end
|
|
68
|
+
|
|
69
|
+
def read_length(reader, long)
|
|
70
|
+
long ? reader.read_uint32 : reader.read_byte
|
|
71
|
+
end
|
|
72
|
+
|
|
73
|
+
def write_length(out, value)
|
|
74
|
+
if value >= 256
|
|
75
|
+
out << [value].pack("N")
|
|
76
|
+
else
|
|
77
|
+
out << value.chr
|
|
78
|
+
end
|
|
79
|
+
end
|
|
80
|
+
|
|
81
|
+
# A byte cursor: every overrun is a truncation error naming its offset.
|
|
82
|
+
class Reader
|
|
83
|
+
attr_reader :bytes, :pos
|
|
84
|
+
|
|
85
|
+
def initialize(bytes)
|
|
86
|
+
@bytes = bytes.b
|
|
87
|
+
@pos = 0
|
|
88
|
+
@shared = []
|
|
89
|
+
end
|
|
90
|
+
|
|
91
|
+
def eof?
|
|
92
|
+
@pos >= @bytes.bytesize
|
|
93
|
+
end
|
|
94
|
+
|
|
95
|
+
def read_byte
|
|
96
|
+
raise Error, "truncated: expected a byte at #{@pos}" if eof?
|
|
97
|
+
|
|
98
|
+
byte = @bytes.getbyte(@pos)
|
|
99
|
+
@pos += 1
|
|
100
|
+
byte
|
|
101
|
+
end
|
|
102
|
+
|
|
103
|
+
def read_uint32
|
|
104
|
+
if @pos + 4 > @bytes.bytesize
|
|
105
|
+
raise Error, "truncated: expected 4 bytes at #{@pos}"
|
|
106
|
+
end
|
|
107
|
+
|
|
108
|
+
value = @bytes.byteslice(@pos, 4).unpack1("N")
|
|
109
|
+
@pos += 4
|
|
110
|
+
value
|
|
111
|
+
end
|
|
112
|
+
|
|
113
|
+
def read_bytes(count)
|
|
114
|
+
if @pos + count > @bytes.bytesize
|
|
115
|
+
raise Error, "truncated: expected #{count} bytes at #{@pos}"
|
|
116
|
+
end
|
|
117
|
+
|
|
118
|
+
data = @bytes.byteslice(@pos, count)
|
|
119
|
+
@pos += count
|
|
120
|
+
data.b
|
|
121
|
+
end
|
|
122
|
+
|
|
123
|
+
def read_tag
|
|
124
|
+
byte = read_byte
|
|
125
|
+
[byte & 0x1F, byte & STREAMING_BIT != 0, byte & SHARED_BIT != 0,
|
|
126
|
+
byte & LONG_BIT != 0]
|
|
127
|
+
end
|
|
128
|
+
|
|
129
|
+
def unread_tag
|
|
130
|
+
@pos -= 1
|
|
131
|
+
end
|
|
132
|
+
|
|
133
|
+
def signed_value(uint)
|
|
134
|
+
uint >= 0x80000000 ? uint - (1 << 32) : uint
|
|
135
|
+
end
|
|
136
|
+
|
|
137
|
+
def record_shared(node)
|
|
138
|
+
@shared << node
|
|
139
|
+
end
|
|
140
|
+
|
|
141
|
+
def shared_object(ordinal)
|
|
142
|
+
node = @shared[ordinal]
|
|
143
|
+
raise Error, "internal reference #{ordinal} exceeds the #{@shared.size} shared objects" if node.nil?
|
|
144
|
+
|
|
145
|
+
node
|
|
146
|
+
end
|
|
147
|
+
end
|
|
148
|
+
|
|
149
|
+
# The decoder: framing, then the object, then the end tag.
|
|
150
|
+
class Decoder
|
|
151
|
+
def initialize(bytes)
|
|
152
|
+
@reader = Reader.new(bytes)
|
|
153
|
+
end
|
|
154
|
+
|
|
155
|
+
def decode(version: nil)
|
|
156
|
+
major, minor, referenced = read_framing
|
|
157
|
+
hierarchy = version || (major == 3 ? :V3 : :V2)
|
|
158
|
+
Openmath.const_get(hierarchy).register_models!
|
|
159
|
+
root = Openmath.const_get(hierarchy).const_get(:Omobj).new
|
|
160
|
+
root.version = "#{major}.#{minor}" if referenced
|
|
161
|
+
child = read_object(referenced: referenced, hierarchy: hierarchy)
|
|
162
|
+
slot(root, child)
|
|
163
|
+
|
|
164
|
+
expect_tag(TAG_END_OBJECT)
|
|
165
|
+
raise Error, "trailing bytes after the object" unless @reader.eof?
|
|
166
|
+
|
|
167
|
+
root
|
|
168
|
+
end
|
|
169
|
+
|
|
170
|
+
# The framings share the 5-bit object tag; the shared flag bit
|
|
171
|
+
# distinguishes [24] (plain) from [24+64] (versioned, references).
|
|
172
|
+
def read_framing
|
|
173
|
+
tag, _streaming, shared, = @reader.read_tag
|
|
174
|
+
raise Error, "expected an object start tag, got #{tag}" unless tag == 24
|
|
175
|
+
|
|
176
|
+
if shared
|
|
177
|
+
[@reader.read_byte, @reader.read_byte, true]
|
|
178
|
+
else
|
|
179
|
+
[2, 0, false]
|
|
180
|
+
end
|
|
181
|
+
end
|
|
182
|
+
|
|
183
|
+
def read_object(referenced:, hierarchy:)
|
|
184
|
+
tag, streaming, shared, long = @reader.read_tag
|
|
185
|
+
if streaming && !streamable?(tag)
|
|
186
|
+
raise Error, "streaming bit on unstreamable tag #{tag}"
|
|
187
|
+
end
|
|
188
|
+
|
|
189
|
+
node = case tag
|
|
190
|
+
when TAG_INTEGER then streaming ? read_streamed_small_integer(hierarchy) : read_small_integer(long, hierarchy)
|
|
191
|
+
when TAG_BIG_INTEGER then read_big_integer(streaming, long, hierarchy)
|
|
192
|
+
when TAG_FLOAT then read_float(long, hierarchy)
|
|
193
|
+
when TAG_BYTEARRAY then read_bytearray(streaming, long, hierarchy)
|
|
194
|
+
when TAG_VARIABLE then read_variable(long, hierarchy)
|
|
195
|
+
when TAG_STRING8 then read_string8(streaming, long, hierarchy)
|
|
196
|
+
when TAG_STRING16 then read_string16(streaming, long, hierarchy)
|
|
197
|
+
when TAG_SYMBOL then read_symbol(long, hierarchy)
|
|
198
|
+
when TAG_CDBASE then read_cdbase(long, referenced, hierarchy)
|
|
199
|
+
when TAG_FOREIGN then read_foreign(streaming, long, hierarchy)
|
|
200
|
+
when TAG_APPLICATION then read_children_until(TAG_APPLICATION + 1, referenced, hierarchy, model(hierarchy, :Oma))
|
|
201
|
+
when TAG_ATTRIBUTION then read_attribution(referenced, hierarchy)
|
|
202
|
+
when TAG_ERROR then read_error(referenced, hierarchy)
|
|
203
|
+
when TAG_BINDING then read_binding(referenced, hierarchy)
|
|
204
|
+
when TAG_INTERNAL_REFERENCE then read_internal_reference(long, hierarchy)
|
|
205
|
+
when TAG_EXTERNAL_REFERENCE then read_external_reference(long, hierarchy)
|
|
206
|
+
else raise Error, "unknown tag #{tag} at #{@reader.pos - 1}"
|
|
207
|
+
end
|
|
208
|
+
@reader.record_shared(node) if shared
|
|
209
|
+
node
|
|
210
|
+
end
|
|
211
|
+
|
|
212
|
+
def streamable?(tag)
|
|
213
|
+
[TAG_INTEGER, TAG_BIG_INTEGER, TAG_BYTEARRAY, TAG_STRING8,
|
|
214
|
+
TAG_STRING16, TAG_FOREIGN].include?(tag)
|
|
215
|
+
end
|
|
216
|
+
|
|
217
|
+
# Packets of the same tag accumulate until one clears the streaming
|
|
218
|
+
# bit; shared flags never appear on packets.
|
|
219
|
+
def read_streaming(tag, &read_packet)
|
|
220
|
+
chunks = []
|
|
221
|
+
loop do
|
|
222
|
+
packet_tag, streaming, shared, long = @reader.read_tag
|
|
223
|
+
raise Error, "shared flag on a streamed packet" if shared
|
|
224
|
+
raise Error, "streamed packet tag #{packet_tag} contradicts #{tag}" if packet_tag != tag
|
|
225
|
+
|
|
226
|
+
chunks << read_packet.call(long)
|
|
227
|
+
break unless streaming
|
|
228
|
+
end
|
|
229
|
+
chunks
|
|
230
|
+
end
|
|
231
|
+
|
|
232
|
+
def read_small_integer(long, hierarchy)
|
|
233
|
+
value = long ? @reader.signed_value(@reader.read_uint32) : @reader.read_byte
|
|
234
|
+
value -= 256 if !long && value >= 128
|
|
235
|
+
integer_node(value, hierarchy)
|
|
236
|
+
end
|
|
237
|
+
|
|
238
|
+
# Streamed small-integer packets assemble as most-significant-first
|
|
239
|
+
# base-128 digits; only the initial packet carries the sign.
|
|
240
|
+
def read_streamed_small_integer(hierarchy)
|
|
241
|
+
digits = read_streaming(TAG_INTEGER) do |long|
|
|
242
|
+
digit = long ? @reader.signed_value(@reader.read_uint32) : @reader.read_byte
|
|
243
|
+
raise Error, "base-128 digit #{digit} out of range" if !long && digit >= 128
|
|
244
|
+
|
|
245
|
+
digit
|
|
246
|
+
end
|
|
247
|
+
value = digits.first >= 128 ? digits.first - 256 : digits.first
|
|
248
|
+
digits.drop(1).each { |digit| value = value * 128 + digit }
|
|
249
|
+
integer_node(value, hierarchy)
|
|
250
|
+
end
|
|
251
|
+
|
|
252
|
+
def read_big_integer(streaming, long, hierarchy)
|
|
253
|
+
chunks = streaming ? read_streaming(TAG_BIG_INTEGER) { |l| read_length_bytes(l) } : [read_length_bytes(long)]
|
|
254
|
+
text = chunks.join.b
|
|
255
|
+
raise Error, "big integer without a sign/base byte" if text.empty?
|
|
256
|
+
|
|
257
|
+
sign_base = text.slice!(0).getbyte(0)
|
|
258
|
+
digits = text
|
|
259
|
+
value = case sign_base & 0xC0
|
|
260
|
+
when 0x80 then digits.bytes.inject(0) { |acc, byte| (acc << 8) | byte }
|
|
261
|
+
when 0x40 then Integer("0x#{digits}")
|
|
262
|
+
else Integer(digits)
|
|
263
|
+
end
|
|
264
|
+
value = -value if (sign_base & 0x3F) == 0x2D
|
|
265
|
+
integer_node(value, hierarchy)
|
|
266
|
+
end
|
|
267
|
+
|
|
268
|
+
def read_length_bytes(long)
|
|
269
|
+
@reader.read_bytes(Openmath::Binary.read_length(@reader, long))
|
|
270
|
+
end
|
|
271
|
+
|
|
272
|
+
def read_length(long)
|
|
273
|
+
Openmath::Binary.read_length(@reader, long)
|
|
274
|
+
end
|
|
275
|
+
|
|
276
|
+
def integer_node(value, hierarchy)
|
|
277
|
+
node = model(hierarchy, :Omi)
|
|
278
|
+
node.value = [value.to_s]
|
|
279
|
+
node
|
|
280
|
+
end
|
|
281
|
+
|
|
282
|
+
def read_float(_long, hierarchy)
|
|
283
|
+
bits = @reader.read_bytes(8).unpack1("G")
|
|
284
|
+
node = model(hierarchy, :Omf)
|
|
285
|
+
node.dec = bits.to_s
|
|
286
|
+
node
|
|
287
|
+
end
|
|
288
|
+
|
|
289
|
+
def read_bytearray(streaming, long, hierarchy)
|
|
290
|
+
bytes = streaming ? read_streaming(TAG_BYTEARRAY) { |l| read_length_bytes(l) }.join : read_length_bytes(long)
|
|
291
|
+
node = model(hierarchy, :Omb)
|
|
292
|
+
node.value = [Base64.strict_encode64(bytes)]
|
|
293
|
+
node
|
|
294
|
+
end
|
|
295
|
+
|
|
296
|
+
def read_string8(streaming, long, hierarchy)
|
|
297
|
+
text = streaming ? read_streaming(TAG_STRING8) { |l| read_length_bytes(l) }.join : read_length_bytes(long)
|
|
298
|
+
string_node(text.force_encoding("UTF-8"), hierarchy)
|
|
299
|
+
end
|
|
300
|
+
|
|
301
|
+
# A string16 length counts UTF-16 units; the payload is 2n bytes.
|
|
302
|
+
def read_string16(streaming, long, hierarchy)
|
|
303
|
+
chunks = streaming ? read_streaming(TAG_STRING16) { |l| @reader.read_bytes(2 * read_length(l)) } : [@reader.read_bytes(2 * read_length(long))]
|
|
304
|
+
string_node(chunks.join.force_encoding("UTF-16BE").encode("UTF-8"), hierarchy)
|
|
305
|
+
end
|
|
306
|
+
|
|
307
|
+
def string_node(text, hierarchy)
|
|
308
|
+
node = model(hierarchy, :Omstr)
|
|
309
|
+
node.value = [text]
|
|
310
|
+
node
|
|
311
|
+
end
|
|
312
|
+
|
|
313
|
+
def read_variable(long, hierarchy)
|
|
314
|
+
node = model(hierarchy, :Omv)
|
|
315
|
+
node.name = @reader.read_bytes(read_length(long)).force_encoding("UTF-8")
|
|
316
|
+
node
|
|
317
|
+
end
|
|
318
|
+
|
|
319
|
+
def read_symbol(long, hierarchy)
|
|
320
|
+
cd_length = read_length(long)
|
|
321
|
+
name_length = read_length(long)
|
|
322
|
+
node = model(hierarchy, :Oms)
|
|
323
|
+
node.cd = @reader.read_bytes(cd_length).force_encoding("UTF-8")
|
|
324
|
+
node.name = @reader.read_bytes(name_length).force_encoding("UTF-8")
|
|
325
|
+
node
|
|
326
|
+
end
|
|
327
|
+
|
|
328
|
+
def read_cdbase(long, referenced, hierarchy)
|
|
329
|
+
uri = @reader.read_bytes(read_length(long)).force_encoding("UTF-8")
|
|
330
|
+
child = read_object(referenced: referenced, hierarchy: hierarchy)
|
|
331
|
+
child.cdbase = uri if child.respond_to?(:cdbase=)
|
|
332
|
+
child
|
|
333
|
+
end
|
|
334
|
+
|
|
335
|
+
def read_foreign(streaming, long, hierarchy)
|
|
336
|
+
chunks = streaming ? read_streaming(TAG_FOREIGN) { |l| read_foreign_packet(l) } : [read_foreign_packet(long)]
|
|
337
|
+
encoding, payload = chunks.transpose.map(&:join)
|
|
338
|
+
node = model(hierarchy, :Omforeign)
|
|
339
|
+
node.foreign_encoding = encoding.force_encoding("UTF-8")
|
|
340
|
+
node.notom_value = payload.empty? ? [] : [payload.force_encoding("UTF-8")]
|
|
341
|
+
node
|
|
342
|
+
end
|
|
343
|
+
|
|
344
|
+
def read_foreign_packet(long)
|
|
345
|
+
encoding_length = read_length(long)
|
|
346
|
+
payload_length = read_length(long)
|
|
347
|
+
[@reader.read_bytes(encoding_length), @reader.read_bytes(payload_length)]
|
|
348
|
+
end
|
|
349
|
+
|
|
350
|
+
# Applications and other plain containers: children until the end
|
|
351
|
+
# tag, each slotted by its element name.
|
|
352
|
+
def read_children_until(end_tag, referenced, hierarchy, node)
|
|
353
|
+
until peek_tag == end_tag
|
|
354
|
+
slot(node, read_object(referenced: referenced, hierarchy: hierarchy))
|
|
355
|
+
end
|
|
356
|
+
consume_tag(end_tag)
|
|
357
|
+
node
|
|
358
|
+
end
|
|
359
|
+
|
|
360
|
+
def read_attribution(referenced, hierarchy)
|
|
361
|
+
node = model(hierarchy, :Omattr)
|
|
362
|
+
pairs = model(hierarchy, :Omatp)
|
|
363
|
+
expect_tag(TAG_ATTRPAIRS)
|
|
364
|
+
until peek_tag == TAG_ATTRPAIRS + 1
|
|
365
|
+
slot(pairs, read_object(referenced: referenced, hierarchy: hierarchy))
|
|
366
|
+
end
|
|
367
|
+
consume_tag(TAG_ATTRPAIRS + 1)
|
|
368
|
+
slot(node, pairs)
|
|
369
|
+
slot(node, read_object(referenced: referenced, hierarchy: hierarchy))
|
|
370
|
+
expect_tag(TAG_ATTRIBUTION + 1)
|
|
371
|
+
node
|
|
372
|
+
end
|
|
373
|
+
|
|
374
|
+
def read_error(referenced, hierarchy)
|
|
375
|
+
node = read_children_until(TAG_ERROR + 1, referenced, hierarchy, model(hierarchy, :Ome))
|
|
376
|
+
unless node.oms_value&.first
|
|
377
|
+
raise Error, "error constructor without a leading symbol"
|
|
378
|
+
end
|
|
379
|
+
|
|
380
|
+
node
|
|
381
|
+
end
|
|
382
|
+
|
|
383
|
+
def read_binding(referenced, hierarchy)
|
|
384
|
+
node = model(hierarchy, :Ombind)
|
|
385
|
+
slot(node, read_object(referenced: referenced, hierarchy: hierarchy))
|
|
386
|
+
expect_tag(TAG_BVARS)
|
|
387
|
+
vars_container = model(hierarchy, :Ombvar)
|
|
388
|
+
until peek_tag == TAG_BVARS + 1
|
|
389
|
+
slot(vars_container, read_object(referenced: referenced, hierarchy: hierarchy))
|
|
390
|
+
end
|
|
391
|
+
consume_tag(TAG_BVARS + 1)
|
|
392
|
+
slot(node, vars_container)
|
|
393
|
+
slot(node, read_object(referenced: referenced, hierarchy: hierarchy))
|
|
394
|
+
expect_tag(TAG_BINDING + 1)
|
|
395
|
+
node
|
|
396
|
+
end
|
|
397
|
+
|
|
398
|
+
# The ordinal names the n+1-th shared sub-object; a referenced
|
|
399
|
+
# target's original id has no carrier in the binary format, so one
|
|
400
|
+
# is synthesized (stable from the first re-serialization on).
|
|
401
|
+
def read_internal_reference(long, hierarchy)
|
|
402
|
+
ordinal = read_length(long)
|
|
403
|
+
target = @reader.shared_object(ordinal)
|
|
404
|
+
node = model(hierarchy, :Omr)
|
|
405
|
+
node.href = "##{target.id || "omr-#{ordinal}"}"
|
|
406
|
+
target.id ||= "omr-#{ordinal}" if target.respond_to?(:id=)
|
|
407
|
+
node
|
|
408
|
+
end
|
|
409
|
+
|
|
410
|
+
def read_external_reference(long, hierarchy)
|
|
411
|
+
node = model(hierarchy, :Omr)
|
|
412
|
+
node.href = @reader.read_bytes(read_length(long)).force_encoding("UTF-8")
|
|
413
|
+
node
|
|
414
|
+
end
|
|
415
|
+
|
|
416
|
+
def peek_tag
|
|
417
|
+
tag, = @reader.read_tag
|
|
418
|
+
@reader.unread_tag
|
|
419
|
+
tag
|
|
420
|
+
end
|
|
421
|
+
|
|
422
|
+
def consume_tag(expected)
|
|
423
|
+
tag, = @reader.read_tag
|
|
424
|
+
raise Error, "expected tag #{expected}, got #{tag}" if tag != expected
|
|
425
|
+
end
|
|
426
|
+
|
|
427
|
+
def expect_tag(expected)
|
|
428
|
+
consume_tag(expected)
|
|
429
|
+
end
|
|
430
|
+
|
|
431
|
+
def slot(node, child)
|
|
432
|
+
name = child.class.mappings_for(:xml).element_name
|
|
433
|
+
attribute = Evaluation::Evaluator::CHILD_ATTRIBUTES[name]
|
|
434
|
+
if attribute.nil? || !node.respond_to?("#{attribute}=")
|
|
435
|
+
raise Error, "child #{name} is not allowed in #{node.class.mappings_for(:xml).element_name}"
|
|
436
|
+
end
|
|
437
|
+
|
|
438
|
+
collection = node.public_send(attribute) || []
|
|
439
|
+
node.public_send(:"#{attribute}=", collection + [child])
|
|
440
|
+
# Document order survives only through the order tracking; decoded
|
|
441
|
+
# children record themselves so serialization walks them in order.
|
|
442
|
+
order = node.element_order ||= []
|
|
443
|
+
order << Lutaml::Xml::Element.new("Element", name, node_type: :element)
|
|
444
|
+
end
|
|
445
|
+
|
|
446
|
+
def model(hierarchy, name)
|
|
447
|
+
Openmath.const_get(hierarchy).const_get(name).new
|
|
448
|
+
end
|
|
449
|
+
end
|
|
450
|
+
|
|
451
|
+
# The encoder: one pass, no streaming, shared flags on exactly the
|
|
452
|
+
# OMR-referenced targets.
|
|
453
|
+
class Writer
|
|
454
|
+
def initialize(root)
|
|
455
|
+
@root = root
|
|
456
|
+
@referenced = {}
|
|
457
|
+
collect_references(root)
|
|
458
|
+
@ordinals = {}
|
|
459
|
+
end
|
|
460
|
+
|
|
461
|
+
def bytes
|
|
462
|
+
out = +"".b
|
|
463
|
+
version = @root.respond_to?(:version) ? @root.version : nil
|
|
464
|
+
if version && !version.to_s.empty?
|
|
465
|
+
major, minor = version.to_s.split(".").map { |part| Integer(part) }
|
|
466
|
+
out << (24 + 64).chr << major.chr << minor.chr
|
|
467
|
+
else
|
|
468
|
+
out << 24.chr
|
|
469
|
+
end
|
|
470
|
+
write_object(@root, out)
|
|
471
|
+
out << TAG_END_OBJECT.chr
|
|
472
|
+
out
|
|
473
|
+
end
|
|
474
|
+
|
|
475
|
+
def collect_references(node)
|
|
476
|
+
CHILDREN(node).each { |child| collect_references(child) }
|
|
477
|
+
return unless node.is_a?(V2::Omr) || node.is_a?(V3::Omr)
|
|
478
|
+
|
|
479
|
+
href = node.href.to_s
|
|
480
|
+
return unless href.start_with?("#")
|
|
481
|
+
|
|
482
|
+
id = href[1..]
|
|
483
|
+
@referenced[id] ||= find_by_id(@root, id)
|
|
484
|
+
end
|
|
485
|
+
|
|
486
|
+
def find_by_id(node, id)
|
|
487
|
+
return node if node.respond_to?(:id) && node.id == id
|
|
488
|
+
|
|
489
|
+
CHILDREN(node).each do |child|
|
|
490
|
+
found = find_by_id(child, id)
|
|
491
|
+
return found if found
|
|
492
|
+
end
|
|
493
|
+
nil
|
|
494
|
+
end
|
|
495
|
+
|
|
496
|
+
def CHILDREN(node)
|
|
497
|
+
return [] unless node.respond_to?(:element_order)
|
|
498
|
+
|
|
499
|
+
Evaluation::Evaluator.ordered_children(node)
|
|
500
|
+
end
|
|
501
|
+
|
|
502
|
+
def write_object(node, out)
|
|
503
|
+
if node.is_a?(V2::Omr) || node.is_a?(V3::Omr)
|
|
504
|
+
write_reference(node, out)
|
|
505
|
+
return
|
|
506
|
+
end
|
|
507
|
+
|
|
508
|
+
unless cdbase(node).nil?
|
|
509
|
+
uri = cdbase(node)
|
|
510
|
+
out << TAG_CDBASE.chr
|
|
511
|
+
out << (uri.bytesize >= 256 ? 1 : 0).chr
|
|
512
|
+
Binary.write_length(out, uri.bytesize)
|
|
513
|
+
out << uri.b
|
|
514
|
+
end
|
|
515
|
+
|
|
516
|
+
shared = mark_shared(node)
|
|
517
|
+
name = node.class.mappings_for(:xml).element_name
|
|
518
|
+
send("write_#{name.downcase}", node, out, shared)
|
|
519
|
+
end
|
|
520
|
+
|
|
521
|
+
def cdbase(node)
|
|
522
|
+
node.respond_to?(:cdbase) && !node.is_a?(V2::Omobj) && !node.is_a?(V3::Omobj) ? node.cdbase : nil
|
|
523
|
+
end
|
|
524
|
+
|
|
525
|
+
def mark_shared(node)
|
|
526
|
+
return false unless node.respond_to?(:id) && @referenced.value?(node)
|
|
527
|
+
return true if @ordinals.key?(node.object_id)
|
|
528
|
+
|
|
529
|
+
@ordinals[node.object_id] = @ordinals.size
|
|
530
|
+
true
|
|
531
|
+
end
|
|
532
|
+
|
|
533
|
+
def write_reference(node, out)
|
|
534
|
+
href = node.href.to_s
|
|
535
|
+
unless href.start_with?("#")
|
|
536
|
+
long = href.bytesize >= 256
|
|
537
|
+
out << tag_byte(TAG_EXTERNAL_REFERENCE, false, long)
|
|
538
|
+
Binary.write_length(out, href.bytesize)
|
|
539
|
+
out << href.b
|
|
540
|
+
return
|
|
541
|
+
end
|
|
542
|
+
|
|
543
|
+
target = @referenced[href[1..]]
|
|
544
|
+
raise Error, "OMR href #{href.inspect} has no target in the object" if target.nil?
|
|
545
|
+
|
|
546
|
+
ordinal = @ordinals[target.object_id]
|
|
547
|
+
if ordinal.nil?
|
|
548
|
+
raise Error, "forward reference: #{href.inspect} targets an object not yet encoded"
|
|
549
|
+
end
|
|
550
|
+
|
|
551
|
+
if ordinal < 256
|
|
552
|
+
out << TAG_INTERNAL_REFERENCE.chr << ordinal.chr
|
|
553
|
+
else
|
|
554
|
+
out << (TAG_INTERNAL_REFERENCE + LONG_BIT).chr << [ordinal].pack("N")
|
|
555
|
+
end
|
|
556
|
+
end
|
|
557
|
+
|
|
558
|
+
def write_integer(node, out, shared)
|
|
559
|
+
value = Integer(node.value.join.gsub(/\s+/, ""))
|
|
560
|
+
if value.between?(-128, 127)
|
|
561
|
+
out << tag_byte(TAG_INTEGER, shared, false)
|
|
562
|
+
out << (value & 0xFF).chr
|
|
563
|
+
elsif value.between?(-(1 << 31), (1 << 31) - 1)
|
|
564
|
+
out << tag_byte(TAG_INTEGER, shared, true)
|
|
565
|
+
out << [value & 0xFFFFFFFF].pack("N")
|
|
566
|
+
else
|
|
567
|
+
digits = value.abs.to_s
|
|
568
|
+
long = digits.bytesize >= 256
|
|
569
|
+
out << tag_byte(TAG_BIG_INTEGER, shared, long)
|
|
570
|
+
Binary.write_length(out, digits.bytesize + 1)
|
|
571
|
+
out << (value.negative? ? 0x2D : 0x2B).chr << digits.b
|
|
572
|
+
end
|
|
573
|
+
end
|
|
574
|
+
|
|
575
|
+
def write_float(node, out, shared)
|
|
576
|
+
out << tag_byte(TAG_FLOAT, shared, false)
|
|
577
|
+
bits = node.hex ? [node.hex].pack("H*").unpack1("G") : Float(node.dec)
|
|
578
|
+
out << [bits].pack("G")
|
|
579
|
+
end
|
|
580
|
+
|
|
581
|
+
def write_variable(node, out, shared)
|
|
582
|
+
name = node.name.to_s
|
|
583
|
+
long = name.bytesize >= 256
|
|
584
|
+
out << tag_byte(TAG_VARIABLE, shared, long)
|
|
585
|
+
Binary.write_length(out, name.bytesize)
|
|
586
|
+
out << name.b
|
|
587
|
+
end
|
|
588
|
+
|
|
589
|
+
def write_symbol(node, out, shared)
|
|
590
|
+
cd = node.cd.to_s
|
|
591
|
+
name = node.name.to_s
|
|
592
|
+
long = [cd, name].map { |part| part.bytesize }.max >= 256
|
|
593
|
+
out << tag_byte(TAG_SYMBOL, shared, long)
|
|
594
|
+
Binary.write_length(out, cd.bytesize)
|
|
595
|
+
Binary.write_length(out, name.bytesize)
|
|
596
|
+
out << cd.b << name.b
|
|
597
|
+
end
|
|
598
|
+
|
|
599
|
+
def write_omstr(node, out, shared)
|
|
600
|
+
text = node.value.join
|
|
601
|
+
if text.ascii_only? || text.encoding == Encoding::UTF_8 && text.bytes.none? { |b| b > 0x7F }
|
|
602
|
+
long = text.bytesize >= 256
|
|
603
|
+
out << tag_byte(TAG_STRING8, shared, long)
|
|
604
|
+
Binary.write_length(out, text.bytesize)
|
|
605
|
+
out << text.b
|
|
606
|
+
else
|
|
607
|
+
units = text.encode("UTF-16BE").bytesize / 2
|
|
608
|
+
long = units >= 256
|
|
609
|
+
out << tag_byte(TAG_STRING16, shared, long)
|
|
610
|
+
Binary.write_length(out, units)
|
|
611
|
+
out << text.encode("UTF-16BE").b
|
|
612
|
+
end
|
|
613
|
+
end
|
|
614
|
+
|
|
615
|
+
def write_omb(node, out, shared)
|
|
616
|
+
bytes = Base64.decode64(node.value.join)
|
|
617
|
+
long = bytes.bytesize >= 256
|
|
618
|
+
out << tag_byte(TAG_BYTEARRAY, shared, long)
|
|
619
|
+
Binary.write_length(out, bytes.bytesize)
|
|
620
|
+
out << bytes
|
|
621
|
+
end
|
|
622
|
+
|
|
623
|
+
def write_omforeign(node, out, shared)
|
|
624
|
+
encoding = node.foreign_encoding.to_s
|
|
625
|
+
payload = Array(node.notom_value).join
|
|
626
|
+
long = [encoding, payload].map { |part| part.bytesize }.max >= 256
|
|
627
|
+
out << tag_byte(TAG_FOREIGN, shared, long)
|
|
628
|
+
Binary.write_length(out, encoding.bytesize)
|
|
629
|
+
Binary.write_length(out, payload.bytesize)
|
|
630
|
+
out << encoding.b << payload.b
|
|
631
|
+
end
|
|
632
|
+
|
|
633
|
+
# The frame carries the root: version rode the framing bytes, and the
|
|
634
|
+
# root cdbase is not representable in the binary format — its single
|
|
635
|
+
# child is what gets encoded.
|
|
636
|
+
def write_omobj(node, out, _shared)
|
|
637
|
+
child = CHILDREN(node).first
|
|
638
|
+
raise Error, "empty OMOBJ" unless child
|
|
639
|
+
|
|
640
|
+
write_object(child, out)
|
|
641
|
+
end
|
|
642
|
+
|
|
643
|
+
def write_oma(node, out, shared)
|
|
644
|
+
write_compound(node, out, shared, TAG_APPLICATION, TAG_APPLICATION + 1)
|
|
645
|
+
end
|
|
646
|
+
|
|
647
|
+
def write_ome(node, out, shared)
|
|
648
|
+
write_compound(node, out, shared, TAG_ERROR, TAG_ERROR + 1)
|
|
649
|
+
end
|
|
650
|
+
|
|
651
|
+
def write_omattr(node, out, shared)
|
|
652
|
+
out << tag_byte(TAG_ATTRIBUTION, shared, false)
|
|
653
|
+
pairs = node.omatp_value&.first
|
|
654
|
+
raise Error, "attribution without OMATP pairs" unless pairs
|
|
655
|
+
|
|
656
|
+
out << TAG_ATTRPAIRS.chr
|
|
657
|
+
CHILDREN(pairs).each { |child| write_object(child, out) }
|
|
658
|
+
out << (TAG_ATTRPAIRS + 1).chr
|
|
659
|
+
attributed = Evaluation::Evaluator.ordered_children(node).last
|
|
660
|
+
raise Error, "attribution without an attributed object" if attributed.nil? || pairs.equal?(attributed)
|
|
661
|
+
|
|
662
|
+
write_object(attributed, out)
|
|
663
|
+
out << (TAG_ATTRIBUTION + 1).chr
|
|
664
|
+
end
|
|
665
|
+
|
|
666
|
+
def write_ombind(node, out, shared)
|
|
667
|
+
out << tag_byte(TAG_BINDING, shared, false)
|
|
668
|
+
write_object(node.oms_value.first, out)
|
|
669
|
+
out << TAG_BVARS.chr
|
|
670
|
+
vars = node.ombvar_value&.first
|
|
671
|
+
raise Error, "binding without OMBVAR" unless vars
|
|
672
|
+
|
|
673
|
+
CHILDREN(vars).each { |child| write_object(child, out) }
|
|
674
|
+
out << (TAG_BVARS + 1).chr
|
|
675
|
+
body = Evaluation::Evaluator.ordered_children(node).drop(2).first
|
|
676
|
+
raise Error, "binding without a body" unless body
|
|
677
|
+
|
|
678
|
+
write_object(body, out)
|
|
679
|
+
out << (TAG_BINDING + 1).chr
|
|
680
|
+
end
|
|
681
|
+
|
|
682
|
+
def write_compound(node, out, shared, start_tag, end_tag)
|
|
683
|
+
out << tag_byte(start_tag, shared, false)
|
|
684
|
+
CHILDREN(node).each { |child| write_object(child, out) }
|
|
685
|
+
out << end_tag.chr
|
|
686
|
+
end
|
|
687
|
+
|
|
688
|
+
def tag_byte(tag, shared, long)
|
|
689
|
+
tag | (shared ? SHARED_BIT : 0) | (long ? LONG_BIT : 0)
|
|
690
|
+
end
|
|
691
|
+
|
|
692
|
+
# The element-name dispatch spellings.
|
|
693
|
+
def write_omi(node, out, shared) = write_integer(node, out, shared)
|
|
694
|
+
def write_omf(node, out, shared) = write_float(node, out, shared)
|
|
695
|
+
def write_omv(node, out, shared) = write_variable(node, out, shared)
|
|
696
|
+
def write_oms(node, out, shared) = write_symbol(node, out, shared)
|
|
697
|
+
end
|
|
698
|
+
end
|
|
699
|
+
end
|