apex-ruby 1.0.6

data/ext/apex_ext/apex_src/src/extensions/index.h

@@ -0,0 +1,90 @@
+/**
+ * Index Extension for Apex
+ *
+ * Supports three index syntaxes:
+ * - mmark/MultiMarkdown: (!item), (!item, subitem), (!!item, subitem)
+ * - TextIndex: {^}, [term]{^}, {^params}
+ * - Leanpub: {i: term}, {i: "term"}, {i: "Main!sub"}
+ */
+
+#ifndef APEX_INDEX_H
+#define APEX_INDEX_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include "../../include/apex/apex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Index syntax types */
+typedef enum {
+    APEX_INDEX_MMARK = 0,
+    APEX_INDEX_TEXTINDEX = 1,
+    APEX_INDEX_LEANPUB = 2
+} apex_index_syntax_t;
+
+/* Index entry structure */
+typedef struct apex_index_entry {
+    char *item;                    /* Main index term */
+    char *subitem;                 /* Sub-item (optional) */
+    bool primary;                  /* Primary entry flag (mmark) */
+    int position;                  /* Position in document */
+    char *anchor_id;               /* Generated anchor ID (e.g., "idxref-0") */
+    apex_index_syntax_t syntax_type;  /* MMARK or TEXTINDEX */
+    struct apex_index_entry *next;  /* Linked list */
+} apex_index_entry;
+
+/* Index registry */
+typedef struct {
+    apex_index_entry *entries;     /* Linked list of index entries */
+    size_t count;                  /* Number of entries */
+    int next_ref_id;               /* Next reference ID for anchors */
+} apex_index_registry;
+
+/**
+ * Process index entries in text via preprocessing
+ * Extracts index entries and stores them in registry
+ * Returns modified text with index markers
+ */
+char *apex_process_index_entries(const char *text, apex_index_registry *registry, const apex_options *options);
+
+/**
+ * Render index markers in HTML output
+ * Replaces index markers with formatted HTML spans
+ */
+char *apex_render_index_markers(const char *html, apex_index_registry *registry, const apex_options *options);
+
+/**
+ * Generate index HTML from collected entries
+ * Returns formatted index HTML
+ */
+char *apex_generate_index_html(apex_index_registry *registry, const apex_options *options);
+
+/**
+ * Insert index at <!--INDEX--> marker or end of document
+ * Returns HTML with index inserted
+ */
+char *apex_insert_index(const char *html, apex_index_registry *registry, const apex_options *options);
+
+/**
+ * Free index registry
+ */
+void apex_free_index_registry(apex_index_registry *registry);
+
+/**
+ * Create a new index entry
+ */
+apex_index_entry *apex_index_entry_new(const char *item, apex_index_syntax_t syntax_type);
+
+/**
+ * Free an index entry
+ */
+void apex_index_entry_free(apex_index_entry *entry);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_INDEX_H */

data/ext/apex_ext/apex_src/src/extensions/inline_footnotes.c

