1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
module ocda.model;
struct OcdaImage {
string name; // image filename as referenced by the object
string sha256; // hex-encoded (uppercase) digest of the file
ulong bytes; // file size
int width; // file's own pixel width (not display width)
int height; // file's own pixel height
bool missing; // file absent or unreadable, no sha256/bytes
string[string] fields; // any further/unrecognised key:value fields
}
struct OcdaObject {
int ocn;
string is_a; // heading, para, toc, table, code, group, block, verse, quote, endnote, glossary, bibliography, bookindex, blurb
string section; // head, toc, body, endnotes, glossary, bibliography, bookindex, blurb
string heading_level; // A, B, C, D, 1, 2, 3, 4 (for headings)
string identifier; // heading: from the declaration line; otherwise .identifier
string part; // frontmatter, body, backmatter
string is_of_type; // para, block, comment: how the text behaves
string own_section; // .section, when it differs from the block it sits in
string segment_html_is;// the html segment this object sits in
string segment_epub; // the epub segment this heading opens
string segment_epub_is;// the epub segment this object sits in
string table_aligns; // l c r per column
string[] stow_link; // links extracted from the object
string[] anchor_tags; // named targets the markup placed on this object
int parent_ocn;
int last_descendant_ocn;
int ocn_range_first;// a container (a poem): the first and last
int ocn_range_last; // ocn of what it holds; 0 otherwise (2.1)
int[] children; // direct child heading OCNs
int[] ancestors; // markedup_ancestors[8]
bool dummy_heading;
bool ocn_off;
int indent_base;
int indent_hang;
bool bullet;
string lang;
bool has_links;
bool has_notes_reg;
bool has_notes_star;
bool has_images;
string segment;
string segment_prev;
string segment_next;
string anchor;
string heading_lev_anchor; // a heading's own named target
int table_cols;
string table_widths;
bool table_header;
string code_syntax;
bool code_linenumbers;
string heading_ancestors_text;
string sha256;
OcdaImage[] images; // repeatable .image records, in order
string text; // content (lines joined with newline)
/+ ↓ whether this object is rendered at all.
is_of_type "comment" is markup commentary: carried by the
abstraction so that nothing is lost, and not put into output. An
output that renders it leaks the author notes into the document,
which is what spine itself does not do.
+/
bool renders() const {
return is_of_type != "comment";
}
/+ ↓ the section this object belongs to, which is the block it sits in
unless it says otherwise +/
string sectionOf() const {
return (own_section.length > 0) ? own_section : section;
}
}
/+ ↓ what the reader met and did not understand.
A reader that silently drops what it does not know cannot say whether
it understood the document, and cannot be used to check a
specification against an implementation: silence and understanding
look alike. So the parser counts what it ignored, and
--report-unknown prints it.
+/
struct OcdaUnknown {
size_t[string] property; // .name -> times seen
size_t[string] block; // @name -> times seen
size_t[string] line; // first char -> times seen, lines of no known shape
bool any() const {
return property.length > 0 || block.length > 0 || line.length > 0;
}
}
struct OcdaDocument {
string format_version; // as declared on line 1, "" when absent
string source_filename; // from the "% Source:" line
string[string] source; // @source: language, languages, digest
OcdaUnknown unknown; // what was met and not understood
string[string] metadata; // key -> value
string[string] make; // key -> value
string[string] doc_has; // key -> value
OcdaObject[] head;
OcdaObject[] toc;
OcdaObject[] body;
OcdaObject[] endnotes;
OcdaObject[] glossary;
OcdaObject[] bibliography;
OcdaObject[] bookindex;
OcdaObject[] blurb;
OcdaObject[] tail;
/+ ↓ the major part of the declared version, "" when none was declared +/
string formatVersionMajor() const {
import std.string : indexOf;
if (format_version.length == 0) { return ""; }
auto dot = format_version.indexOf('.');
return (dot > 0) ? format_version[0 .. dot] : format_version;
}
string meta(string key) {
if (auto p = key in metadata) return *p;
return "";
}
OcdaObject[]* sectionByName(string name) {
switch (name) {
case "head": return &head;
case "toc": return &toc;
case "body": return &body;
case "endnotes": return &endnotes;
case "glossary": return &glossary;
case "bibliography": return &bibliography;
case "bookindex": return &bookindex;
case "blurb": return &blurb;
case "tail": return &tail;
default: return null;
}
}
}
/+ ↓ the format major version this reader knows.
The .ssp and the .ocda.db carry one version between them, declared in
band: the .ssp on its first line, the database in its schema.version
row. The minor part is raised when a property is added, and a reader of
the newer format still reads the older one, so only the major part is
checked here. Raise this when the reader has been brought to a new
major, not before: the point of the gate is to refuse what has not been
looked at.
+/
enum ssp_format_major_read = "2";
|