module ssp_types; struct SspImage { 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 SspObject { 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; // named segment (for headings) string part; // frontmatter, body, backmatter int parent_ocn; int last_descendant_ocn; 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; int table_cols; string table_widths; bool table_header; string code_syntax; bool code_linenumbers; string heading_ancestors_text; string sha256; SspImage[] images; // repeatable .image records, in order string text; // content (lines joined with newline) } /+ ↓ 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 SspUnknown { 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 SspDocument { string format_version; // as declared on line 1, "" when absent string[string] source; // @source: language, languages, digest SspUnknown unknown; // what was met and not understood string[string] metadata; // key -> value string[string] make; // key -> value string[string] doc_has; // key -> value SspObject[] head; SspObject[] toc; SspObject[] body; SspObject[] endnotes; SspObject[] glossary; SspObject[] bibliography; SspObject[] bookindex; SspObject[] blurb; SspObject[] 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 ""; } SspObject[]* 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";