Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

doc-links(asciidoc): AsciiDoc sections linked to the code they include and name

Martin Vogel92f5edfe32aa
diff --git a/Makefile.cbm b/Makefile.cbm
index 9e1a7ac94..cd5eb4124 100644
--- a/Makefile.cbm
+++ b/Makefile.cbm
@@ -380,6 +380,7 @@ EXTRACTION_SRCS = \
$(CBM_DIR)/doclink_py.c \
$(CBM_DIR)/doc_adr.c \
$(CBM_DIR)/doc_pdf.c \
+ $(CBM_DIR)/doc_adoc.c \
$(CBM_DIR)/pdf/pdf_obj.c \
$(CBM_DIR)/pdf/pdf_font.c \
$(CBM_DIR)/pdf/pdf_text.c \
@@ -510,6 +511,7 @@ PIPELINE_SRCS = \
src/pipeline/doc_links_md.c \
src/pipeline/doc_links_pdf.c \
src/pipeline/doc_links_rst.c \
+ src/pipeline/doc_links_adoc.c \
src/pipeline/doc_links_msbuild.c \
src/pipeline/pass_route_nodes.c \
src/pipeline/pass_enrichment.c \
@@ -772,7 +774,7 @@ TEST_DISCOVER_SRCS = \
TEST_GRAPH_BUFFER_SRCS = tests/test_graph_buffer.c
-TEST_PIPELINE_SRCS = tests/test_registry.c tests/test_pipeline.c tests/test_pipeline_conventions.c tests/test_pipeline_frozen.c tests/test_importance.c tests/test_cross_repo.c tests/test_fqn.c tests/test_route_canon.c tests/test_path_alias.c tests/test_configlink.c tests/test_doclinks.c tests/test_doc_mentions.c tests/test_doc_links_md.c tests/test_doc_links_pdf.c tests/test_doc_links_rst.c tests/test_infrascan.c tests/test_worker_pool.c tests/test_parallel.c tests/test_index_resilience.c tests/test_index_format.c tests/test_call_reference_contract.c tests/repro/repro_call_scope_usages.c tests/repro/repro_call_argument_usages.c tests/repro/repro_reference_precision.c tests/repro/repro_lexical_binding_precision.c tests/repro/repro_call_argument_matrix_a.c tests/repro/repro_call_argument_matrix_b.c tests/repro/repro_call_node_behaviors.c tests/repro/repro_language_registry.c tests/repro/repro_call_node_manifest.c tests/repro/repro_lsp_ordered_signatures.c tests/repro/repro_lsp_ordered_local.c tests/repro/repro_ts_overload_return_chains.c tests/repro/repro_harness_cleanup.c tests/repro/repro_runner_filter.c
+TEST_PIPELINE_SRCS = tests/test_registry.c tests/test_pipeline.c tests/test_pipeline_conventions.c tests/test_pipeline_frozen.c tests/test_importance.c tests/test_cross_repo.c tests/test_fqn.c tests/test_route_canon.c tests/test_path_alias.c tests/test_configlink.c tests/test_doclinks.c tests/test_doc_mentions.c tests/test_doc_links_md.c tests/test_doc_links_pdf.c tests/test_doc_links_rst.c tests/test_doc_links_adoc.c tests/test_infrascan.c tests/test_worker_pool.c tests/test_parallel.c tests/test_index_resilience.c tests/test_index_format.c tests/test_call_reference_contract.c tests/repro/repro_call_scope_usages.c tests/repro/repro_call_argument_usages.c tests/repro/repro_reference_precision.c tests/repro/repro_lexical_binding_precision.c tests/repro/repro_call_argument_matrix_a.c tests/repro/repro_call_argument_matrix_b.c tests/repro/repro_call_node_behaviors.c tests/repro/repro_language_registry.c tests/repro/repro_call_node_manifest.c tests/repro/repro_lsp_ordered_signatures.c tests/repro/repro_lsp_ordered_local.c tests/repro/repro_ts_overload_return_chains.c tests/repro/repro_harness_cleanup.c tests/repro/repro_runner_filter.c
TEST_WATCHER_SRCS = tests/test_watcher.c
diff --git a/internal/cbm/cbm.c b/internal/cbm/cbm.c
index c740953f6..b9e3237b2 100644
--- a/internal/cbm/cbm.c
+++ b/internal/cbm/cbm.c
@@ -2821,6 +2821,25 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
cbm_index_mark_done(rel_path);
return result;
}
+ /* AsciiDoc has no grammar either: its headings, includes, attribute
+ * references and monospace spans are read from the text (doc_adoc.c). */
+ if (language == CBM_LANG_ASCIIDOC) {
+ result->module_qn = cbm_fqn_module_source_lang(a, project, rel_path, language);
+ CBMExtractCtx adoc_ctx = {
+ .arena = a,
+ .scratch = scratch,
+ .result = result,
+ .source = source,
+ .source_len = source_len,
+ .language = language,
+ .project = project,
+ .rel_path = rel_path,
+ .module_qn = result->module_qn,
+ };
+ cbm_adoc_extract_document(&adoc_ctx);
+ cbm_index_mark_done(rel_path);
+ return result;
+ }
// Get language spec
const CBMLangSpec *spec = cbm_lang_spec(language);
diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.h
index 0cb9c323c..b1868baec 100644
--- a/internal/cbm/cbm.h
+++ b/internal/cbm/cbm.h
@@ -210,6 +210,7 @@ typedef enum {
CBM_LANG_PLSQL, // Oracle PL/SQL
CBM_LANG_CHIALISP, // Chialisp (.clsp/.clib/.clinc — Chia smart-coin s-expression language)
CBM_LANG_PDF, // PDF documents: the text layer, read without a grammar (doc_pdf.c)
+ CBM_LANG_ASCIIDOC, // AsciiDoc documents, read without a grammar (doc_adoc.c)
CBM_LANG_COUNT
} CBMLanguage;
diff --git a/internal/cbm/doc_adoc.c b/internal/cbm/doc_adoc.c
new file mode 100644
index 000000000..bfe70b69a
--- /dev/null
+++ b/internal/cbm/doc_adoc.c
@@ -0,0 +1,944 @@
+/*
+ * doc_adoc.c — AsciiDoc documents in the graph (the extraction half;
+ * src/pipeline/doc_links_adoc.c resolves), and the Antora scope blob.
+ *
+ * AsciiDoc has no grammar here: like a PDF, the file is read directly. Each
+ * heading (`= Title` .. `====== Title`, or `#` .. `######`) outside a
+ * delimited block becomes a Section (name the title, the text up to the next
+ * heading as its docstring, its lines up to the next heading); text before
+ * the first heading belongs to the file. Delimited blocks (`----` listing,
+ * `....` literal, `////` comment, `++++` passthrough, `====` example, `****`
+ * sidebar, `____` quote, `|===` table, ``` fences) open and close on the same
+ * delimiter line (the field test's H8 rules).
+ *
+ * References become tokens whose `raw` is the reference as written, then
+ * TAB-separated fields:
+ * include include::target[attrs] (Asciidoctor's preprocessor directive:
+ * read in every block but a comment block; `\include::` is
+ * escaped): written, target with the page's attributes
+ * substituted (references the page does not define stay as
+ * `{name}` for the component's), tags (`tag=` / `tags=`),
+ * lines (`lines=`)
+ * attribute an attribute reference `{name}` in the text: written, name,
+ * the page's value as written and as the page expands it (both
+ * "" when the page does not define it).
+ * Antora components define their API links as attributes
+ * (`{Assertions}` -> a javadoc page): the resolver reads them.
+ * code_path, a monospace span (`x`, ``x``, `+x+`) naming a path or a
+ * code_name qualified name (the Markdown code-span classifier); raw is
+ * the span's text
+ * Page attributes (`:name: value`, `:name!:` / `:!name:` to unset) apply from
+ * their line on, in document order.
+ *
+ * The Antora scope (cbm_doclink_antora_scan_scope): an antora.yml's component
+ * name, its asciidoc attributes and its collector scans; an
+ * antora-playbook*.yml's asciidoc attributes. Read as text, never run.
+ */
+#include "doclink.h"
+
+#include "arena.h"
+#include "cbm.h"
+#include "helpers.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+ AD_HEAD_MAX = 6, /* `======` */
+ AD_DELIM_MIN = 4, /* `----` and its kin */
+ AD_TABLE_MIN = 3, /* `|===` */
+ AD_FENCE_MIN = 3, /* ``` */
+ AD_BODY_MAX = 500, /* a section's docstring (Markdown's MAX_COMMENT_LEN) */
+ AD_SPAN_MAX = 150, /* a span the classifier reads (MD_SPAN_MAX) */
+ AD_ATTRS_INIT = 16, /* first capacity of the page attribute list */
+ AD_EXPAND_DEPTH = 10, /* nested attribute references expanded (H8) */
+ AD_FIELD_MAX = 512, /* an attribute value or target longer than this is skipped */
+};
+
+typedef struct {
+ const char *s;
+ int len;
+} ad_line_t;
+
+typedef struct {
+ char *name;
+ char *value;
+} ad_attr_t;
+
+typedef struct {
+ int line; /* 0-based */
+ const char *title;
+ const char *qn;
+ bool shared_qn;
+} ad_head_t;
+
+typedef struct {
+ CBMExtractCtx *ctx;
+ CBMArena *scratch;
+ ad_line_t *L;
+ int n;
+ unsigned char *in_block; /* 1: inside a delimited block; 2: inside a comment block */
+ ad_head_t *heads;
+ int nheads;
+ ad_attr_t *attrs;
+ int nattrs;
+ int cap_attrs;
+ char *span_buf;
+ bool failed;
+} ad_doc_t;
+
+static bool ad_blank(char c) {
+ return c == ' ' || c == '\t' || c == '\r';
+}
+
+static bool ad_word(char c) {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+}
+
+/* The line without trailing whitespace: its length. */
+static int ad_rlen(const ad_line_t *l) {
+ int n = l->len;
+ while (n > 0 && ad_blank(l->s[n - 1])) {
+ n--;
+ }
+ return n;
+}
+
+/* ADOC_DELIM_RE: the delimiter's length, or 0. */
+static int ad_delim(const ad_line_t *l) {
+ int n = ad_rlen(l);
+ if (n == 0) {
+ return 0;
+ }
+ const char *s = l->s;
+ if (s[0] == '|') {
+ int k = 1;
+ while (k < n && s[k] == '=') {
+ k++;
+ }
+ return (k == n && n - 1 >= AD_TABLE_MIN) ? n : 0;
+ }
+ if (!strchr("-.=*_+/`", s[0])) {
+ return 0;
+ }
+ for (int k = 1; k < n; k++) {
+ if (s[k] != s[0]) {
+ return 0;
+ }
+ }
+ int min = s[0] == '`' ? AD_FENCE_MIN : AD_DELIM_MIN;
+ return n >= min ? n : 0;
+}
+
+/* ADOC_HEAD_RE ^(={1,6}|#{1,6})\s+(\S.*?)\s*$: the level and the title span. */
+static int ad_heading(const ad_line_t *l, int *ta, int *tb) {
+ const char *s = l->s;
+ int n = ad_rlen(l);
+ if (n == 0 || (s[0] != '=' && s[0] != '#')) {
+ return 0;
+ }
+ int k = 0;
+ while (k < n && s[k] == s[0]) {
+ k++;
+ }
+ if (k > AD_HEAD_MAX || k >= n || !ad_blank(s[k])) {
+ return 0;
+ }
+ int a = k;
+ while (a < n && ad_blank(s[a])) {
+ a++;
+ }
+ if (a >= n) {
+ return 0;
+ }
+ *ta = a;
+ *tb = n;
+ return k;
+}
+
+static bool ad_lines(ad_doc_t *d, const char *src, int len) {
+ int count = 1;
+ for (int i = 0; i < len; i++) {
+ count += src[i] == '\n';
+ }
+ d->L = (ad_line_t *)cbm_arena_alloc(d->scratch, (size_t)count * sizeof(*d->L));
+ d->in_block = (unsigned char *)cbm_arena_alloc(d->scratch, (size_t)count);
+ if (!d->L || !d->in_block) {
+ return false;
+ }
+ memset(d->in_block, 0, (size_t)count);
+ int pos = 0;
+ for (int i = 0; i < count; i++) {
+ const char *nl = memchr(src + pos, '\n', (size_t)(len - pos));
+ int end = nl ? (int)(nl - src) : len;
+ d->L[i] = (ad_line_t){src + pos, end - pos};
+ pos = end + 1;
+ }
+ d->n = count;
+ return true;
+}
+
+/* Delimited blocks, then the headings outside them. */
+static void ad_structure(ad_doc_t *d) {
+ int open = -1;
+ for (int i = 0; i < d->n; i++) {
+ int dl = ad_delim(&d->L[i]);
+ if (open < 0) {
+ if (dl) {
+ open = i;
+ d->in_block[i] = d->L[i].s[0] == '/' ? 2 : 1;
+ }
+ continue;
+ }
+ const ad_line_t *o = &d->L[open];
+ d->in_block[i] = d->L[open].s[0] == '/' ? 2 : 1;
+ if (dl && dl == ad_rlen(o) && memcmp(d->L[i].s, o->s, (size_t)dl) == 0) {
+ open = -1;
+ }
+ }
+ d->heads = (ad_head_t *)cbm_arena_alloc(d->scratch, (size_t)d->n * sizeof(*d->heads));
+ if (!d->heads) {
+ d->failed = true;
+ return;
+ }
+ for (int i = 0; i < d->n; i++) {
+ int ta;
+ int tb;
+ if (d->in_block[i] || ad_heading(&d->L[i], &ta, &tb) == 0) {
+ continue;
+ }
+ char *title = cbm_arena_strndup(d->ctx->arena, d->L[i].s + ta, (size_t)(tb - ta));
+ if (!title) {
+ d->failed = true;
+ return;
+ }
+ d->heads[d->nheads++] = (ad_head_t){.line = i, .title = title};
+ }
+}
+
+/* qn_safe_segment (extract_defs.c): whitespace runs become '-'. */
+static const char *ad_qn_segment(CBMArena *a, const char *name) {
+ char *out = cbm_arena_strdup(a, name);
+ if (!out) {
+ return NULL;
+ }
+ size_t w = 0;
+ bool in_ws = false;
+ for (const char *p = name; *p; p++) {
+ if (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') {
+ in_ws = true;
+ continue;
+ }
+ if (in_ws && w > 0) {
+ out[w++] = '-';
+ }
+ in_ws = false;
+ out[w++] = *p;
+ }
+ out[w] = '\0';
+ return out;
+}
+
+/* The section's own text, whitespace collapsed, at most AD_BODY_MAX bytes and
+ * never a cut UTF-8 character. */
+static const char *ad_body(ad_doc_t *d, int from, int to) {
+ char *out = (char *)cbm_arena_alloc(d->ctx->arena, AD_BODY_MAX + 1);
+ if (!out) {
+ return NULL;
+ }
+ int w = 0;
+ for (int k = from; k < to && w < AD_BODY_MAX; k++) {
+ const char *s = d->L[k].s;
+ int len = d->L[k].len;
+ for (int i = 0; i < len && w < AD_BODY_MAX; i++) {
+ char c = s[i];
+ if (ad_blank(c)) {
+ if (w > 0 && out[w - 1] != ' ') {
+ out[w++] = ' ';
+ }
+ continue;
+ }
+ out[w++] = c;
+ }
+ if (w > 0 && w < AD_BODY_MAX && out[w - 1] != ' ') {
+ out[w++] = ' ';
+ }
+ }
+ while (w > 0 && ((unsigned char)out[w - 1] & 0xC0) == 0x80) {
+ w--; /* never end inside a character */
+ }
+ if (w > 0 && ((unsigned char)out[w - 1] & 0xC0) == 0xC0) {
+ w--;
+ }
+ while (w > 0 && out[w - 1] == ' ') {
+ w--;
+ }
+ out[w] = '\0';
+ return w > 0 ? out : NULL;
+}
+
+static int ad_head_qn_cmp(const void *a, const void *b) {
+ const ad_head_t *x = *(const ad_head_t *const *)a;
+ const ad_head_t *y = *(const ad_head_t *const *)b;
+ return strcmp(x->qn, y->qn);
+}
+
+static void ad_sections(ad_doc_t *d) {
+ CBMExtractCtx *ctx = d->ctx;
+ CBMArena *a = ctx->arena;
+ for (int h = 0; h < d->nheads; h++) {
+ const char *seg = ad_qn_segment(a, d->heads[h].title);
+ d->heads[h].qn = seg ? cbm_fqn_compute(a, ctx->project, ctx->rel_path, seg) : NULL;
+ if (!d->heads[h].qn) {
+ d->failed = true;
+ return;
+ }
+ }
+ if (d->nheads > 1) {
+ ad_head_t **by = (ad_head_t **)cbm_arena_alloc(d->scratch, (size_t)d->nheads * sizeof(*by));
+ if (!by) {
+ d->failed = true;
+ return;
+ }
+ for (int h = 0; h < d->nheads; h++) {
+ by[h] = &d->heads[h];
+ }
+ qsort(by, (size_t)d->nheads, sizeof(*by), ad_head_qn_cmp);
+ for (int h = 1; h < d->nheads; h++) {
+ if (strcmp(by[h]->qn, by[h - 1]->qn) == 0) {
+ by[h]->shared_qn = true;
+ by[h - 1]->shared_qn = true;
+ }
+ }
+ }
+ for (int h = 0; h < d->nheads; h++) {
+ const ad_head_t *hd = &d->heads[h];
+ int end = h + 1 < d->nheads ? d->heads[h + 1].line : d->n;
+ int last = end - 1;
+ while (last > hd->line && ad_rlen(&d->L[last]) == 0) {
+ last--;
+ }
+ CBMDefinition def;
+ memset(&def, 0, sizeof(def));
+ def.name = hd->title;
+ def.qualified_name = hd->qn;
+ def.label = "Section";
+ def.file_path = ctx->rel_path;
+ def.start_line = (uint32_t)hd->line + 1;
+ def.end_line = (uint32_t)last + 1;
+ def.is_exported = true;
+ def.docstring = ad_body(d, hd->line + 1, end);
+ cbm_defs_push(&ctx->result->defs, a, def);
+ }
+}
+
+/* ── Page attributes ─────────────────────────────────────────────── */
+
+static ad_attr_t *ad_attr_find(ad_doc_t *d, const char *name, size_t n) {
+ for (int i = 0; i < d->nattrs; i++) {
+ if (strlen(d->attrs[i].name) == n && memcmp(d->attrs[i].name, name, n) == 0) {
+ return &d->attrs[i];
+ }
+ }
+ return NULL;
+}
+
+/* ATTR_ENTRY_RE ^:(!?)([\w][\w\-]*)(!?):(?:\s+(.*?))?\s*$ -- true when the
+ * line is an attribute entry (set or unset). */
+static bool ad_attr_entry(ad_doc_t *d, const ad_line_t *l) {
+ const char *s = l->s;
+ int n = ad_rlen(l);
+ if (n < 3 || s[0] != ':') {
+ return false;
+ }
+ int k = 1;
+ bool unset = false;
+ if (s[k] == '!') {
+ unset = true;
+ k++;
+ }
+ int na = k;
+ if (k >= n || !ad_word(s[k])) {
+ return false;
+ }
+ while (k < n && (ad_word(s[k]) || s[k] == '-')) {
+ k++;
+ }
+ int nb = k;
+ if (k < n && s[k] == '!') {
+ unset = true;
+ k++;
+ }
+ if (k >= n || s[k] != ':') {
+ return false;
+ }
+ k++;
+ if (k < n && !ad_blank(s[k])) {
+ return false;
+ }
+ while (k < n && ad_blank(s[k])) {
+ k++;
+ }
+ ad_attr_t *a = ad_attr_find(d, s + na, (size_t)(nb - na));
+ if (unset) {
+ if (a) {
+ *a = d->attrs[--d->nattrs];
+ }
+ return true;
+ }
+ char *value = cbm_arena_strndup(d->scratch, s + k, (size_t)(n - k));
+ if (!value) {
+ d->failed = true;
+ return true;
+ }
+ if (a) {
+ a->value = value;
+ return true;
+ }
+ if (d->nattrs >= d->cap_attrs) {
+ int ncap = d->cap_attrs ? d->cap_attrs * 2 : AD_ATTRS_INIT;
+ ad_attr_t *grown = (ad_attr_t *)cbm_arena_alloc(d->scratch, (size_t)ncap * sizeof(*grown));
+ if (!grown) {
+ d->failed = true;
+ return true;
+ }
+ if (d->nattrs) {
+ memcpy(grown, d->attrs, (size_t)d->nattrs * sizeof(*grown));
+ }
+ d->attrs = grown;
+ d->cap_attrs = ncap;
+ }
+ char *name = cbm_arena_strndup(d->scratch, s + na, (size_t)(nb - na));
+ if (!name) {
+ d->failed = true;
+ return true;
+ }
+ d->attrs[d->nattrs++] = (ad_attr_t){name, value};
+ return true;
+}
+
+/* A `{name}` reference at s[i] (not escaped `\{`): the name's span. */
+static bool ad_attr_ref(const char *s, int n, int i, int *a, int *b) {
+ if (s[i] != '{' || (i > 0 && s[i - 1] == '\\') || i + 2 >= n || !ad_word(s[i + 1])) {
+ return false;
+ }
+ int k = i + 1;
+ while (k < n && (ad_word(s[k]) || s[k] == '-')) {
+ k++;
+ }
+ if (k >= n || s[k] != '}') {
+ return false;
+ }
+ *a = i + 1;
+ *b = k;
+ return true;
+}
+
+/* The text with the page's attribute references substituted, pass after pass
+ * (a value may reference others; at most AD_EXPAND_DEPTH passes, as H8's
+ * depth); references the page does not define stay as written. NULL when it
+ * grows past AD_FIELD_MAX or memory ran out. */
+static char *ad_expand(ad_doc_t *d, const char *s, int n) {
+ char cur[AD_FIELD_MAX + 1];
+ char out[AD_FIELD_MAX + 1];
+ if (n > AD_FIELD_MAX) {
+ return NULL;
+ }
+ memcpy(cur, s, (size_t)n);
+ int cl = n;
+ for (int pass = 0; pass < AD_EXPAND_DEPTH; pass++) {
+ int w = 0;
+ bool changed = false;
+ for (int i = 0; i < cl; i++) {
+ int a;
+ int b;
+ const ad_attr_t *at = NULL;
+ if (ad_attr_ref(cur, cl, i, &a, &b)) {
+ at = ad_attr_find(d, cur + a, (size_t)(b - a));
+ }
+ if (at) {
+ int vl = (int)strlen(at->value);
+ if (w + vl > AD_FIELD_MAX) {
+ return NULL;
+ }
+ memcpy(out + w, at->value, (size_t)vl);
+ w += vl;
+ i = b;
+ changed = true;
+ continue;
+ }
+ if (w + 1 > AD_FIELD_MAX) {
+ return NULL;
+ }
+ out[w++] = cur[i];
+ }
+ if (w > 0) {
+ memcpy(cur, out, (size_t)w);
+ }
+ cl = w;
+ if (!changed) {
+ break;
+ }
+ }
+ return cbm_arena_strndup(d->scratch, cur, (size_t)cl);
+}
+
+/* ── Tokens ──────────────────────────────────────────────────────── */
+
+static void ad_push(ad_doc_t *d, int line, int syntax, const char *raw) {
+ if (!raw) {
+ d->failed = true;
+ return;
+ }
+ CBMExtractCtx *ctx = d->ctx;
+ int lo = 0;
+ int hi = d->nheads;
+ while (lo < hi) {
+ int mid = lo + ((hi - lo) / 2);
+ if (d->heads[mid].line <= line) {
+ lo = mid + 1;
+ } else {
+ hi = mid;
+ }
+ }
+ const ad_head_t *sec = lo > 0 ? &d->heads[lo - 1] : NULL;
+ if (sec && sec->shared_qn) {
+ sec = NULL;
+ }
+ CBMDocLink link = {
+ .source_qn = sec ? sec->qn : (ctx->module_qn ? ctx->module_qn : ""),
+ .raw = raw,
+ .line = (uint32_t)line + 1,
+ .def_line = sec ? (uint32_t)sec->line + 1 : 1,
+ .syntax = (uint16_t)syntax,
+ .flags = sec ? 0 : CBM_DOCLINK_FLAG_FILE,
+ };
+ cbm_doclinks_push(&ctx->result->doc_links, ctx->arena, link);
+}
+
+/* A value of the include's attribute list (`tag=x`, `tags="a;b"`, `lines=1..5`). */
+static void ad_attrlist_value(const char *al, int n, const char *key, char *out, size_t cap) {
+ out[0] = '\0';
+ size_t kl = strlen(key);
+ for (int i = 0; i + (int)kl < n; i++) {
+ if ((i > 0 && ad_word(al[i - 1])) || memcmp(al + i, key, kl) != 0) {
+ continue;
+ }
+ int k = i + (int)kl;
+ while (k < n && ad_blank(al[k])) {
+ k++;
+ }
+ if (k >= n || al[k] != '=') {
+ continue;
+ }
+ k++;
+ while (k < n && ad_blank(al[k])) {
+ k++;
+ }
+ int a = k;
+ int b;
+ if (k < n && al[k] == '"') {
+ a = k + 1;
+ const char *q = memchr(al + a, '"', (size_t)(n - a));
+ b = q ? (int)(q - al) : n;
+ } else {
+ b = a;
+ while (b < n && al[b] != ',') {
+ b++;
+ }
+ }
+ while (b > a && ad_blank(al[b - 1])) {
+ b--;
+ }
+ snprintf(out, cap, "%.*s", b - a, al + a);
+ return;
+ }
+}
+
+/* INCLUDE_RE ^(\\?)include::([^\[\s][^\[]*)\[(.*)\]\s*$ */
+static void ad_include(ad_doc_t *d, int i) {
+ const ad_line_t *l = &d->L[i];
+ const char *s = l->s;
+ int n = ad_rlen(l);
+ static const char kw[] = "include::";
+ int kl = (int)strlen(kw);
+ if (n < kl + 2 || memcmp(s, kw, (size_t)kl) != 0 || s[kl] == '[' || ad_blank(s[kl]) ||
+ s[n - 1] != ']') {
+ return;
+ }
+ const char *open = memchr(s + kl, '[', (size_t)(n - kl));
+ if (!open) {
+ return;
+ }
+ int ta = kl;
+ int tb = (int)(open - s);
+ int aa = tb + 1;
+ int ab = n - 1;
+ char *target = ad_expand(d, s + ta, tb - ta);
+ if (!target || strchr(target, '\t')) {
+ return;
+ }
+ char tags[AD_FIELD_MAX];
+ char tag1[AD_FIELD_MAX];
+ char lines[AD_FIELD_MAX];
+ ad_attrlist_value(s + aa, ab - aa, "tags", tags, sizeof(tags));
+ ad_attrlist_value(s + aa, ab - aa, "tag", tag1, sizeof(tag1));
+ ad_attrlist_value(s + aa, ab - aa, "lines", lines, sizeof(lines));
+ char *written = cbm_arena_strndup(d->ctx->arena, s, (size_t)n);
+ ad_push(d, i, CBM_DOCLINK_ADOC_INCLUDE,
+ written ? cbm_arena_sprintf(d->ctx->arena, "%s\t%s\t%s\t%s", written, target,
+ tags[0] ? tags : tag1, lines)
+ : NULL);
+}
+
+/* Built-in attributes: characters and document settings, never a link. */
+static bool ad_builtin(const char *s, size_t n) {
+ static const char *const names[] = {"nbsp", "sp",
+ "empty", "blank",
+ "zwsp", "wj",
+ "apos", "quot",
+ "lsquo", "rsquo",
+ "ldquo", "rdquo",
+ "deg", "plus",
+ "brvbar", "vbar",
+ "amp", "lt",
+ "gt", "startsb",
+ "endsb", "caret",
+ "asterisk", "tilde",
+ "backslash", "backtick",
+ "two-colons", "two-semicolons",
+ "cpp", "cxx",
+ "pp", "docname",
+ "docdir", "docfile",
+ "doctitle", "toc",
+ "version", "revnumber",
+ "revdate", "author",
+ "email", "page-component-version",
+ NULL};
+ for (int i = 0; names[i]; i++) {
+ if (strlen(names[i]) == n && memcmp(names[i], s, n) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static void ad_attr_refs(ad_doc_t *d, int i) {
+ const ad_line_t *l = &d->L[i];
+ const char *s = l->s;
+ int n = l->len;
+ for (int k = 0; k < n; k++) {
+ int a;
+ int b;
+ if (!ad_attr_ref(s, n, k, &a, &b) || ad_builtin(s + a, (size_t)(b - a))) {
+ continue;
+ }
+ const ad_attr_t *at = ad_attr_find(d, s + a, (size_t)(b - a));
+ char *value = at ? ad_expand(d, at->value, (int)strlen(at->value)) : NULL;
+ if (at && (!value || strchr(value, '\t') || strchr(at->value, '\t'))) {
+ k = b;
+ continue;
+ }
+ ad_push(d, i, CBM_DOCLINK_ADOC_ATTRIBUTE,
+ cbm_arena_sprintf(d->ctx->arena, "{%.*s}\t%.*s\t%s\t%s", b - a, s + a, b - a, s + a,
+ at ? at->value : "", value ? value : ""));
+ k = b;
+ }
+}
+
+/* Monospace spans of a prose line: `x` and ``x``, a `+x+` passthrough's inner
+ * text; each a code_path / code_name when the classifier names one. */
+static void ad_spans(ad_doc_t *d, int i) {
+ const ad_line_t *l = &d->L[i];
+ const char *s = l->s;
+ int n = l->len;
+ int k = 0;
+ while (k < n) {
+ if (s[k] != '`') {
+ k++;
+ continue;
+ }
+ int run = 1;
+ while (k + run < n && s[k + run] == '`') {
+ run++;
+ }
+ if (run > 2) {
+ k += run;
+ continue;
+ }
+ int a = k + run;
+ int e = a;
+ while (e + run <= n && !(memcmp(s + e, run == 2 ? "``" : "`", (size_t)run) == 0)) {
+ e++;
+ }
+ if (e + run > n || e == a) {
+ k = a;
+ continue;
+ }
+ int b = e;
+ if (b - a >= 2 && s[a] == '+' && s[b - 1] == '+') {
+ a++;
+ b--;
+ }
+ CBMDocLinkMdPath p;
+ if (b > a && b - a <= AD_SPAN_MAX &&
+ cbm_doclink_md_classify_span(s + a, (size_t)(b - a), d->span_buf, AD_SPAN_MAX + 1,
+ &p)) {
+ ad_push(d, i,
+ p.shape == CBM_DOCLINK_MD_QUALIFIED ? CBM_DOCLINK_ADOC_CODE_NAME
+ : CBM_DOCLINK_ADOC_CODE_PATH,
+ cbm_arena_strndup(d->ctx->arena, s + a, (size_t)(b - a)));
+ }
+ k = e + run;
+ }
+}
+
+static void ad_tokens(ad_doc_t *d) {
+ for (int i = 0; i < d->n && !d->failed; i++) {
+ if (d->in_block[i] == 2) {
+ continue; /* a comment block: nothing in it is read */
+ }
+ const ad_line_t *l = &d->L[i];
+ if (l->len >= 2 && l->s[0] == '/' && l->s[1] == '/' && !d->in_block[i]) {
+ continue; /* a line comment */
+ }
+ if (!d->in_block[i] && ad_attr_entry(d, l)) {
+ continue;
+ }
+ if (l->len > 0 && l->s[0] == 'i') {
+ ad_include(d, i);
+ }
+ ad_attr_refs(d, i);
+ if (!d->in_block[i]) {
+ ad_spans(d, i);
+ }
+ }
+}
+
+void cbm_adoc_extract_document(CBMExtractCtx *ctx) {
+ if (!ctx || !ctx->result || !ctx->source || ctx->source_len <= 0) {
+ return;
+ }
+ ad_doc_t d = {.ctx = ctx, .scratch = ctx->scratch ? ctx->scratch : ctx->arena};
+ d.span_buf = (char *)cbm_arena_alloc(d.scratch, (size_t)(AD_SPAN_MAX + 1) * 2);
+ if (!d.span_buf || !ad_lines(&d, ctx->source, ctx->source_len)) {
+ ctx->result->doc_links.failed = true;
+ return;
+ }
+ ad_structure(&d);
+ if (!d.failed) {
+ ad_sections(&d);
+ }
+ if (!d.failed) {
+ ad_tokens(&d);
+ }
+ if (d.failed) {
+ ctx->result->doc_links.failed = true;
+ }
+}
+
+/* ── The Antora scope (antora.yml, antora-playbook*.yml) ─────────── */
+
+typedef struct {
+ CBMArena *a;
+ char *buf;
+ size_t len;
+ size_t cap;
+ bool failed;
+} ad_sb_t;
+
+static void ad_put(ad_sb_t *sb, const char *s, size_t n) {
+ if (sb->failed) {
+ return;
+ }
+ if (sb->len + n + 1 > sb->cap) {
+ size_t ncap = sb->cap ? sb->cap : AD_FIELD_MAX;
+ while (ncap < sb->len + n + 1) {
+ ncap *= 2;
+ }
+ char *grown = (char *)cbm_arena_alloc(sb->a, ncap);
+ if (!grown) {
+ sb->failed = true;
+ return;
+ }
+ if (sb->len) {
+ memcpy(grown, sb->buf, sb->len);
+ }
+ sb->buf = grown;
+ sb->cap = ncap;
+ }
+ memcpy(sb->buf + sb->len, s, n);
+ sb->len += n;
+ sb->buf[sb->len] = '\0';
+}
+
+static void ad_rec(ad_sb_t *sb, const char *kind, const char *a, size_t an, const char *b,
+ size_t bn) {
+ for (size_t i = 0; i < an; i++) {
+ if (a[i] == '\t' || a[i] == '\n') {
+ return;
+ }
+ }
+ for (size_t i = 0; b && i < bn; i++) {
+ if (b[i] == '\t' || b[i] == '\n') {
+ return;
+ }
+ }
+ ad_put(sb, kind, strlen(kind));
+ ad_put(sb, "\t", 1);
+ ad_put(sb, a, an);
+ if (b) {
+ ad_put(sb, "\t", 1);
+ ad_put(sb, b, bn);
+ }
+ ad_put(sb, "\n", 1);
+}
+
+static int ad_indent(const char *s, int n) {
+ int k = 0;
+ while (k < n && s[k] == ' ') {
+ k++;
+ }
+ return k;
+}
+
+/* `key: value` at s (after the indent): the key and value spans (value
+ * unquoted, comments not stripped: the field test's reading). */
+static bool ad_yaml_kv(const char *s, int n, int *ka, int *kb, int *va, int *vb) {
+ int k = 0;
+ if (k >= n || !(ad_word(s[k]))) {
+ return false;
+ }
+ while (k < n && (ad_word(s[k]) || s[k] == '-')) {
+ k++;
+ }
+ int e = k;
+ while (k < n && ad_blank(s[k])) {
+ k++;
+ }
+ if (k >= n || s[k] != ':') {
+ return false;
+ }
+ k++;
+ while (k < n && ad_blank(s[k])) {
+ k++;
+ }
+ *ka = 0;
+ *kb = e;
+ *va = k;
+ *vb = n; /* the caller's line has no trailing whitespace */
+ return true;
+}
+
+/* A value in matching quotes loses them. */
+static void ad_unquote(const char *s, int *va, int *vb) {
+ if (*vb - *va >= 2 && s[*va] == s[*vb - 1] && (s[*va] == '\'' || s[*va] == '"')) {
+ (*va)++;
+ (*vb)--;
+ }
+}
+
+/* H8 parse_antora_yml: `name:`, `asciidoc: attributes:` and
+ * `ext: collector: scan: - dir: / into:`. */
+static void ad_antora(const char *src, int len, bool component, ad_sb_t *sb) {
+ bool in_asciidoc = false;
+ bool in_attrs = false;
+ int attrs_ind = -1;
+ bool in_scan = false;
+ int pos = 0;
+ while (pos <= len) {
+ const char *nl = memchr(src + pos, '\n', (size_t)(len - pos));
+ int end = nl ? (int)(nl - src) : len;
+ const char *s = src + pos;
+ int n = end - pos;
+ while (n > 0 && ad_blank(s[n - 1])) {
+ n--;
+ }
+ int ind = ad_indent(s, n);
+ int ka;
+ int kb;
+ int va;
+ int vb;
+ bool kv = ad_yaml_kv(s + ind, n - ind, &ka, &kb, &va, &vb);
+ if (kv) {
+ ad_unquote(s + ind, &va, &vb);
+ }
+ if (ind == 0 && n > 0) {
+ in_asciidoc = kv && kb == (int)strlen("asciidoc") && memcmp(s, "asciidoc", 8) == 0;
+ in_attrs = false;
+ in_scan = false;
+ if (component && kv && kb == (int)strlen("name") && memcmp(s, "name", 4) == 0 &&
+ vb > va) {
+ ad_rec(sb, "N", s + va, (size_t)(vb - va), NULL, 0);
+ }
+ } else if (in_asciidoc && kv && va == vb && kb == (int)strlen("attributes") &&
+ memcmp(s + ind, "attributes", 10) == 0) {
+ in_attrs = true;
+ attrs_ind = -1;
+ } else if (in_attrs && n > ind && s[ind] != '#') {
+ if (attrs_ind < 0) {
+ attrs_ind = ind;
+ }
+ if (ind < attrs_ind) {
+ in_attrs = false;
+ } else if (ind == attrs_ind && kv) {
+ ad_rec(sb, "A", s + ind, (size_t)kb, s + ind + va, (size_t)(vb - va));
+ }
+ }
+ if (component && kv && kb == (int)strlen("scan") && memcmp(s + ind, "scan", 4) == 0) {
+ in_scan = true;
+ } else if (component && in_scan) {
+ const char *t = s + ind;
+ int tn = n - ind;
+ if (tn > 1 && t[0] == '-' && ad_blank(t[1])) {
+ int sk = 1;
+ while (sk < tn && ad_blank(t[sk])) {
+ sk++;
+ }
+ t += sk;
+ tn -= sk;
+ }
+ int a;
+ int b;
+ int c;
+ int e;
+ bool tkv = ad_yaml_kv(t, tn, &a, &b, &c, &e);
+ if (tkv) {
+ ad_unquote(t, &c, &e);
+ }
+ if (tkv && e > c) {
+ if (b == 3 && memcmp(t, "dir", 3) == 0) {
+ ad_rec(sb, "D", t + c, (size_t)(e - c), NULL, 0);
+ } else if (b == 4 && memcmp(t, "into", 4) == 0) {
+ ad_rec(sb, "I", t + c, (size_t)(e - c), NULL, 0);
+ }
+ }
+ }
+ pos = end + 1;
+ }
+}
+
+const char *cbm_doclink_antora_scan_scope(CBMExtractCtx *ctx) {
+ if (!ctx || !ctx->rel_path || !ctx->source || ctx->source_len <= 0) {
+ return NULL;
+ }
+ const char *base = strrchr(ctx->rel_path, '/');
+ base = base ? base + 1 : ctx->rel_path;
+ bool component = strcmp(base, "antora.yml") == 0;
+ bool playbook = strncmp(base, "antora-playbook", strlen("antora-playbook")) == 0;
+ if (!component && !playbook) {
+ return NULL;
+ }
+ ad_sb_t sb = {.a = ctx->arena};
+ ad_put(&sb, CBM_DOCLINK_ADOC_SCOPE_TAG "\n", strlen(CBM_DOCLINK_ADOC_SCOPE_TAG "\n"));
+ ad_put(&sb, component ? "C\n" : "P\n", 2);
+ ad_antora(ctx->source, ctx->source_len, component, &sb);
+ if (sb.failed) {
+ ctx->result->doc_links.failed = true;
+ return NULL;
+ }
+ return sb.buf;
+}
diff --git a/internal/cbm/doclink.c b/internal/cbm/doclink.c
index 1a3d06b3c..09ee36c25 100644
--- a/internal/cbm/doclink.c
+++ b/internal/cbm/doclink.c
@@ -175,6 +175,11 @@ static const doclink_lang_t DOCLINK_LANGS[] = {
{.lang = CBM_LANG_PYTHON,
.scan_scope = cbm_doclink_py_scan_scope,
.scope_tag = CBM_DOCLINK_PY_SCOPE_TAG},
+ /* YAML: the Antora component and playbook settings the AsciiDoc resolver
+ * reads */
+ {.lang = CBM_LANG_YAML,
+ .scan_scope = cbm_doclink_antora_scan_scope,
+ .scope_tag = CBM_DOCLINK_ADOC_SCOPE_TAG},
};
static const doclink_lang_t *doclink_lang(CBMLanguage lang) {
diff --git a/internal/cbm/doclink.h b/internal/cbm/doclink.h
index 741b95aaa..e97aaf488 100644
--- a/internal/cbm/doclink.h
+++ b/internal/cbm/doclink.h
@@ -92,6 +92,11 @@
X(CBM_DOCLINK_RST_KERNEL_DOC, CBM_LANG_RST, "kernel_doc", false, true, "MENTIONS") \
X(CBM_DOCLINK_RST_CODE_PATH, CBM_LANG_RST, "code_path", false, true, "MENTIONS") \
X(CBM_DOCLINK_RST_CODE_NAME, CBM_LANG_RST, "code_name", false, true, "MENTIONS") \
+ /* asciidoc (doc_adoc.c): includes, Antora API attributes, monospace spans */ \
+ X(CBM_DOCLINK_ADOC_INCLUDE, CBM_LANG_ASCIIDOC, "include", false, true, "MENTIONS") \
+ X(CBM_DOCLINK_ADOC_ATTRIBUTE, CBM_LANG_ASCIIDOC, "attribute", false, true, "MENTIONS") \
+ X(CBM_DOCLINK_ADOC_CODE_PATH, CBM_LANG_ASCIIDOC, "code_path", false, true, "MENTIONS") \
+ X(CBM_DOCLINK_ADOC_CODE_NAME, CBM_LANG_ASCIIDOC, "code_name", false, true, "MENTIONS") \
/* any language (CBM_LANG_COUNT): a URL is never an edge */ \
X(CBM_DOCLINK_HREF, CBM_LANG_COUNT, "href", true, false, "MENTIONS")
@@ -333,6 +338,22 @@ const char *cbm_doclink_py_scan_scope(CBMExtractCtx *ctx);
/* The Python scope blob starts with this tag line. */
#define CBM_DOCLINK_PY_SCOPE_TAG "py1"
+/* ── AsciiDoc (doc_adoc.c) ─────────────────────────────────────────── */
+
+/* AsciiDoc documents: a Section per heading and the references to code
+ * (include::, Antora API attributes, monospace spans) as doc-link tokens.
+ * Runs instead of a grammar for CBM_LANG_ASCIIDOC. */
+void cbm_adoc_extract_document(CBMExtractCtx *ctx);
+
+/* The scope blob of a YAML file, which the AsciiDoc resolver reads: an
+ * antora.yml's component name, asciidoc attributes and collector scans, an
+ * antora-playbook*.yml's attributes (read as text). NULL for every other
+ * file. */
+const char *cbm_doclink_antora_scan_scope(CBMExtractCtx *ctx);
+
+/* The Antora scope blob starts with this tag line. */
+#define CBM_DOCLINK_ADOC_SCOPE_TAG "ad1"
+
/* PDF documents (doc_pdf.c): a Section per page (name "page N", the page's
* text as docstring, property page) and the pages' structural code mentions
* as doc-link tokens. Runs instead of a grammar for CBM_LANG_PDF. */
diff --git a/internal/cbm/lang_specs.c b/internal/cbm/lang_specs.c
index a37c3e52c..6672011d0 100644
--- a/internal/cbm/lang_specs.c
+++ b/internal/cbm/lang_specs.c
@@ -2718,6 +2718,9 @@ static const CBMLangSpec lang_specs[CBM_LANG_COUNT] = {
// looked up, so this language never reaches cbm_lang_spec()/cbm_ts_language().
// Left as a zero spec.
+ // CBM_LANG_ASCIIDOC — AsciiDoc documents. No grammar row, as PDF: extraction
+ // reads the file itself (cbm_adoc_extract_document, doc_adoc.c). Zero spec.
+
// CBM_LANG_OBJECTSCRIPT_EXPORT — Studio Export XML. No grammar row: the
// pipeline transcodes Export XML to UDL (iris_export_xml.c) and re-extracts
// each class as CBM_LANG_OBJECTSCRIPT_UDL, so this language never reaches
diff --git a/src/discover/language.c b/src/discover/language.c
index c15a1d43d..b1cd7d938 100644
--- a/src/discover/language.c
+++ b/src/discover/language.c
@@ -619,6 +619,9 @@ static const ext_entry_t EXT_TABLE[] = {
{".clib", CBM_LANG_CHIALISP},
{".clinc", CBM_LANG_CHIALISP},
{".pdf", CBM_LANG_PDF},
+ /* AsciiDoc; `.asc` is left out: it is as often an ASCII-armored signature */
+ {".adoc", CBM_LANG_ASCIIDOC},
+ {".asciidoc", CBM_LANG_ASCIIDOC},
/* Slang */
{".slang", CBM_LANG_SLANG},
@@ -831,6 +834,7 @@ static const char *LANG_NAMES[CBM_LANG_COUNT] = {
[CBM_LANG_SCHEME] = "Scheme",
[CBM_LANG_CHIALISP] = "Chialisp",
[CBM_LANG_PDF] = "PDF",
+ [CBM_LANG_ASCIIDOC] = "AsciiDoc",
[CBM_LANG_FENNEL] = "Fennel",
[CBM_LANG_FISH] = "Fish",
[CBM_LANG_AWK] = "AWK",
diff --git a/src/discover/userconfig.c b/src/discover/userconfig.c
index 7b1f3d2b5..a0d306008 100644
--- a/src/discover/userconfig.c
+++ b/src/discover/userconfig.c
@@ -161,6 +161,7 @@ static const lang_name_entry_t LANG_NAME_TABLE[] = {
{"plsql", CBM_LANG_PLSQL},
{"chialisp", CBM_LANG_CHIALISP},
{"pdf", CBM_LANG_PDF},
+ {"asciidoc", CBM_LANG_ASCIIDOC},
{"lean", CBM_LANG_LEAN},
{"form", CBM_LANG_FORM},
{"magma", CBM_LANG_MAGMA},
diff --git a/src/pipeline/doc_links.c b/src/pipeline/doc_links.c
index 71159220d..c5023658d 100644
--- a/src/pipeline/doc_links.c
+++ b/src/pipeline/doc_links.c
@@ -45,10 +45,8 @@ const char *cbm_doclink_reason_name(int reason) {
/* One pointer per language with a resolver: the one line a language leg adds
* to this file. */
static const cbm_doclink_resolver_t *const DOCLINK_RESOLVERS[] = {
- &cbm_doclink_cs_resolver,
- &cbm_doclink_md_resolver,
- &cbm_doclink_pdf_resolver,
- &cbm_doclink_rst_resolver,
+ &cbm_doclink_cs_resolver, &cbm_doclink_md_resolver, &cbm_doclink_pdf_resolver,
+ &cbm_doclink_rst_resolver, &cbm_doclink_adoc_resolver,
};
enum { DOCLINK_RESOLVER_COUNT = sizeof(DOCLINK_RESOLVERS) / sizeof(DOCLINK_RESOLVERS[0]) };
@@ -93,7 +91,7 @@ static const cbm_doclink_resolver_t *resolver_of_scope(const char *scope) {
/* ── Incremental scope rules ─────────────────────────────────────── */
bool cbm_doclinks_binds_lines(CBMLanguage lang) {
- return lang == CBM_LANG_MARKDOWN || lang == CBM_LANG_RST;
+ return lang == CBM_LANG_MARKDOWN || lang == CBM_LANG_RST || lang == CBM_LANG_ASCIIDOC;
}
bool cbm_doclinks_is_scope_input(const char *rel_path) {
diff --git a/src/pipeline/doc_links.h b/src/pipeline/doc_links.h
index ec1416f27..77a5dfb67 100644
--- a/src/pipeline/doc_links.h
+++ b/src/pipeline/doc_links.h
@@ -245,6 +245,9 @@ extern const cbm_doclink_resolver_t cbm_doclink_pdf_resolver;
/* reStructuredText documents and the Python scope they read (doc_links_rst.c):
* via "rst". */
extern const cbm_doclink_resolver_t cbm_doclink_rst_resolver;
+/* AsciiDoc documents and the Antora YAML scope they read (doc_links_adoc.c):
+ * via "asciidoc". */
+extern const cbm_doclink_resolver_t cbm_doclink_adoc_resolver;
/* Over a Markdown resolver index (cbm_doclink_md_resolver.build), for the
* other document resolvers: the innermost code definition of `path` holding
@@ -253,6 +256,15 @@ extern const cbm_doclink_resolver_t cbm_doclink_rst_resolver;
const cbm_gbuf_node_t *cbm_doclink_md_segment(const void *md_index, const char *path,
uint32_t first, uint32_t last, const char *member);
const cbm_gbuf_node_t *cbm_doclink_md_folder(const void *md_index, const char *path);
+/* The definition a region [first, last] of `path` (its text in `text`) binds,
+ * by the field test's rule (H8 bind_range): edge blank and comment lines
+ * trimmed; the innermost enclosing definition, unless it is a type (or there
+ * is none) and the definitions inside cover every other line of the region
+ * (an annotation right above one counts) -- then that one definition (the
+ * type for several). NULL: the file. */
+const cbm_gbuf_node_t *cbm_doclink_md_region(const void *md_index, const char *path,
+ const char *text, size_t text_len, uint32_t first,
+ uint32_t last);
bool cbm_doclink_md_test_path(const char *path);
#if defined(CBM_ENABLE_TEST_SEAMS) && CBM_ENABLE_TEST_SEAMS
@@ -278,7 +290,8 @@ void cbm_doclink_cs_test_unit_memo(bool on);
#endif
/* True for a document language whose references may bind the LINES of a file
- * (Markdown `file#L3-L9`, reST :lines:): a body edit of that file keeps its
+ * (Markdown `file#L3-L9`, reST :lines:, AsciiDoc tags and lines=): a body
+ * edit of that file keeps its
* names but can move what those lines hold, so an incremental run
* re-resolves such documents with the edited file. */
bool cbm_doclinks_binds_lines(CBMLanguage lang);
diff --git a/src/pipeline/doc_links_adoc.c b/src/pipeline/doc_links_adoc.c
new file mode 100644
index 000000000..863462e41
--- /dev/null
+++ b/src/pipeline/doc_links_adoc.c
@@ -0,0 +1,919 @@
+/*
+ * doc_links_adoc.c — AsciiDoc references -> MENTIONS edges, via "asciidoc"
+ * (the resolving half of internal/cbm/doc_adoc.c), with the Antora rules the
+ * field test's harvester measured (H8: includes 97.6-100 % resolved, ~100 %
+ * precise; javadoc attributes 320/320).
+ *
+ * Antora: a component is the directory of an antora.yml; its pages live under
+ * <component>/modules/<module>/pages. Its attributes and collector scans, and
+ * a playbook's attributes, come from the YAML scope blobs (doc_adoc.c), so an
+ * incremental run resolves as a full one.
+ *
+ * include::target[...]: references the page left are expanded from the
+ * component's attributes, then the playbook's. A resource ID
+ * ([[version@]component:]module:]family$path) names
+ * <component>/modules/<module>/<family dir>/<path>, or a file a collector scan
+ * contributes there; any other target is relative to the including file. Its
+ * `lines=` bind the innermost definition holding them; its `tag=` / `tags=`
+ * regions -- the included file's own `tag::x[]` .. `end::x[]` comments, read
+ * from that indexed file -- likewise; a tag the file does not have binds the
+ * file (the document stays a dependent of that file, so it re-resolves when
+ * the file changes, on an incremental run as on a full one).
+ *
+ * {attribute} references whose value is an Antora javadoc link
+ * ({javadoc-root}/<module>/<package path>/<Type>.html[#member]) bind the
+ * Java or Kotlin type (or its member) that the repository's main sources
+ * declare under that package path.
+ *
+ * Monospace spans: the Markdown resolver's code-span rules (doc_links_md.c).
+ */
+#include "pipeline/doc_links.h"
+
+#include "discover/discover.h" /* cbm_language_for_filename */
+#include "doclink.h"
+#include "foundation/arena.h"
+#include "foundation/compat_fs.h"
+#include "foundation/constants.h"
+#include "foundation/mem_core.h"
+#include "graph_buffer/graph_buffer.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+ RA_PATH_CAP = 1024,
+ RA_FIELDS = 6,
+ RA_EXPAND_PASSES = 10, /* nested attribute references (H8's depth) */
+ RA_TAG_FILE_MAX = 8 * 1024 * 1024, /* an included file read for its tags */
+ RA_TAGS = 16, /* tags of one include */
+ RA_TAG_LEN = 128, /* a tag name */
+ RA_INIT = 8,
+};
+
+typedef struct {
+ const char *key;
+ const char *value;
+} ra_attr_t;
+
+typedef struct {
+ const char *dir;
+ const char *into;
+} ra_scan_t;
+
+typedef struct {
+ const char *root; /* the antora.yml's directory ("" for the repository root) */
+ const char *name;
+ ra_attr_t *attrs;
+ int nattrs;
+ ra_scan_t *scans;
+ int nscans;
+} ra_comp_t;
+
+typedef struct {
+ const char *project;
+ const char *repo; /* the repository on disk: included files are read for their tags */
+ void *md;
+ const char **run_paths;
+ int run_count;
+ CBMArena arena;
+ ra_comp_t *comps;
+ int ncomps;
+ ra_attr_t *pattrs; /* playbook attributes, the first definition of a key wins */
+ int npattrs;
+} ra_index_t;
+
+static void ra_destroy(void *index);
+
+static const char *ra_base(const char *path) {
+ const char *s = strrchr(path, '/');
+ return s ? s + SKIP_ONE : path;
+}
+
+static bool ra_ends(const char *s, const char *suffix) {
+ size_t n = strlen(s);
+ size_t k = strlen(suffix);
+ return n >= k && strcmp(s + n - k, suffix) == 0;
+}
+
+static bool ra_grow(CBMArena *a, void **items, int count, int *cap, size_t size) {
+ if (count < *cap) {
+ return true;
+ }
+ int ncap = *cap ? *cap * PAIR_LEN : RA_INIT;
+ void *grown = cbm_arena_alloc(a, (size_t)ncap * size);
+ if (!grown) {
+ return false;
+ }
+ if (count > 0) {
+ memcpy(grown, *items, (size_t)count * size);
+ }
+ *items = grown;
+ *cap = ncap;
+ return true;
+}
+
+/* One YAML scope blob: a component (C) or a playbook (P). */
+static bool ra_read_scope(ra_index_t *x, const char *path, const char *scope, int *comp_cap,
+ int *pattr_cap) {
+ char *copy = cbm_arena_strdup(&x->arena, scope);
+ if (!copy) {
+ return false;
+ }
+ char *save = NULL;
+ (void)strtok_r(copy, "\n", &save); /* the tag line */
+ char *line = strtok_r(NULL, "\n", &save);
+ if (!line || (strcmp(line, "C") != 0 && strcmp(line, "P") != 0)) {
+ return true;
+ }
+ bool component = line[0] == 'C';
+ ra_comp_t comp = {0};
+ int acap = 0;
+ int scap = 0;
+ if (component) {
+ const char *b = ra_base(path);
+ comp.root =
+ cbm_arena_strndup(&x->arena, path, b > path ? (size_t)(b - path - SKIP_ONE) : 0);
+ comp.name = "";
+ if (!comp.root) {
+ return false;
+ }
+ }
+ for (line = strtok_r(NULL, "\n", &save); line; line = strtok_r(NULL, "\n", &save)) {
+ char *tab = strchr(line, '\t');
+ if (!tab) {
+ continue;
+ }
+ *tab = '\0';
+ char *v = tab + SKIP_ONE;
+ if (strcmp(line, "N") == 0 && component) {
+ comp.name = v;
+ } else if (strcmp(line, "A") == 0) {
+ char *t2 = strchr(v, '\t');
+ if (!t2) {
+ continue;
+ }
+ *t2 = '\0';
+ ra_attr_t at = {v, t2 + SKIP_ONE};
+ if (component) {
+ if (!ra_grow(&x->arena, (void **)&comp.attrs, comp.nattrs, &acap, sizeof(at))) {
+ return false;
+ }
+ comp.attrs[comp.nattrs++] = at;
+ } else {
+ bool seen = false;
+ for (int i = 0; i < x->npattrs; i++) {
+ seen = seen || strcmp(x->pattrs[i].key, at.key) == 0;
+ }
+ if (!seen) {
+ if (!ra_grow(&x->arena, (void **)&x->pattrs, x->npattrs, pattr_cap,
+ sizeof(at))) {
+ return false;
+ }
+ x->pattrs[x->npattrs++] = at;
+ }
+ }
+ } else if (strcmp(line, "D") == 0 && component) {
+ if (!ra_grow(&x->arena, (void **)&comp.scans, comp.nscans, &scap, sizeof(ra_scan_t))) {
+ return false;
+ }
+ comp.scans[comp.nscans++] = (ra_scan_t){v, ""};
+ } else if (strcmp(line, "I") == 0 && component && comp.nscans > 0) {
+ comp.scans[comp.nscans - 1].into = v;
+ }
+ }
+ if (component) {
+ if (!ra_grow(&x->arena, (void **)&x->comps, x->ncomps, comp_cap, sizeof(comp))) {
+ return false;
+ }
+ x->comps[x->ncomps++] = comp;
+ }
+ return true;
+}
+
+static void *ra_build(const cbm_doclink_build_in_t *in) {
+ ra_index_t *x = (ra_index_t *)cbm_calloc(CBM_MEM_CLASS_OTHER, sizeof(*x));
+ if (!x) {
+ return NULL;
+ }
+ cbm_arena_init(&x->arena);
+ x->project = in->ctx ? in->ctx->project_name : NULL;
+ x->repo = in->ctx ? in->ctx->repo_path : NULL;
+ x->run_count = in->run_file_count;
+ x->run_paths = in->run_file_count > 0
+ ? (const char **)cbm_calloc(CBM_MEM_CLASS_OTHER,
+ (size_t)in->run_file_count * sizeof(char *))
+ : NULL;
+ x->md = cbm_doclink_md_resolver.build(in);
+ if ((in->run_file_count > 0 && !x->run_paths) || !x->md || !x->project) {
+ ra_destroy(x);
+ return NULL;
+ }
+ int comp_cap = 0;
+ int pattr_cap = 0;
+ for (int i = 0; i < in->file_count; i++) {
+ const cbm_doclink_file_t *f = &in->files[i];
+ if (f->run_file >= 0 && f->run_file < x->run_count) {
+ x->run_paths[f->run_file] = f->rel_path; /* valid until destroy */
+ }
+ if (f->scope &&
+ strncmp(f->scope, CBM_DOCLINK_ADOC_SCOPE_TAG "\n",
+ strlen(CBM_DOCLINK_ADOC_SCOPE_TAG "\n")) == 0 &&
+ !ra_read_scope(x, f->rel_path, f->scope, &comp_cap, &pattr_cap)) {
+ ra_destroy(x);
+ return NULL;
+ }
+ }
+ return x;
+}
+
+static void ra_destroy(void *index) {
+ ra_index_t *x = (ra_index_t *)index;
+ if (!x) {
+ return;
+ }
+ if (x->md) {
+ cbm_doclink_md_resolver.destroy(x->md);
+ }
+ cbm_arena_destroy(&x->arena);
+ cbm_free(CBM_MEM_CLASS_OTHER, x->run_paths);
+ cbm_free(CBM_MEM_CLASS_OTHER, x);
+}
+
+/* H8 component_of: the deepest component whose modules/ hold the document. */
+static const ra_comp_t *ra_component_of(const ra_index_t *x, const char *doc) {
+ const ra_comp_t *best = NULL;
+ for (int i = 0; i < x->ncomps; i++) {
+ const ra_comp_t *c = &x->comps[i];
+ char pref[RA_PATH_CAP];
+ snprintf(pref, sizeof(pref), "%s%smodules/", c->root, c->root[0] ? "/" : "");
+ if (strncmp(doc, pref, strlen(pref)) == 0 &&
+ (!best || strlen(c->root) > strlen(best->root))) {
+ best = c;
+ }
+ }
+ return best;
+}
+
+static const char *ra_attr(const ra_index_t *x, const ra_comp_t *c, const char *key, size_t n) {
+ for (int i = 0; c && i < c->nattrs; i++) {
+ if (strlen(c->attrs[i].key) == n && memcmp(c->attrs[i].key, key, n) == 0) {
+ return c->attrs[i].value;
+ }
+ }
+ for (int i = 0; i < x->npattrs; i++) {
+ if (strlen(x->pattrs[i].key) == n && memcmp(x->pattrs[i].key, key, n) == 0) {
+ return x->pattrs[i].value;
+ }
+ }
+ return NULL;
+}
+
+static bool ra_word(char c) {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+}
+
+/* The text with the component's and the playbook's attribute references
+ * substituted, pass after pass. False when one stays undefined or it does
+ * not fit. */
+static bool ra_expand(const ra_index_t *x, const ra_comp_t *c, const char *s, char *out,
+ size_t cap) {
+ char cur[RA_PATH_CAP];
+ char nxt[RA_PATH_CAP];
+ if (snprintf(cur, sizeof(cur), "%s", s) >= (int)sizeof(cur)) {
+ return false;
+ }
+ bool undefined = false;
+ for (int pass = 0; pass < RA_EXPAND_PASSES; pass++) {
+ size_t w = 0;
+ bool changed = false;
+ undefined = false;
+ for (size_t i = 0; cur[i]; i++) {
+ const char *v = NULL;
+ size_t e = i + SKIP_ONE;
+ if (cur[i] == '{' && (i == 0 || cur[i - SKIP_ONE] != '\\') && ra_word(cur[e])) {
+ while (cur[e] && (ra_word(cur[e]) || cur[e] == '-')) {
+ e++;
+ }
+ if (cur[e] == '}') {
+ v = ra_attr(x, c, cur + i + SKIP_ONE, e - i - SKIP_ONE);
+ undefined = undefined || !v;
+ }
+ }
+ if (v) {
+ size_t vl = strlen(v);
+ if (w + vl >= sizeof(nxt)) {
+ return false;
+ }
+ memcpy(nxt + w, v, vl);
+ w += vl;
+ i = e;
+ changed = true;
+ continue;
+ }
+ if (w + SKIP_ONE >= sizeof(nxt)) {
+ return false;
+ }
+ nxt[w++] = cur[i];
+ }
+ nxt[w] = '\0';
+ memcpy(cur, nxt, w + SKIP_ONE);
+ if (!changed) {
+ break;
+ }
+ }
+ if (undefined || snprintf(out, cap, "%s", cur) >= (int)cap) {
+ return false;
+ }
+ return true;
+}
+
+/* os.path.normpath(base/p); false when it leaves the repository. */
+static bool ra_norm(const char *base, const char *p, char *out, size_t cap) {
+ char tmp[RA_PATH_CAP * PAIR_LEN];
+ snprintf(tmp, sizeof(tmp), "%s%s%s", base, base[0] && p[0] ? "/" : "", p);
+ size_t w = 0;
+ out[0] = '\0';
+ for (char *s = tmp; *s;) {
+ char *e = strchr(s, '/');
+ size_t l = e ? (size_t)(e - s) : strlen(s);
+ if (l == PAIR_LEN && s[0] == '.' && s[1] == '.') {
+ if (w == 0) {
+ return false;
+ }
+ while (w > 0 && out[w - SKIP_ONE] != '/') {
+ w--;
+ }
+ if (w > 0) {
+ w--;
+ }
+ out[w] = '\0';
+ } else if (l > 0 && !(l == SKIP_ONE && s[0] == '.')) {
+ if (w + l + PAIR_LEN > cap) {
+ return false;
+ }
+ if (w > 0) {
+ out[w++] = '/';
+ }
+ memcpy(out + w, s, l);
+ w += l;
+ out[w] = '\0';
+ }
+ if (!e) {
+ break;
+ }
+ s = e + SKIP_ONE;
+ }
+ return true;
+}
+
+static void ra_unresolved(cbm_doclink_outcome_t *out, int reason) {
+ out->kind = CBM_DOCLINK_UNRESOLVED;
+ out->reason = reason;
+}
+
+static void ra_edge(cbm_doclink_outcome_t *out, const cbm_gbuf_node_t *n, uint32_t a, uint32_t b) {
+ out->kind = CBM_DOCLINK_EDGE;
+ out->target = n;
+ out->exact = true;
+ out->target_first = a;
+ out->target_last = b;
+}
+
+/* A path of a type the indexer does not read (a service file, an image): no
+ * reference to code, decided by its name as the Markdown resolver does -- never
+ * by the disk, which an incremental run does not watch for such files. */
+static bool ra_unindexable(const char *path) {
+ return cbm_language_for_filename(ra_base(path)) == CBM_LANG_COUNT;
+}
+
+/* A collector scan of build output (`./build/...`): what it contributes is
+ * generated, not a file of the repository (H8). */
+static bool ra_build_dir(const char *dir) {
+ while (dir[0] == '.' && dir[1] == '/') {
+ dir += PAIR_LEN;
+ }
+ return strcmp(dir, "build") == 0 || strncmp(dir, "build/", strlen("build/")) == 0 ||
+ strstr(dir, "/build/") != NULL;
+}
+
+static const char *const RA_FAMILIES[][2] = {{"example", "examples"},
+ {"partial", "partials"},
+ {"page", "pages"},
+ {"image", "images"},
+ {"attachment", "attachments"}};
+
+/* H8 resolve_target: an Antora resource ID or a path relative to the including
+ * file. Returns the repository path in `out`, or false with `out->kind` set. */
+static bool ra_target(const ra_index_t *x, const cbm_gbuf_t *graph, const char *doc,
+ const ra_comp_t *comp, const char *target, char *path, size_t cap,
+ cbm_doclink_outcome_t *out) {
+ out->kind = CBM_DOCLINK_LOCAL;
+ if (strstr(target, "://")) {
+ return false; /* a URL include */
+ }
+ const char *dollar = strchr(target, '$');
+ if (dollar && comp) {
+ char pre[RA_PATH_CAP];
+ snprintf(pre, sizeof(pre), "%.*s", (int)(dollar - target), target);
+ const char *at = strrchr(pre, '@');
+ char *segs = at ? pre + (at - pre) + SKIP_ONE : pre;
+ /* family is the last segment; module and component before it */
+ char *fam = strrchr(segs, ':');
+ const char *module = NULL;
+ if (fam) {
+ *fam = '\0';
+ fam++;
+ char *comp_sep = strchr(segs, ':');
+ if (comp_sep) {
+ *comp_sep = '\0';
+ if (strcmp(segs, comp->name) != 0) {
+ return false; /* another component's resource */
+ }
+ module = comp_sep + SKIP_ONE;
+ } else {
+ module = segs;
+ }
+ } else {
+ fam = segs;
+ }
+ char doc_module[RA_PATH_CAP] = "ROOT";
+ if (!module) {
+ /* the including page's own module: modules/<module>/... */
+ const char *rel = doc + strlen(comp->root) + (comp->root[0] ? SKIP_ONE : 0);
+ if (strncmp(rel, "modules/", strlen("modules/")) == 0) {
+ const char *m = rel + strlen("modules/");
+ const char *slash = strchr(m, '/');
+ if (slash) {
+ snprintf(doc_module, sizeof(doc_module), "%.*s", (int)(slash - m), m);
+ }
+ }
+ module = doc_module;
+ }
+ const char *famdir = NULL;
+ for (size_t i = 0; i < sizeof(RA_FAMILIES) / sizeof(RA_FAMILIES[0]); i++) {
+ if (strcmp(fam, RA_FAMILIES[i][0]) == 0) {
+ famdir = RA_FAMILIES[i][1];
+ }
+ }
+ if (!famdir) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+ return false;
+ }
+ char virt[RA_PATH_CAP];
+ snprintf(virt, sizeof(virt), "modules/%s/%s/%s", module, famdir, dollar + SKIP_ONE);
+ if (ra_norm(comp->root, virt, path, cap) &&
+ cbm_pipeline_file_node(graph, x->project, path)) {
+ return true;
+ }
+ /* a file a collector scan contributes into the component */
+ for (int i = 0; i < comp->nscans; i++) {
+ const char *into = comp->scans[i].into;
+ while (into[0] == '.' && into[1] == '/') {
+ into += PAIR_LEN;
+ }
+ size_t il = strlen(into);
+ while (il > 0 && into[il - SKIP_ONE] == '/') {
+ il--;
+ }
+ if (il == 0 || strncmp(virt, into, il) != 0 || virt[il] != '/') {
+ continue;
+ }
+ char sub[RA_PATH_CAP];
+ snprintf(sub, sizeof(sub), "%s/%s", comp->scans[i].dir, virt + il + SKIP_ONE);
+ if (ra_norm(comp->root, sub, path, cap) &&
+ cbm_pipeline_file_node(graph, x->project, path)) {
+ return true;
+ }
+ if (ra_build_dir(comp->scans[i].dir)) {
+ return false; /* build output (H8 generated): no file of the repository */
+ }
+ }
+ if (ra_unindexable(virt)) {
+ return false;
+ }
+ ra_unresolved(out, CBM_DOCLINK_REASON_MISSING);
+ return false;
+ }
+ char dir[RA_PATH_CAP];
+ const char *b = ra_base(doc);
+ snprintf(dir, sizeof(dir), "%.*s", b > doc ? (int)(b - doc - SKIP_ONE) : 0, doc);
+ if (!ra_norm(dir, target, path, cap)) {
+ return false; /* above the repository root */
+ }
+ if (cbm_pipeline_file_node(graph, x->project, path)) {
+ return true;
+ }
+ char parent[RA_PATH_CAP];
+ const char *pb = ra_base(path);
+ snprintf(parent, sizeof(parent), "%.*s", pb > path ? (int)(pb - path - SKIP_ONE) : 0, path);
+ if (!ra_unindexable(path) && parent[0] && cbm_doclink_md_folder(x->md, parent)) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_MISSING);
+ }
+ return false;
+}
+
+/* Asciidoctor's TagDirectiveRx \b(?:tag|(e)nd)::(\S+?)\[\](?=$|[ \r]) over the
+ * file: the 1-based lines from the first region's first content line to the
+ * last region's last one (directive lines excluded). False when a tag has no
+ * region. */
+static bool ra_tag_span(const char *src, size_t n, const char *const *tags, int ntags,
+ uint32_t *first, uint32_t *last) {
+ *first = 0;
+ *last = 0;
+ for (int t = 0; t < ntags; t++) {
+ size_t tl = strlen(tags[t]);
+ uint32_t line = 1;
+ uint32_t start = 0;
+ bool found = false;
+ size_t pos = 0;
+ while (pos < n) {
+ const char *nl = memchr(src + pos, '\n', n - pos);
+ size_t end = nl ? (size_t)(nl - src) : n;
+ for (size_t i = pos; i + PAIR_LEN < end; i++) {
+ bool is_end = false;
+ size_t k;
+ if (i + strlen("tag::") <= end && memcmp(src + i, "tag::", strlen("tag::")) == 0) {
+ k = i + strlen("tag::");
+ } else if (i + strlen("end::") <= end &&
+ memcmp(src + i, "end::", strlen("end::")) == 0) {
+ k = i + strlen("end::");
+ is_end = true;
+ } else {
+ continue;
+ }
+ if (i > pos && ra_word(src[i - SKIP_ONE])) {
+ continue; /* \b */
+ }
+ if (k + tl + PAIR_LEN > end || memcmp(src + k, tags[t], tl) != 0 ||
+ src[k + tl] != '[' || src[k + tl + SKIP_ONE] != ']') {
+ continue;
+ }
+ size_t after = k + tl + PAIR_LEN;
+ if (after != end && src[after] != ' ' && src[after] != '\r') {
+ continue;
+ }
+ if (!is_end && start == 0) {
+ start = line + SKIP_ONE;
+ } else if (is_end && start != 0) {
+ if (start <= line - SKIP_ONE) {
+ *first = (*first == 0 || start < *first) ? start : *first;
+ *last = line - SKIP_ONE > *last ? line - SKIP_ONE : *last;
+ found = true;
+ }
+ start = 0;
+ }
+ break;
+ }
+ line++;
+ pos = end + SKIP_ONE;
+ }
+ if (start != 0 && start <= line - SKIP_ONE) {
+ *first = (*first == 0 || start < *first) ? start : *first;
+ *last = line - SKIP_ONE > *last ? line - SKIP_ONE : *last;
+ found = true;
+ }
+ if (!found) {
+ return false;
+ }
+ }
+ return *first > 0;
+}
+
+/* The included file's text, read from the indexed file on disk (at most
+ * RA_TAG_FILE_MAX bytes): its tag regions and the lines of a region. NULL
+ * when it cannot be read; the caller frees it (cbm_free, OTHER). */
+static char *ra_read(const ra_index_t *x, const char *path, size_t *n) {
+ *n = 0;
+ if (!x->repo) {
+ return NULL;
+ }
+ char abs[RA_PATH_CAP * PAIR_LEN];
+ snprintf(abs, sizeof(abs), "%s/%s", x->repo, path);
+ FILE *f = cbm_fopen(abs, "rb");
+ if (!f) {
+ return NULL;
+ }
+ char *buf = (char *)cbm_alloc(CBM_MEM_CLASS_OTHER, RA_TAG_FILE_MAX);
+ *n = buf ? fread(buf, SKIP_ONE, RA_TAG_FILE_MAX, f) : 0;
+ (void)fclose(f);
+ return buf;
+}
+
+/* `lines=a..b;c;d..-1`: the span of all ranges (-1: the file's end). */
+static bool ra_lines(const char *v, uint32_t *first, uint32_t *last) {
+ *first = 0;
+ *last = 0;
+ const char *p = v;
+ while (*p) {
+ while (*p == ';' || *p == ',' || *p == ' ' || *p == '"') {
+ p++;
+ }
+ if (!*p) {
+ break;
+ }
+ if (*p < '0' || *p > '9') {
+ return false;
+ }
+ uint32_t a = (uint32_t)strtoul(p, (char **)&p, 10);
+ uint32_t b = a;
+ if (p[0] == '.' && p[1] == '.') {
+ p += PAIR_LEN;
+ if (p[0] == '-' && p[1] == '1') {
+ b = UINT32_MAX;
+ p += PAIR_LEN;
+ } else if (*p >= '0' && *p <= '9') {
+ b = (uint32_t)strtoul(p, (char **)&p, 10);
+ } else {
+ return false;
+ }
+ }
+ if (a == 0 || b < a) {
+ return false;
+ }
+ *first = (*first == 0 || a < *first) ? a : *first;
+ *last = b > *last ? b : *last;
+ }
+ return *first > 0;
+}
+
+typedef struct {
+ char buf[RA_PATH_CAP * PAIR_LEN];
+ char *f[RA_FIELDS];
+ int n;
+} ra_rec_t;
+
+static bool ra_record(const char *raw, ra_rec_t *r) {
+ if (snprintf(r->buf, sizeof(r->buf), "%s", raw) >= (int)sizeof(r->buf)) {
+ return false;
+ }
+ r->n = 0;
+ char *p = r->buf;
+ while (r->n < RA_FIELDS) {
+ r->f[r->n++] = p;
+ char *tab = strchr(p, '\t');
+ if (!tab) {
+ break;
+ }
+ *tab = '\0';
+ p = tab + SKIP_ONE;
+ }
+ for (int i = r->n; i < RA_FIELDS; i++) {
+ r->f[i] = "";
+ }
+ return true;
+}
+
+static void ra_include(const ra_index_t *x, const cbm_gbuf_t *graph, const char *doc,
+ const ra_rec_t *r, cbm_doclink_outcome_t *out) {
+ const ra_comp_t *comp = ra_component_of(x, doc);
+ char target[RA_PATH_CAP];
+ if (strchr(r->f[1], '{')) {
+ if (!comp || !ra_expand(x, comp, r->f[1], target, sizeof(target))) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE); /* an undefined attribute */
+ return;
+ }
+ } else {
+ snprintf(target, sizeof(target), "%s", r->f[1]);
+ }
+ char path[RA_PATH_CAP];
+ if (!ra_target(x, graph, doc, comp, target, path, sizeof(path), out)) {
+ return;
+ }
+ const cbm_gbuf_node_t *file = cbm_pipeline_file_node(graph, x->project, path);
+ if (!file) {
+ out->kind = CBM_DOCLINK_LOCAL;
+ return;
+ }
+ uint32_t first = 0;
+ uint32_t last = 0;
+ const char *tagv = r->f[2];
+ if (!tagv[0] && r->f[3][0] && !ra_lines(r->f[3], &first, &last)) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+ return;
+ }
+ size_t tn = 0;
+ char *text = (tagv[0] || first > 0) ? ra_read(x, path, &tn) : NULL;
+ if (tagv[0]) {
+ /* H8: negated and wildcard tags leave the positive ones; none left
+ * includes the whole file */
+ char tags[RA_TAGS][RA_TAG_LEN];
+ const char *tagp[RA_TAGS];
+ int nt = 0;
+ for (const char *p = tagv; *p && nt < RA_TAGS;) {
+ size_t l = strcspn(p, ";,");
+ if (l > 0 && l < RA_TAG_LEN && p[0] != '!' && !memchr(p, '*', l)) {
+ snprintf(tags[nt], RA_TAG_LEN, "%.*s", (int)l, p);
+ tagp[nt] = tags[nt];
+ nt++;
+ }
+ p += l + (p[l] ? SKIP_ONE : 0);
+ }
+ if (nt == 0 || !text || !ra_tag_span(text, tn, tagp, nt, &first, &last)) {
+ first = 0; /* wildcards only, or a tag the file lacks: the file */
+ last = 0;
+ }
+ }
+ if (first > 0) {
+ const cbm_gbuf_node_t *seg = text
+ ? cbm_doclink_md_region(x->md, path, text, tn, first, last)
+ : cbm_doclink_md_segment(x->md, path, first, last, NULL);
+ cbm_free(CBM_MEM_CLASS_OTHER, text);
+ ra_edge(out, seg ? seg : file, first, last == UINT32_MAX ? 0 : last);
+ return;
+ }
+ cbm_free(CBM_MEM_CLASS_OTHER, text);
+ ra_edge(out, file, 0, 0);
+}
+
+static bool ra_class_label(const char *label) {
+ static const char *const labels[] = {"Class", "Interface", "Enum", "Type", "Trait", NULL};
+ for (int i = 0; label && labels[i]; i++) {
+ if (strcmp(label, labels[i]) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool ra_member_label(const char *label) {
+ static const char *const labels[] = {"Method", "Field", "Variable", "Function", NULL};
+ for (int i = 0; label && labels[i]; i++) {
+ if (strcmp(label, labels[i]) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* H8 javadoc: xref:attachment$api/<module>/<pkg path>/<Type>.html[#member]. */
+static void ra_javadoc(const ra_index_t *x, const cbm_gbuf_t *graph, const char *val,
+ cbm_doclink_outcome_t *out) {
+ static const char key[] = "xref:attachment$api/";
+ const char *p = strstr(val, key);
+ if (!p) {
+ return;
+ }
+ p += strlen(key);
+ const char *slash = strchr(p, '/'); /* after the JPMS module */
+ if (!slash) {
+ return;
+ }
+ const char *path = slash + SKIP_ONE;
+ const char *html = strstr(path, ".html");
+ if (!html || memchr(path, '[', (size_t)(html - path))) {
+ return;
+ }
+ char rel[RA_PATH_CAP];
+ snprintf(rel, sizeof(rel), "%.*s", (int)(html - path), path);
+ const char *tname = ra_base(rel);
+ if (strcmp(tname, "package-summary") == 0 || strcmp(tname, "module-summary") == 0 ||
+ strcmp(rel, "index") == 0) {
+ return; /* a package or module page: no code node */
+ }
+ char anchor[RA_PATH_CAP] = "";
+ if (html[strlen(".html")] == '#') {
+ const char *a = html + strlen(".html") + SKIP_ONE;
+ size_t al = strcspn(a, "[(-");
+ snprintf(anchor, sizeof(anchor), "%.*s", (int)al, a);
+ }
+ char pkgdir[RA_PATH_CAP];
+ snprintf(pkgdir, sizeof(pkgdir), "%.*s", (int)(tname - rel), rel); /* "org/x/" */
+ char outer[RA_PATH_CAP];
+ snprintf(outer, sizeof(outer), "%.*s", (int)strcspn(tname, "."), tname);
+ const char *want = strrchr(tname, '.') ? strrchr(tname, '.') + SKIP_ONE : tname;
+ /* the source files declaring <pkg dir>/<Outer>.java|.kt, main sources first */
+ const cbm_gbuf_node_t **nodes = NULL;
+ int count = 0;
+ if (cbm_gbuf_find_by_name(graph, outer, &nodes, &count) != 0) {
+ return;
+ }
+ const char *files[2] = {NULL, NULL};
+ int nfiles = 0;
+ for (int pass = 0; pass < PAIR_LEN && nfiles == 0; pass++) {
+ bool main_only = pass == 0;
+ for (int i = 0; i < count; i++) {
+ const cbm_gbuf_node_t *n = nodes[i];
+ const char *fp = n->file_path;
+ if (!ra_class_label(n->label) || !fp) {
+ continue;
+ }
+ char tail[RA_PATH_CAP * PAIR_LEN];
+ bool java = ra_ends(fp, ".java");
+ snprintf(tail, sizeof(tail), "%s%s%s", pkgdir, outer, java ? ".java" : ".kt");
+ size_t fl = strlen(fp);
+ size_t tl = strlen(tail);
+ if (!(java || ra_ends(fp, ".kt")) || fl < tl || strcmp(fp + fl - tl, tail) != 0 ||
+ (fl > tl && fp[fl - tl - SKIP_ONE] != '/') ||
+ (main_only && !strstr(fp, "/src/main/"))) {
+ continue;
+ }
+ bool seen = false;
+ for (int k = 0; k < nfiles; k++) {
+ seen = seen || strcmp(files[k], fp) == 0;
+ }
+ if (!seen && nfiles < PAIR_LEN) {
+ files[nfiles++] = fp;
+ } else if (!seen) {
+ nfiles++;
+ }
+ }
+ }
+ if (nfiles == 0) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_MISSING);
+ return;
+ }
+ if (nfiles > SKIP_ONE) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_AMBIGUOUS);
+ return;
+ }
+ /* the type in that file (the first by line for a repeated name) */
+ const cbm_gbuf_node_t *type = NULL;
+ if (cbm_gbuf_find_by_name(graph, want, &nodes, &count) == 0) {
+ for (int i = 0; i < count; i++) {
+ const cbm_gbuf_node_t *n = nodes[i];
+ if (ra_class_label(n->label) && n->file_path && strcmp(n->file_path, files[0]) == 0 &&
+ (!type || n->start_line < type->start_line ||
+ (n->start_line == type->start_line && n->id < type->id))) {
+ type = n;
+ }
+ }
+ }
+ if (!type) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_GRAPH_GAP);
+ return;
+ }
+ const cbm_gbuf_node_t *member = NULL;
+ int members = 0;
+ if (anchor[0] && cbm_gbuf_find_by_name(graph, anchor, &nodes, &count) == 0) {
+ for (int i = 0; i < count; i++) {
+ const cbm_gbuf_node_t *n = nodes[i];
+ if (ra_member_label(n->label) && n->file_path && strcmp(n->file_path, files[0]) == 0 &&
+ n->start_line >= type->start_line && n->start_line <= type->end_line) {
+ member = n;
+ members++;
+ }
+ }
+ }
+ /* an overloaded member: the type that declares it */
+ ra_edge(out, members == SKIP_ONE ? member : type, 0, 0);
+}
+
+static void ra_attribute(const ra_index_t *x, const cbm_gbuf_t *graph, const char *doc,
+ const ra_rec_t *r, cbm_doclink_outcome_t *out) {
+ const ra_comp_t *comp = ra_component_of(x, doc);
+ if (!comp) {
+ return; /* outside an Antora component: no API attributes (H8) */
+ }
+ const char *raw = r->f[2][0] ? r->f[2] : ra_attr(x, comp, r->f[1], strlen(r->f[1]));
+ if (!raw || !strstr(raw, "{javadoc-root}")) {
+ return;
+ }
+ char val[RA_PATH_CAP];
+ if (!ra_expand(x, comp, r->f[2][0] ? r->f[3] : raw, val, sizeof(val))) {
+ return;
+ }
+ ra_javadoc(x, graph, val, out);
+}
+
+static void ra_resolve(const void *index, void *state, int run_file, const CBMDocLink *link,
+ const cbm_gbuf_t *graph, cbm_doclink_outcome_t *out) {
+ (void)state;
+ const ra_index_t *x = (const ra_index_t *)index;
+ out->kind = CBM_DOCLINK_LOCAL;
+ const char *doc = (run_file >= 0 && run_file < x->run_count) ? x->run_paths[run_file] : NULL;
+ if (!doc || !link->raw) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+ return;
+ }
+ if (link->syntax == CBM_DOCLINK_ADOC_CODE_PATH || link->syntax == CBM_DOCLINK_ADOC_CODE_NAME) {
+ CBMDocLink md = *link;
+ md.syntax = link->syntax == CBM_DOCLINK_ADOC_CODE_PATH ? CBM_DOCLINK_MD_CODE_PATH
+ : CBM_DOCLINK_MD_CODE_NAME;
+ cbm_doclink_md_resolver.resolve(x->md, NULL, run_file, &md, graph, out);
+ return;
+ }
+ ra_rec_t *r = (ra_rec_t *)cbm_alloc(CBM_MEM_CLASS_OTHER, sizeof(*r));
+ if (!r || !ra_record(link->raw, r)) {
+ ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+ cbm_free(CBM_MEM_CLASS_OTHER, r);
+ return;
+ }
+ if (link->syntax == CBM_DOCLINK_ADOC_INCLUDE) {
+ ra_include(x, graph, doc, r, out);
+ } else if (link->syntax == CBM_DOCLINK_ADOC_ATTRIBUTE) {
+ ra_attribute(x, graph, doc, r, out);
+ }
+ cbm_free(CBM_MEM_CLASS_OTHER, r);
+}
+
+const cbm_doclink_resolver_t cbm_doclink_adoc_resolver = {
+ .langs = {CBM_LANG_ASCIIDOC, CBM_LANG_YAML},
+ .lang_count = 2,
+ .scope_tag = CBM_DOCLINK_ADOC_SCOPE_TAG,
+ .build = ra_build,
+ .destroy = ra_destroy,
+ .resolve = ra_resolve,
+ .via = "asciidoc",
+};
diff --git a/src/pipeline/doc_links_md.c b/src/pipeline/doc_links_md.c
index b2a76594e..667ea724a 100644
--- a/src/pipeline/doc_links_md.c
+++ b/src/pipeline/doc_links_md.c
@@ -50,6 +50,8 @@ enum {
MDR_HEX_BASE = 16,
MDR_PCT_LEN = 3, /* `%XX` */
MDR_ADR_DIGITS = 5, /* an ADR number has at most this many digits */
+ MDR_PRIO_FIELD = 3, /* H8's label priorities: types 0, Type 1, callables 2 */
+ MDR_PRIO_OTHER = 4,
};
/* Labels whose nodes are code a range or a member can name. */
@@ -108,8 +110,8 @@ static const char *mdr_base(const char *path) {
static bool mdr_code_file(const char *path) {
CBMLanguage lang = cbm_language_for_filename(mdr_base(path));
return lang != CBM_LANG_COUNT && lang != CBM_LANG_MARKDOWN && lang != CBM_LANG_RST &&
- lang != CBM_LANG_HTML && lang != CBM_LANG_CSS && lang != CBM_LANG_SCSS &&
- !cbm_has_config_extension(path);
+ lang != CBM_LANG_ASCIIDOC && lang != CBM_LANG_PDF && lang != CBM_LANG_HTML &&
+ lang != CBM_LANG_CSS && lang != CBM_LANG_SCSS && !cbm_has_config_extension(path);
}
/* The stems of a package directory's index file. */
@@ -1205,6 +1207,228 @@ const cbm_gbuf_node_t *cbm_doclink_md_segment(const void *md_index, const char *
return md_index ? mdr_segment((const mdr_index_t *)md_index, path, first, last, member) : NULL;
}
+/* ── A region of a file's text (the field test's H8 bind_range) ─────── */
+
+/* A blank or comment-only line (H8 _skippable). */
+static bool mdr_skippable(const char *s, size_t n) {
+ size_t i = 0;
+ while (i < n && (s[i] == ' ' || s[i] == '\t' || s[i] == '\r')) {
+ i++;
+ }
+ if (i == n) {
+ return true;
+ }
+ const char *t = s + i;
+ size_t r = n - i;
+ if ((r >= PAIR_LEN && t[0] == '/' && (t[1] == '/' || t[1] == '*')) || t[0] == '*' ||
+ t[0] == ';' || t[0] == '%' || (r >= PAIR_LEN && t[0] == '\'' && t[1] == ' ') ||
+ (r >= PAIR_LEN && t[0] == '-' && t[1] == '-' && r > PAIR_LEN &&
+ (t[PAIR_LEN] == ' ' || t[PAIR_LEN] == '\t')) ||
+ (r >= strlen("<!--") && memcmp(t, "<!--", strlen("<!--")) == 0)) {
+ return true;
+ }
+ return t[0] == '#' && !(r >= PAIR_LEN && (t[1] == '[' || t[1] == '!'));
+}
+
+static bool mdr_annotation(const char *s, size_t n) {
+ size_t i = 0;
+ while (i < n && (s[i] == ' ' || s[i] == '\t')) {
+ i++;
+ }
+ return i < n && (s[i] == '@' || (i + SKIP_ONE < n && s[i] == '#' && s[i + SKIP_ONE] == '['));
+}
+
+static bool mdr_container(const char *label) {
+ static const char *const labels[] = {"Function", "Method", "Class", "Struct", "Interface",
+ "Enum", "Type", "Trait", "Record", NULL};
+ for (int i = 0; label && labels[i]; i++) {
+ if (strcmp(label, labels[i]) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static int mdr_label_prio(const char *label) {
+ if (!label) {
+ return MDR_PRIO_OTHER;
+ }
+ if (mdr_classlike(label) && strcmp(label, "Type") != 0) {
+ return 0;
+ }
+ if (strcmp(label, "Type") == 0) {
+ return SKIP_ONE;
+ }
+ if (strcmp(label, "Function") == 0 || strcmp(label, "Method") == 0) {
+ return PAIR_LEN;
+ }
+ return strcmp(label, "Field") == 0 ? MDR_PRIO_FIELD : MDR_PRIO_OTHER;
+}
+
+/* (s, -e, label priority, id): the order H8 picks maximal nodes in. */
+static int mdr_region_cmp(const void *a, const void *b) {
+ const cbm_gbuf_node_t *x = *(const cbm_gbuf_node_t *const *)a;
+ const cbm_gbuf_node_t *y = *(const cbm_gbuf_node_t *const *)b;
+ if (x->start_line != y->start_line) {
+ return x->start_line < y->start_line ? -1 : 1;
+ }
+ if (x->end_line != y->end_line) {
+ return x->end_line > y->end_line ? -1 : 1;
+ }
+ int px = mdr_label_prio(x->label);
+ int py = mdr_label_prio(y->label);
+ if (px != py) {
+ return px < py ? -1 : 1;
+ }
+ return (x->id > y->id) - (x->id < y->id);
+}
+
+/* Do the maximal nodes cover every line of [a, b] that is not blank or a
+ * comment (an annotation line counts when it sits right above a covered
+ * node, H8's exact-cover)? */
+static bool mdr_exact_cover(const cbm_gbuf_node_t *const *max, int nmax, const size_t *starts,
+ const char *text, size_t text_len, uint32_t a, uint32_t b) {
+ for (uint32_t ln = a; ln <= b; ln++) {
+ bool covered = false;
+ for (int k = 0; k < nmax && !covered; k++) {
+ covered = (uint32_t)max[k]->start_line <= ln && (uint32_t)max[k]->end_line >= ln;
+ }
+ size_t s0 = starts[ln - SKIP_ONE];
+ size_t s1 = starts[ln] > s0 ? starts[ln] - SKIP_ONE : s0;
+ if (covered || s0 >= text_len || mdr_skippable(text + s0, s1 - s0)) {
+ continue;
+ }
+ if (!mdr_annotation(text + s0, s1 - s0)) {
+ return false;
+ }
+ /* annotations, blanks and comments down to a covered node's first line */
+ uint32_t nxt = ln + SKIP_ONE;
+ while (nxt <= b) {
+ size_t t0 = starts[nxt - SKIP_ONE];
+ size_t t1 = starts[nxt] > t0 ? starts[nxt] - SKIP_ONE : t0;
+ if (!mdr_skippable(text + t0, t1 - t0) && !mdr_annotation(text + t0, t1 - t0)) {
+ break;
+ }
+ nxt++;
+ }
+ bool starts_node = false;
+ for (int k = 0; k < nmax && !starts_node; k++) {
+ starts_node = (uint32_t)max[k]->start_line <= nxt && (uint32_t)max[k]->end_line >= nxt;
+ }
+ if (!starts_node) {
+ return false;
+ }
+ }
+ return true;
+}
+
+const cbm_gbuf_node_t *cbm_doclink_md_region(const void *md_index, const char *path,
+ const char *text, size_t text_len, uint32_t first,
+ uint32_t last) {
+ const mdr_index_t *x = (const mdr_index_t *)md_index;
+ if (!x || !text || first == 0 || last < first) {
+ return NULL;
+ }
+ /* line starts: starts[k] is the offset of line k + 1; one past the end */
+ uint32_t nlines = SKIP_ONE;
+ for (size_t i = 0; i < text_len; i++) {
+ nlines += text[i] == '\n';
+ }
+ if (last > nlines) {
+ last = nlines;
+ }
+ if (first > last) {
+ return NULL;
+ }
+ size_t *starts =
+ (size_t *)cbm_alloc(CBM_MEM_CLASS_OTHER, ((size_t)nlines + SKIP_ONE) * sizeof(size_t));
+ if (!starts) {
+ return NULL;
+ }
+ uint32_t k = 0;
+ starts[k++] = 0;
+ for (size_t i = 0; i < text_len; i++) {
+ if (text[i] == '\n') {
+ starts[k++] = i + SKIP_ONE;
+ }
+ }
+ starts[k] = text_len + SKIP_ONE;
+ /* edge blank and comment lines trimmed */
+ uint32_t a = first;
+ uint32_t b = last;
+ while (a <= b && mdr_skippable(text + starts[a - SKIP_ONE],
+ starts[a] - SKIP_ONE - starts[a - SKIP_ONE])) {
+ a++;
+ }
+ while (b >= a && mdr_skippable(text + starts[b - SKIP_ONE],
+ starts[b] - SKIP_ONE - starts[b - SKIP_ONE])) {
+ b--;
+ }
+ if (a > b) {
+ a = first;
+ b = last;
+ }
+ int lo = 0;
+ int hi = 0;
+ mdr_file_defs(x, path, &lo, &hi);
+ const cbm_gbuf_node_t *enc = NULL;
+ for (int i = lo; i < hi; i++) {
+ const cbm_gbuf_node_t *n = x->defs[i].node;
+ if (!mdr_container(n->label) || n->start_line <= 0 || (uint32_t)n->start_line > a ||
+ (uint32_t)n->end_line < b) {
+ continue;
+ }
+ int span = n->end_line - n->start_line;
+ int best = enc ? enc->end_line - enc->start_line : 0;
+ if (!enc || span < best ||
+ (span == best && (n->start_line > enc->start_line ||
+ (n->start_line == enc->start_line &&
+ mdr_label_prio(n->label) < mdr_label_prio(enc->label))))) {
+ enc = n;
+ }
+ }
+ const cbm_gbuf_node_t **inside = (const cbm_gbuf_node_t **)cbm_alloc(
+ CBM_MEM_CLASS_OTHER, (size_t)(hi - lo + SKIP_ONE) * sizeof(*inside));
+ const cbm_gbuf_node_t *pick = NULL;
+ if (inside) {
+ int ni = 0;
+ for (int i = lo; i < hi; i++) {
+ const cbm_gbuf_node_t *n = x->defs[i].node;
+ if (n == enc || n->start_line <= 0 || (uint32_t)n->start_line < a ||
+ (uint32_t)n->end_line > b ||
+ (enc && (n->start_line < enc->start_line || n->end_line > enc->end_line))) {
+ continue;
+ }
+ inside[ni++] = n;
+ }
+ qsort(inside, (size_t)ni, sizeof(*inside), mdr_region_cmp);
+ int nmax = 0; /* maximal ones, compacted in place */
+ for (int i = 0; i < ni; i++) {
+ bool nested = false;
+ for (int m = 0; m < nmax && !nested; m++) {
+ nested = inside[m]->start_line <= inside[i]->start_line &&
+ inside[i]->end_line <= inside[m]->end_line;
+ }
+ if (!nested) {
+ inside[nmax++] = inside[i];
+ }
+ }
+ bool type_enc = !enc || (mdr_classlike(enc->label));
+ bool exact =
+ nmax > 0 && type_enc && mdr_exact_cover(inside, nmax, starts, text, text_len, a, b);
+ if (exact && enc) {
+ pick = nmax == SKIP_ONE ? inside[0] : enc; /* several: the type holding them */
+ } else if (enc) {
+ pick = enc;
+ } else if (nmax == SKIP_ONE) {
+ pick = inside[0];
+ }
+ cbm_free(CBM_MEM_CLASS_OTHER, (void *)inside);
+ }
+ cbm_free(CBM_MEM_CLASS_OTHER, starts);
+ return pick;
+}
+
const cbm_gbuf_node_t *cbm_doclink_md_folder(const void *md_index, const char *path) {
return md_index && path ? mdr_folder((const mdr_index_t *)md_index, NULL, path) : NULL;
}
diff --git a/tests/repro/repro_call_node_manifest.c b/tests/repro/repro_call_node_manifest.c
index fe6e3eda5..6d87ac716 100644
--- a/tests/repro/repro_call_node_manifest.c
+++ b/tests/repro/repro_call_node_manifest.c
@@ -549,9 +549,10 @@ TEST(repro_call_node_manifest_live_specs_contain_only_expected_primary_entries)
/* The registry reproduction owns Nim's stale enum and the
* intentionally grammar-free classifications: Studio Export's
- * transform-only one and PDF's DOCUMENT one (doc_pdf.c). */
+ * transform-only one and the DOCUMENT ones of PDF and AsciiDoc
+ * (doc_pdf.c, doc_adoc.c). */
if (language == CBM_LANG_NIM || language == CBM_LANG_OBJECTSCRIPT_EXPORT ||
- language == CBM_LANG_PDF) {
+ language == CBM_LANG_PDF || language == CBM_LANG_ASCIIDOC) {
continue;
}
if (!spec || spec->language != language) {
diff --git a/tests/repro/repro_language_registry.c b/tests/repro/repro_language_registry.c
index 67496eb7f..e99faaa91 100644
--- a/tests/repro/repro_language_registry.c
+++ b/tests/repro/repro_language_registry.c
@@ -218,6 +218,7 @@ static const LanguageCapabilityEntry LANGUAGE_CAPABILITIES[CBM_LANG_COUNT] = {
CALL_WITHOUT_REFERENCE_VOCAB(PLSQL),
CALL_WITHOUT_REFERENCE_VOCAB(CHIALISP),
DOCUMENT(PDF),
+ DOCUMENT(ASCIIDOC),
};
#undef CALL_WITH_REFERENCE_VOCAB
@@ -311,7 +312,7 @@ TEST(repro_language_capability_ledger_covers_every_enum) {
if (counts[CAP_CALL_WITH_REFERENCE_VOCAB] != 88 ||
counts[CAP_CALL_WITHOUT_REFERENCE_VOCAB] != 27 || counts[CAP_NO_CALL] != 49 ||
counts[CAP_TRANSFORM_ONLY] != 1 || counts[CAP_UNSUPPORTED] != 1 ||
- counts[CAP_DOCUMENT] != 1) {
+ counts[CAP_DOCUMENT] != 2) {
fprintf(stderr,
" [language-registry] invariant=capability_partition call_ref_vocab=%d ref_gap=%d "
"no_call=%d transform_only=%d unsupported=%d document=%d\n",
@@ -330,7 +331,8 @@ TEST(repro_call_argument_matrices_equal_call_capability_ledger) {
EXPECTED_MATRIX_A_ROWS = 68,
EXPECTED_MATRIX_B_ROWS = 49,
EXPECTED_CALL_CAPABLE_LANGUAGES = 115,
- EXPECTED_NON_CALL_LANGUAGES = 52, /* 49 no-call + transform-only + unsupported + PDF */
+ EXPECTED_NON_CALL_LANGUAGES =
+ 53, /* 49 no-call + transform-only + unsupported + PDF, AsciiDoc */
EXPECTED_NON_CALL_DOMAIN_CONTROLS = 2,
};
CBMLanguage matrix_a_ids[CBM_LANG_COUNT];
diff --git a/tests/test_doc_links_adoc.c b/tests/test_doc_links_adoc.c
new file mode 100644
index 000000000..97cd5999e
--- /dev/null
+++ b/tests/test_doc_links_adoc.c
@@ -0,0 +1,287 @@
+/*
+ * test_doc_links_adoc.c — AsciiDoc documents -> Sections and MENTIONS edges
+ * (doc_adoc.c, doc_links_adoc.c).
+ *
+ * Headings and delimited blocks, the tokens (include with the page's
+ * attributes, attribute references, monospace spans), the Antora scope blob,
+ * and the resolver: resource IDs and collector scans, tag regions read from
+ * the included file, lines, javadoc attributes to types and members, the
+ * monospace spans through the Markdown rules, incremental == full.
+ */
+#include "../src/foundation/compat.h"
+#include "test_framework.h"
+#include "test_helpers.h"
+#include "test_doc_mentions_helpers.h"
+
+#include "cbm.h"
+#include "doclink.h"
+#include "pipeline/pipeline.h"
+#include "pipeline/pipeline_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const char *const ADOC_PAGE =
+ "= Writing Tests\n" /* 1 */
+ ":testDir: example$java\n" /* 2 */
+ "\n" /* 3 */
+ "Intro with {Assertions} and {nbsp}.\n" /* 4 */
+ "\n" /* 5 */
+ "== First Test\n" /* 6 */
+ "\n" /* 7 */
+ "[source,java]\n" /* 8 */
+ "----\n" /* 9 */
+ "include::{testDir}/example/FirstTests.java[tags=user_guide]\n" /* 10 */
+ "== Not A Heading\n" /* 11 */
+ "----\n" /* 12 */
+ "\n" /* 13 */
+ "////\n" /* 14 */
+ "include::example$java/Hidden.java[]\n" /* 15 */
+ "////\n" /* 16 */
+ "// include::example$java/Commented.java[]\n" /* 17 */
+ "\n" /* 18 */
+ "=== Details\n" /* 19 */
+ "\n" /* 20 */
+ "See `src/main/java/org/x/Assertions.java` and `org.x.Assertions`.\n" /* 21 */
+ "include::../../../../src/main/java/org/x/Calc.java[lines=4..6]\n" /* 22 */
+ "include::{testDir}/example/WithImports.java[tag=all]\n"; /* 23 */
+
+static const CBMDefinition *adoc_def(const CBMFileResult *r, const char *name) {
+ for (int i = 0; i < r->defs.count; i++) {
+ const CBMDefinition *d = &r->defs.items[i];
+ if (d->label && strcmp(d->label, "Section") == 0 && d->name && strcmp(d->name, name) == 0) {
+ return d;
+ }
+ }
+ return NULL;
+}
+
+static bool adoc_raw_has(const CBMFileResult *r, const char *needle) {
+ for (int i = 0; i < r->doc_links.count; i++) {
+ if (strstr(r->doc_links.items[i].raw, needle)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+TEST(adoc_scan_structure) {
+ CBMFileResult *r =
+ dm_extract(ADOC_PAGE, CBM_LANG_ASCIIDOC, "docs/modules/ROOT/pages/writing.adoc");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->doc_links.failed);
+ const CBMDefinition *top = adoc_def(r, "Writing Tests");
+ const CBMDefinition *first = adoc_def(r, "First Test");
+ const CBMDefinition *details = adoc_def(r, "Details");
+ ASSERT_NOT_NULL(top);
+ ASSERT_NOT_NULL(first);
+ ASSERT_NOT_NULL(details);
+ ASSERT_NULL(adoc_def(r, "Not A Heading")); /* inside a listing block */
+ ASSERT_EQ(first->start_line, 6);
+ ASSERT_EQ(first->end_line, 17);
+ ASSERT_STR_EQ(details->qualified_name, "p.docs.modules.ROOT.pages.writing.Details");
+ /* an include with the page's attribute substituted, its tags */
+ const CBMDocLink *inc =
+ dm_find_token(r, "include::{testDir}/example/FirstTests.java[tags=user_guide]\t"
+ "example$java/example/FirstTests.java\tuser_guide\t");
+ ASSERT_NOT_NULL(inc);
+ ASSERT_EQ(inc->syntax, CBM_DOCLINK_ADOC_INCLUDE);
+ ASSERT_EQ(inc->line, 10);
+ ASSERT_STR_EQ(inc->source_qn, first->qualified_name);
+ ASSERT_NOT_NULL(dm_find_token(r,
+ "include::../../../../src/main/java/org/x/Calc.java[lines=4..6]"
+ "\t../../../../src/main/java/org/x/Calc.java\t\t4..6"));
+ /* nothing from a comment block or a line comment */
+ ASSERT_FALSE(adoc_raw_has(r, "Hidden.java"));
+ ASSERT_FALSE(adoc_raw_has(r, "Commented.java"));
+ /* attribute references: built-ins are none; the page's own carry its value */
+ ASSERT_NOT_NULL(dm_find_token(r, "{Assertions}\tAssertions\t\t"));
+ ASSERT_FALSE(adoc_raw_has(r, "{nbsp}"));
+ /* monospace spans */
+ ASSERT_EQ(dm_find_token(r, "src/main/java/org/x/Assertions.java")->syntax,
+ CBM_DOCLINK_ADOC_CODE_PATH);
+ ASSERT_EQ(dm_find_token(r, "org.x.Assertions")->syntax, CBM_DOCLINK_ADOC_CODE_NAME);
+ cbm_free_result(r);
+ PASS();
+}
+
+static const char *const ANTORA_YML =
+ "name: guide\n"
+ "version: true\n"
+ "ext:\n"
+ " collector:\n"
+ " scan:\n"
+ " - dir: ./build/generated\n"
+ " clean: true\n"
+ " - dir: ./src/test\n"
+ " into: modules/ROOT/examples\n"
+ "asciidoc:\n"
+ " attributes:\n"
+ " javadoc-root: \"xref:attachment$api\"\n"
+ " # API\n"
+ " Assertions: '{javadoc-root}/org.x/org/x/Assertions.html[Assertions]'\n"
+ " assertEquals: '{javadoc-root}/org.x/org/x/Assertions.html#assertEquals(int,int)[x]'\n"
+ " Missing: '{javadoc-root}/org.x/org/x/Gone.html[Gone]'\n";
+
+TEST(adoc_antora_scope_blob) {
+ CBMFileResult *r = dm_extract(ANTORA_YML, CBM_LANG_YAML, "docs/antora.yml");
+ ASSERT_NOT_NULL(r);
+ ASSERT_NOT_NULL(r->doc_scope);
+ ASSERT_STR_EQ(r->doc_scope,
+ "ad1\n"
+ "C\n"
+ "N\tguide\n"
+ "D\t./build/generated\n"
+ "D\t./src/test\n"
+ "I\tmodules/ROOT/examples\n"
+ "A\tjavadoc-root\txref:attachment$api\n"
+ "A\tAssertions\t{javadoc-root}/org.x/org/x/Assertions.html[Assertions]\n"
+ "A\tassertEquals\t{javadoc-root}/org.x/org/x/Assertions.html#assertEquals(int,"
+ "int)[x]\n"
+ "A\tMissing\t{javadoc-root}/org.x/org/x/Gone.html[Gone]\n");
+ cbm_free_result(r);
+ r = dm_extract("site:\n title: x\n", CBM_LANG_YAML, "config/other.yml");
+ ASSERT_NOT_NULL(r);
+ ASSERT_NULL(r->doc_scope);
+ cbm_free_result(r);
+ PASS();
+}
+
+static void adoc_write_repo(const char *repo, const char *first_tests) {
+ th_write_file(TH_PATH(repo, "docs/antora.yml"), ANTORA_YML);
+ th_write_file(TH_PATH(repo, "docs/modules/ROOT/pages/writing.adoc"), ADOC_PAGE);
+ th_write_file(TH_PATH(repo, "docs/src/test/java/example/FirstTests.java"), first_tests);
+ th_write_file(TH_PATH(repo, "src/main/java/org/x/Assertions.java"),
+ "package org.x;\n"
+ "\n"
+ "public class Assertions {\n"
+ " public static void assertEquals(int a, int b) {}\n"
+ " public static void fail() {}\n"
+ "}\n");
+ /* a tag region that takes the imports with the class: it binds the class */
+ th_write_file(TH_PATH(repo, "docs/src/test/java/example/WithImports.java"),
+ "package example;\n"
+ "\n"
+ "// tag::all[]\n"
+ "import java.util.List;\n"
+ "\n"
+ "class WithImports {\n"
+ " List<String> names() { return null; }\n"
+ "}\n"
+ "// end::all[]\n");
+ th_write_file(TH_PATH(repo, "src/main/java/org/x/Calc.java"),
+ "package org.x;\n"
+ "\n"
+ "public class Calc {\n"
+ " public int add(int a, int b) {\n"
+ " return a + b;\n"
+ " }\n"
+ "}\n");
+}
+
+static const char *const FIRST_TESTS = "package example;\n" /* 1 */
+ "\n" /* 2 */
+ "class FirstTests {\n" /* 3 */
+ " void helper() {}\n" /* 4 */
+ "\n" /* 5 */
+ " // tag::user_guide[]\n" /* 6 */
+ " void addition() {\n" /* 7 */
+ " helper();\n" /* 8 */
+ " }\n" /* 9 */
+ " // end::user_guide[]\n" /* 10 */
+ "}\n"; /* 11 */
+
+static bool adoc_edge(const char *db, const char *src, const char *tgt, const char *needle) {
+ char props[512];
+ int n = 0;
+ dm_edge(db, src, tgt, props, sizeof(props), &n);
+ return n == 1 && (!needle || strstr(props, needle));
+}
+
+TEST(adoc_links_pipeline) {
+ char tmp[256];
+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_dladoc_XXXXXX");
+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+ char repo[512];
+ char db[512];
+ snprintf(repo, sizeof(repo), "%s/repo", tmp);
+ snprintf(db, sizeof(db), "%s/g.db", tmp);
+ adoc_write_repo(repo, FIRST_TESTS);
+ ASSERT_EQ(dm_index(repo, db, NULL), 0);
+ const char *page = "docs.modules.ROOT.pages.writing";
+ char src[256];
+ /* a resource ID through a collector scan; the tag region's innermost method */
+ snprintf(src, sizeof(src), "%s.First-Test", page);
+ ASSERT_TRUE(adoc_edge(db, src, "example.FirstTests.addition",
+ "{\"via\":\"asciidoc\",\"syntax\":\"include\",\"tier\":\"exact\""));
+ ASSERT_TRUE(adoc_edge(db, src, "example.FirstTests.addition", "\"target_lines\":[7,9]"));
+ /* a javadoc attribute (under the document title): the type it documents */
+ snprintf(src, sizeof(src), "%s.Writing-Tests", page);
+ ASSERT_TRUE(adoc_edge(db, src, "org.x.Assertions", "\"syntax\":\"attribute\""));
+ /* lines= and a relative include */
+ snprintf(src, sizeof(src), "%s.Details", page);
+ ASSERT_TRUE(adoc_edge(db, src, "org.x.Calc.add", "\"target_lines\":[4,6]"));
+ /* the region's imports are no definition: the one it holds whole binds */
+ ASSERT_TRUE(adoc_edge(db, src, "example.WithImports", "\"target_lines\":[4,8]"));
+ /* monospace spans through the Markdown rules */
+ ASSERT_TRUE(adoc_edge(db, src, "src.main.java.org.x.Assertions.java.__file__",
+ "\"syntax\":\"code_path\""));
+ /* back navigation: the method knows the section that includes it */
+ ASSERT_EQ(dm_count(db, "SELECT COUNT(*) FROM edges e JOIN nodes s ON s.id=e.source_id JOIN "
+ "nodes t ON t.id=e.target_id WHERE e.type='MENTIONS' AND "
+ "t.name='addition' AND s.label='Section' AND s.name='First Test'"),
+ 1);
+ th_cleanup(tmp);
+ PASS();
+}
+
+TEST(adoc_links_incremental) {
+ char tmp[256];
+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_dladoc_inc_XXXXXX");
+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+ char repo[512];
+ char db[512];
+ char full_db[512];
+ snprintf(repo, sizeof(repo), "%s/repo", tmp);
+ snprintf(db, sizeof(db), "%s/inc.db", tmp);
+ snprintf(full_db, sizeof(full_db), "%s/full.db", tmp);
+ adoc_write_repo(repo, FIRST_TESTS);
+ ASSERT_EQ(dm_index(repo, db, NULL), 0);
+ /* the tagged region moves to another method: the page follows it */
+ th_write_file(TH_PATH(repo, "docs/src/test/java/example/FirstTests.java"),
+ "package example;\n"
+ "\n"
+ "class FirstTests {\n"
+ " // tag::user_guide[]\n"
+ " void helper() {}\n"
+ " // end::user_guide[]\n"
+ "\n"
+ " void addition() {\n"
+ " helper();\n"
+ " }\n"
+ "}\n");
+ ASSERT_EQ(dm_step(repo, db, full_db, "tag moved", CBM_INCREMENTAL_ROUTE_CLOSURE_REPAIR), 0);
+ /* a component attribute changes: every page re-resolves */
+ th_write_file(TH_PATH(repo, "docs/antora.yml"),
+ "name: guide\n"
+ "ext:\n"
+ " collector:\n"
+ " scan:\n"
+ " - dir: ./src/test\n"
+ " into: modules/ROOT/examples\n"
+ "asciidoc:\n"
+ " attributes:\n"
+ " javadoc-root: \"xref:attachment$api\"\n"
+ " Assertions: '{javadoc-root}/org.x/org/x/Calc.html[Calc]'\n");
+ ASSERT_EQ(dm_step(repo, db, full_db, "attribute change", CBM_INCREMENTAL_ROUTE_FORCED_FULL), 0);
+ th_cleanup(tmp);
+ PASS();
+}
+
+SUITE(doc_links_adoc) {
+ RUN_TEST(adoc_scan_structure);
+ RUN_TEST(adoc_antora_scope_blob);
+ RUN_TEST(adoc_links_pipeline);
+ RUN_TEST(adoc_links_incremental);
+}
diff --git a/tests/test_main.c b/tests/test_main.c
index 542df5b48..145e96ef6 100644
--- a/tests/test_main.c
+++ b/tests/test_main.c
@@ -1824,6 +1824,7 @@ extern void suite_doc_mentions_msbuild(void);
extern void suite_doc_links_md(void);
extern void suite_doc_links_pdf(void);
extern void suite_doc_links_rst(void);
+extern void suite_doc_links_adoc(void);
extern void suite_infrascan(void);
extern void suite_cli(void);
extern void suite_agent_clients(void);
@@ -2294,6 +2295,7 @@ int main(int argc, char **argv) {
RUN_SELECTED_SUITE(doc_links_md);
RUN_SELECTED_SUITE(doc_links_pdf);
RUN_SELECTED_SUITE(doc_links_rst);
+ RUN_SELECTED_SUITE(doc_links_adoc);
/* Infrastructure scanning */
RUN_SELECTED_SUITE(infrascan);