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.
Files changed (41) hide show
  1. checksums.yaml +4 -4
  2. data/README.adoc +45 -5
  3. data/data/binding-table-1.yml +76 -0
  4. data/data/pmquant.ocd +89 -0
  5. data/data/pmquant.sts +60 -0
  6. data/data/portable-bindings.json +1 -0
  7. data/data/replay-vectors.yml +70 -0
  8. data/lib/openmath/base/omforeign.rb +18 -4
  9. data/lib/openmath/base/omobj.rb +7 -0
  10. data/lib/openmath/binary.rb +699 -0
  11. data/lib/openmath/canonical.rb +127 -0
  12. data/lib/openmath/cd/cds_namespace.rb +13 -0
  13. data/lib/openmath/cd/group_collection.rb +160 -0
  14. data/lib/openmath/cd/group_document.rb +50 -0
  15. data/lib/openmath/cd/namespace.rb +6 -0
  16. data/lib/openmath/cd/signature_document.rb +53 -0
  17. data/lib/openmath/cd/signatures.rb +63 -0
  18. data/lib/openmath/cd.rb +10 -0
  19. data/lib/openmath/common_elements.rb +9 -0
  20. data/lib/openmath/content_mathml.rb +443 -0
  21. data/lib/openmath/content_mathml_operators.rb +51 -0
  22. data/lib/openmath/evaluation/closure.rb +11 -0
  23. data/lib/openmath/evaluation/errors.rb +30 -0
  24. data/lib/openmath/evaluation/evaluator.rb +192 -32
  25. data/lib/openmath/evaluation/interval.rb +17 -0
  26. data/lib/openmath/evaluation/operations.rb +394 -12
  27. data/lib/openmath/evaluation/portable.rb +114 -0
  28. data/lib/openmath/evaluation/signature_checker.rb +173 -0
  29. data/lib/openmath/evaluation/stochastic.rb +113 -0
  30. data/lib/openmath/evaluation/uncertain.rb +64 -0
  31. data/lib/openmath/evaluation.rb +12 -2
  32. data/lib/openmath/foreign.rb +146 -0
  33. data/lib/openmath/tagged.rb +41 -0
  34. data/lib/openmath/v2.rb +1 -1
  35. data/lib/openmath/v3.rb +1 -1
  36. data/lib/openmath/version.rb +1 -1
  37. data/lib/openmath.rb +41 -3
  38. data/schemas/PROVENANCE.md +3 -0
  39. data/schemas/omcdgroup2.rnc +33 -0
  40. data/schemas/omcdgroup2.rng +86 -0
  41. 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