@@ -0,0 +1,205 @@
+/**
+ * Inline Footnotes Extension for Apex
+ * Implementation
+ */
+
+#include "inline_footnotes.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+/**
+ * Check if a string contains spaces (indicates inline footnote vs reference)
+ */
+static bool has_spaces(const char *text, int len) {
+    for (int i = 0; i < len; i++) {
+        if (isspace((unsigned char)text[i])) return true;
+    }
+    return false;
+}
+
+/**
+ * Process inline footnotes
+ */
+char *apex_process_inline_footnotes(const char *text) {
+    if (!text) return NULL;
+
+    size_t len = strlen(text);
+    /* Allocate generous buffer (inline footnotes become references + definitions) */
+    size_t capacity = len * 3;
+    char *output = malloc(capacity);
+    if (!output) return strdup(text);
+
+    const char *read = text;
+    char *write = output;
+    size_t remaining = capacity;
+
+    /* Track footnotes to add at end */
+    typedef struct footnote_def {
+        int number;
+        char *content;
+        struct footnote_def *next;
+    } footnote_def;
+
+    footnote_def *footnotes = NULL;
+    footnote_def **footnote_tail = &footnotes;
+    int footnote_count = 0;
+
+    bool in_code_block = false;
+    bool in_code_span = false;
+
+    #define WRITE_STR(str) do { \
+        size_t slen = strlen(str); \
+        if (slen < remaining) { \
+            memcpy(write, str, slen); \
+            write += slen; \
+            remaining -= slen; \
+        } \
+    } while(0)
+
+    #define WRITE_CHAR(c) do { \
+        if (remaining > 0) { \
+            *write++ = c; \
+            remaining--; \
+        } \
+    } while(0)
+
+    while (*read) {
+        /* Track code blocks (don't process footnotes inside) */
+        if (strncmp(read, "```", 3) == 0 || strncmp(read, "~~~", 3) == 0) {
+            in_code_block = !in_code_block;
+            WRITE_CHAR(*read);
+            read++;
+            continue;
+        }
+
+        /* Track inline code spans */
+        if (*read == '`' && !in_code_block) {
+            in_code_span = !in_code_span;
+            WRITE_CHAR(*read);
+            read++;
+            continue;
+        }
+
+        if (in_code_block || in_code_span) {
+            WRITE_CHAR(*read);
+            read++;
+            continue;
+        }
+
+        /* Check for Kramdown inline footnote: ^[text] */
+        if (*read == '^' && read[1] == '[') {
+            const char *start = read + 2;
+            const char *end = start;
+            int bracket_depth = 1;
+
+            /* Find matching ] */
+            while (*end && bracket_depth > 0) {
+                if (*end == '[') bracket_depth++;
+                else if (*end == ']') bracket_depth--;
+                if (bracket_depth > 0) end++;
+            }
+
+            if (*end == ']') {
+                /* Found complete inline footnote */
+                int content_len = end - start;
+
+                /* Create footnote definition */
+                footnote_def *fn = malloc(sizeof(footnote_def));
+                if (fn) {
+                    fn->number = ++footnote_count;
+                    fn->content = malloc(content_len + 1);
+                    if (fn->content) {
+                        memcpy(fn->content, start, content_len);
+                        fn->content[content_len] = '\0';
+                    }
+                    fn->next = NULL;
+                    *footnote_tail = fn;
+                    footnote_tail = &fn->next;
+
+                    /* Write reference */
+                    char ref[32];
+                    snprintf(ref, sizeof(ref), "[^fn%d]", fn->number);
+                    WRITE_STR(ref);
+
+                    read = end + 1;
+                    continue;
+                }
+            }
+        }
+
+        /* Check for MMD inline footnote: [^text with spaces] */
+        if (*read == '[' && read[1] == '^') {
+            const char *start = read + 2;
+            const char *end = start;
+
+            /* Find closing ] */
+            while (*end && *end != ']' && *end != '\n') end++;
+
+            if (*end == ']') {
+                int content_len = end - start;
+
+                /* Check if it has spaces (MMD inline) vs no spaces (reference) */
+                if (has_spaces(start, content_len)) {
+                    /* MMD inline footnote */
+                    footnote_def *fn = malloc(sizeof(footnote_def));
+                    if (fn) {
+                        fn->number = ++footnote_count;
+                        fn->content = malloc(content_len + 1);
+                        if (fn->content) {
+                            memcpy(fn->content, start, content_len);
+                            fn->content[content_len] = '\0';
+                        }
+                        fn->next = NULL;
+                        *footnote_tail = fn;
+                        footnote_tail = &fn->next;
+
+                        /* Write reference */
+                        char ref[32];
+                        snprintf(ref, sizeof(ref), "[^fn%d]", fn->number);
+                        WRITE_STR(ref);
+
+                        read = end + 1;
+                        continue;
+                    }
+                }
+                /* else: it's a regular footnote reference, fall through */
+            }
+        }
+
+        /* Regular character */
+        WRITE_CHAR(*read);
+        read++;
+    }
+
+    /* Add footnote definitions at the end */
+    if (footnotes) {
+        WRITE_STR("\n\n");
+
+        for (footnote_def *fn = footnotes; fn; fn = fn->next) {
+            char def[64];
+            snprintf(def, sizeof(def), "[^fn%d]: ", fn->number);
+            WRITE_STR(def);
+            WRITE_STR(fn->content);
+            WRITE_CHAR('\n');
+        }
+    }
+
+    *write = '\0';
+
+    /* Clean up footnote list */
+    while (footnotes) {
+        footnote_def *next = footnotes->next;
+        free(footnotes->content);
+        free(footnotes);
+        footnotes = next;
+    }
+
+    #undef WRITE_STR
+    #undef WRITE_CHAR
+
+    return output;
+}
+

data/ext/apex_ext/apex_src/src/extensions/inline_footnotes.h

@@ -0,0 +1,34 @@
+/**
+ * Inline Footnotes Extension for Apex
+ *
+ * Supports two inline footnote syntaxes:
+ * 1. Kramdown: ^[footnote text]
+ * 2. MultiMarkdown: [^footnote text with spaces]
+ *
+ * Both are converted to standard footnote references + definitions
+ * before the main parsing phase.
+ */
+
+#ifndef APEX_INLINE_FOOTNOTES_H
+#define APEX_INLINE_FOOTNOTES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Process inline footnotes by converting them to reference style
+ *
+ * Kramdown: text^[inline note] → text[^fn1]...[^fn1]: inline note
+ * MMD: text[^inline note] → text[^fn1]...[^fn1]: inline note
+ *
+ * Returns newly allocated string with footnotes converted
+ */
+char *apex_process_inline_footnotes(const char *text);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_INLINE_FOOTNOTES_H */
+

data/ext/apex_ext/apex_src/src/extensions/inline_tables.c

@@ -0,0 +1,332 @@
+/**
+ * Inline Tables Extension for Apex
+ * Implementation
+ */
+
+#include "inline_tables.h"
+#include "includes.h"  /* for apex_csv_to_table */
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <ctype.h>
+
+/* Detect delimiter for a block of lines: TSV if any tab, else CSV if any comma, else none */
+static int detect_delimiter(const char *start, const char *end) {
+    bool has_tab = false;
+    bool has_comma = false;
+
+    for (const char *p = start; p < end; p++) {
+        if (*p == '\t') has_tab = true;
+        else if (*p == ',') has_comma = true;
+        if (has_tab) break;
+    }
+
+    if (has_tab) return '\t';
+    if (has_comma) return ',';
+    return 0;
+}
+
+/* Process ```table fenced blocks and <!--TABLE--> markers */
+char *apex_process_inline_tables(const char *text) {
+    if (!text) return NULL;
+
+    size_t len = strlen(text);
+    size_t capacity = len * 3 + 1; /* allow for table expansion */
+    char *out = malloc(capacity);
+    if (!out) return strdup(text);
+
+    const char *read = text;
+    char *write = out;
+
+    while (*read) {
+        /* ```table fenced block */
+        if (read[0] == '`' && read[1] == '`' && read[2] == '`') {
+            const char *line_start = read;
+            const char *p = read + 3;
+
+            /* Read info string until end of line */
+            while (*p && *p != '\n') p++;
+            const char *info_start = read + 3;
+            const char *info_end = p;
+            while (info_start < info_end && isspace((unsigned char)*info_start)) info_start++;
+            while (info_end > info_start && isspace((unsigned char)*(info_end - 1))) info_end--;
+
+            bool is_table_fence = false;
+            if (info_end > info_start) {
+                size_t info_len = (size_t)(info_end - info_start);
+                if (info_len == 5 && strncasecmp(info_start, "table", 5) == 0) {
+                    is_table_fence = true;
+                }
+            }
+
+            /* Move past newline after fence line */
+            if (*p == '\n') p++;
+            const char *content_start = p;
+
+            /* Find closing fence */
+            const char *closing = NULL;
+            while (*p) {
+                if (p[0] == '`' && p[1] == '`' && p[2] == '`') {
+                    closing = p;
+                    break;
+                }
+                p++;
+            }
+
+            const char *content_end = closing ? closing : text + len;
+
+            if (is_table_fence) {
+                int delim = detect_delimiter(content_start, content_end);
+                if (delim == 0) {
+                    /* No delimiter detected: emit original fence block unchanged */
+                    size_t block_len = (closing ? (p + 3 - line_start) : (text + len - line_start));
+                    if (write + block_len >= out + capacity) {
+                        size_t used = (size_t)(write - out);
+                        capacity = (used + block_len + 1) * 2;
+                        char *tmp = realloc(out, capacity);
+                        if (!tmp) {
+                            free(out);
+                            return strdup(text);
+                        }
+                        out = tmp;
+                        write = out + used;
+                    }
+                    memcpy(write, line_start, block_len);
+                    write += block_len;
+                    read = closing ? (p + 3) : (text + len);
+                    continue;
+                }
+
+                /* Convert to table */
+                bool is_tsv = (delim == '\t');
+                /* content_start..content_end may not be null-terminated */
+                size_t data_len = (size_t)(content_end - content_start);
+                char *data = malloc(data_len + 1);
+                if (!data) {
+                    free(out);
+                    return strdup(text);
+                }
+                memcpy(data, content_start, data_len);
+                data[data_len] = '\0';
+
+                char *table = apex_csv_to_table(data, is_tsv);
+                free(data);
+
+                if (!table) {
+                    /* Fallback: emit original block */
+                    size_t block_len = (closing ? (p + 3 - line_start) : (text + len - line_start));
+                    if (write + block_len >= out + capacity) {
+                        size_t used = (size_t)(write - out);
+                        capacity = (used + block_len + 1) * 2;
+                        char *tmp = realloc(out, capacity);
+                        if (!tmp) {
+                            free(out);
+                            return strdup(text);
+                        }
+                        out = tmp;
+                        write = out + used;
+                    }
+                    memcpy(write, line_start, block_len);
+                    write += block_len;
+                    read = closing ? (p + 3) : (text + len);
+                    continue;
+                }
+
+                size_t table_len = strlen(table);
+                if (write + table_len >= out + capacity) {
+                    size_t used = (size_t)(write - out);
+                    capacity = (used + table_len + 1) * 2;
+                    char *tmp = realloc(out, capacity);
+                    if (!tmp) {
+                        free(out);
+                        free(table);
+                        return strdup(text);
+                    }
+                    out = tmp;
+                    write = out + used;
+                }
+                memcpy(write, table, table_len);
+                write += table_len;
+                free(table);
+
+                /* Skip closing fence line */
+                if (closing) {
+                    p += 3;
+                    while (*p && *p != '\n') p++;
+                    if (*p == '\n') {
+                        *write++ = '\n';
+                        p++;
+                    }
+                    read = p;
+                } else {
+                    read = text + len;
+                }
+                continue;
+            } else {
+                /* Not a table fence: copy as-is up to first char after closing fence */
+                const char *block_end = closing ? (p + 3) : (text + len);
+                size_t block_len = (size_t)(block_end - line_start);
+                if (write + block_len >= out + capacity) {
+                    size_t used = (size_t)(write - out);
+                    capacity = (used + block_len + 1) * 2;
+                    char *tmp = realloc(out, capacity);
+                    if (!tmp) {
+                        free(out);
+                        return strdup(text);
+                    }
+                    out = tmp;
+                    write = out + used;
+                }
+                memcpy(write, line_start, block_len);
+                write += block_len;
+                read = block_end;
+                continue;
+            }
+        }
+
+        /* <!--TABLE--> marker */
+        if (strncmp(read, "<!--TABLE-->", 12) == 0) {
+            const char *marker_start = read;
+            const char *p = read + 12;
+            /* Skip optional trailing spaces and one newline */
+            while (*p == ' ' || *p == '\t') p++;
+            if (*p == '\r') p++;
+            if (*p == '\n') p++;
+
+            const char *data_start = p;
+            const char *data_end = data_start;
+            bool seen_nonblank = false;
+
+            while (*data_end) {
+                const char *line = data_end;
+                const char *line_end = line;
+                while (*line_end && *line_end != '\n') line_end++;
+
+                /* Check if line is blank */
+                const char *q = line;
+                while (q < line_end && (*q == ' ' || *q == '\t' || *q == '\r')) q++;
+                bool blank = (q == line_end);
+
+                if (blank) {
+                    break;
+                }
+
+                seen_nonblank = true;
+                data_end = (*line_end == '\n') ? (line_end + 1) : line_end;
+            }
+
+            if (!seen_nonblank) {
+                /* No data: just copy marker through */
+                size_t marker_len = (size_t)(p - marker_start);
+                if (write + marker_len >= out + capacity) {
+                    size_t used = (size_t)(write - out);
+                    capacity = (used + marker_len + 1) * 2;
+                    char *tmp = realloc(out, capacity);
+                    if (!tmp) {
+                        free(out);
+                        return strdup(text);
+                    }
+                    out = tmp;
+                    write = out + used;
+                }
+                memcpy(write, marker_start, marker_len);
+                write += marker_len;
+                read = p;
+                continue;
+            }
+
+            int delim = detect_delimiter(data_start, data_end);
+            if (delim == 0) {
+                /* No delimiter: emit marker and data unchanged */
+                size_t block_len = (size_t)(data_end - marker_start);
+                if (write + block_len >= out + capacity) {
+                    size_t used = (size_t)(write - out);
+                    capacity = (used + block_len + 1) * 2;
+                    char *tmp = realloc(out, capacity);
+                    if (!tmp) {
+                        free(out);
+                        return strdup(text);
+                    }
+                    out = tmp;
+                    write = out + used;
+                }
+                memcpy(write, marker_start, block_len);
+                write += block_len;
+                read = data_end;
+                continue;
+            }
+
+            bool is_tsv = (delim == '\t');
+            size_t data_len = (size_t)(data_end - data_start);
+            char *data = malloc(data_len + 1);
+            if (!data) {
+                free(out);
+                return strdup(text);
+            }
+            memcpy(data, data_start, data_len);
+            data[data_len] = '\0';
+
+            char *table = apex_csv_to_table(data, is_tsv);
+            free(data);
+
+            if (!table) {
+                /* Fallback: copy original */
+                size_t block_len = (size_t)(data_end - marker_start);
+                if (write + block_len >= out + capacity) {
+                    size_t used = (size_t)(write - out);
+                    capacity = (used + block_len + 1) * 2;
+                    char *tmp = realloc(out, capacity);
+                    if (!tmp) {
+                        free(out);
+                        return strdup(text);
+                    }
+                    out = tmp;
+                    write = out + used;
+                }
+                memcpy(write, marker_start, block_len);
+                write += block_len;
+                read = data_end;
+                continue;
+            }
+
+            size_t table_len = strlen(table);
+            if (write + table_len >= out + capacity) {
+                size_t used = (size_t)(write - out);
+                capacity = (used + table_len + 1) * 2;
+                char *tmp = realloc(out, capacity);
+                if (!tmp) {
+                    free(out);
+                    free(table);
+                    return strdup(text);
+                }
+                out = tmp;
+                write = out + used;
+            }
+            memcpy(write, table, table_len);
+            write += table_len;
+            free(table);
+
+            read = data_end;
+            continue;
+        }
+
+        /* Default: copy one char */
+        *write++ = *read++;
+        if ((size_t)(write - out) + 1 >= capacity) {
+            size_t used = (size_t)(write - out);
+            capacity = (used * 2) + 1;
+            char *tmp = realloc(out, capacity);
+            if (!tmp) {
+                free(out);
+                return strdup(text);
+            }
+            out = tmp;
+            write = out + used;
+        }
+    }
+
+    *write = '\0';
+    return out;
+}
+
+

data/ext/apex_ext/apex_src/src/extensions/inline_tables.h

@@ -0,0 +1,13 @@
+/**
+ * Inline Tables Extension for Apex
+ * Interface
+ */
+
+#ifndef APEX_INLINE_TABLES_H
+#define APEX_INLINE_TABLES_H
+
+char *apex_process_inline_tables(const char *text);
+
+#endif /* APEX_INLINE_TABLES_H */
+
+