path: root/rst_context.lua

#!/usr/bin/env texlua
--------------------------------------------------------------------------------
--         FILE:  rst_context.lua
--        USAGE:  ./rst_context.lua 
--  DESCRIPTION:  
--      OPTIONS:  ---
-- REQUIREMENTS:  ---
--       AUTHOR:  Philipp Gesang (Phg), <megas.kapaneus@gmail.com>
--      VERSION:  1.0
--      CREATED:  31/08/10 19:35:15 CEST
--------------------------------------------------------------------------------
--
--- TODO
-- - Find an appropriate way to handle generic tables irrespective of the grid
--   settings. The problem is:
--   http://archive.contextgarden.net/message/20100912.112605.8a1aaf13.en.html
--   Seems we'll have to choose either the grid or split tables as default. Not
--   good.


require "lpeg"
help = require "rst_helpers"

local dbg_write = help.dbg_writef

local C, Cb, Cc, Cg, Cmt, Cp, Cs, Ct, P, R, S, V, match = lpeg.C, lpeg.Cb, lpeg.Cc, lpeg.Cg, lpeg.Cmt, lpeg.Cp, lpeg.Cs, lpeg.Ct, lpeg.P, lpeg.R, lpeg.S, lpeg.V, lpeg.match

-- This one should ignore escaped spaces.
do
    local stripper = P{
        [1] = "stripper",
        stripper = V"space"^0 * C((V"space"^0 * (V"escaped" + V"nospace")^1)^0),
        space    = S(" \t\v\n"),
        nospace  = 1 - V"space",
        escaped  = P"\\" * V"space"
    }
    function string.strip(str)
        return stripper:match(str) or ""
    end 
end

local rst_context = {}


rst_context.collected_references = {}
rst_context.collected_adornments = {}
rst_context.last_section_level   = 0
rst_context.anonymous_targets    = 0
rst_context.anonymous_links      = 0
rst_context.context_references   = {}
rst_context.substitutions        = {}

rst_context.current_footnote_number   = 0
rst_context.current_symbolnote_number = 0

function rst_context.footnote_reference (label)
    local tf = state.footnotes
    if label:match("^%d+$") then -- all digits
        local c = tonumber(label)
        print("creating footnote nr " .. c)
        return [[\\footnote{\\getbuffer[__footnote_number_]].. c .."]}"
    elseif label == "#" then --autonumber
        local rc = rst_context.current_footnote_number
        rc = rc + 1
        --rst_context.current_footnote_number = rst_context.current_footnote_number + 1
        print("creating footnote nr " .. rc)
        rst_context.current_footnote_number = rc
        return [[\\footnote{\\getbuffer[__footnote_number_]].. rc .."]}"
    elseif label:match("^#.+$") then
        local thelabel = label:match("^#(.+)$")
        print("creating labeled footnote " .. thelabel)
        return [[\\footnote{\\getbuffer[__footnote_label_]].. thelabel .."]}"
    elseif label == "*" then
        local rc = rst_context.current_symbolnote_number
        rc = rc + 1
        print("creating symbolnote nr " .. rc)
        rst_context.current_symbolnote_number = rc
        return [[\\symbolnote{\\getbuffer[__footnote_symbol_]].. rc .."]}"
    else -- “citation reference” for now treating them like footnotes
        local rc = rst_context.current_footnote_number
        rc = rc + 1
        --rst_context.current_footnote_number = rst_context.current_footnote_number + 1
        print("creating footnote nr " .. rc)
        rst_context.current_footnote_number = rc
        return [[\\footnote{\\getbuffer[__footnote_number_]].. rc .."]}"
        --return [[\\cite{]] .. label .. "}"
    end
end

function rst_context.addsetups(item)
    state.addme[item] = state.addme[item] or true
    return 0
end

do
    local w = S" \v\t\n" / "_"
    local wp = Cs((w + 1)^1)
    function rst_context.whitespace_to_underscore(str)
        return  str and wp:match(str) or ""
    end
end

-- So we can use crefs[n][2] to refer to the place where the reference was
-- created.
local function get_context_reference (str)
    local crefs = rst_context.context_references
    refstring = "__target_" .. rst_context.whitespace_to_underscore(str)
    crefs[#crefs + 1] = { refstring, str }
    return refstring
end

function rst_context.emphasis (str)
    return [[{\\em ]] .. str .. [[}]]
end

function rst_context.strong_emphasis (str)
    return [[{\\sc ]] .. str .. [[}]]
end

function rst_context.literal (str)
    str = str:gsub([[\]], [[\\]]) -- evade escaping of backslashes
    return [[\\type{]] .. str .. [[}]]
    --return [[\\starttyping ]] .. str .. [[\\stoptyping]]
end


function rst_context.interpreted_text (...)
    local tab = { ... }
    --print (tab, #tab, tab[1], tab[2], tab[3])
    local role, str
    role = tab[1]:match("^:(.*):$") or tab[3]:match("^:(.*):$")
    str  = tab[2]

    if not role then -- implicit role
        role = "emphasis"
    end

    --print(role, str)

    return rst_context[role](str)
end

function rst_context.link_standalone (str)
    return "\n"
        .. [[\\goto{\\hyphenatedurl{]] .. str .. [[}}[url(]] .. str .. [=[)]]=]
end

function rst_context.reference (str)
    rst_context.addsetups("references")
    str = str:match("^`?([^`]+)`?_$") -- LPEG could render this gibberish legible but not time
    return [[\\RSTchoosegoto{__target_]] .. rst_context.whitespace_to_underscore(str) .. "}{"
            .. str .. "}"
end

function rst_context.anon_reference (str)
    rst_context.addsetups("references")
    str = str:match("^`?([^`]+)`?__$")
    rst_context.anonymous_links = rst_context.anonymous_links + 1
    link = "__target_anon_" .. rst_context.anonymous_links
    --return [[\\goto{]] .. str .. [[}[url(]] .. link .. [=[)]]=]
    return string.format([[\\RSTchoosegoto{%s}{%s}]], link, str)
end

local whitespace = S" \n\t\v"
local nowhitespace = 1 - whitespace
local removewhitespace = Cs((nowhitespace^1 + Cs(whitespace / ""))^0)

function rst_context.target (tab)
    rst_context.addsetups("references")
    --print("GOT ONE!")
    --local tab = { ... }
    local refs = rst_context.collected_references
    local target = tab[#tab] -- Ct + C could be clearer but who cares
    tab[#tab] = nil

    local function create_anonymous ()
        rst_context.anonymous_targets = rst_context.anonymous_targets + 1
        return "anon_" .. rst_context.anonymous_targets
    end

    --target = resolve_indirect (target)

    local insert = ""

    --if removewhitespace:match(target) == "" then
    if target == "" then -- links here
        for _, id in next, tab do
            print(id)
            insert = insert .. "\n\\reference[__target_" .. id .. "]{}"
        end
    else
        for i=1,#tab do
            local id = tab[i]
            if id == "" then -- anonymous
                id = create_anonymous()
            else
                id = tab[i]:gsub("\\:",":"):match("`?([^`]+)`?") -- deescaping
            end
            if id then
                refs[id] = refs[id] or target
            end
        end
    end

    return insert
end

function rst_context.inline_internal_target (str)
    return "\\\\reference[__target_" .. rst_context.whitespace_to_underscore(str) .."]{}"
end

function rst_context.substitution_reference (str, underscores)
    local sub = ""
    rst_context.addsetups("substitutions")
    if underscores == "_" then -- normal reference
        sub = sub .. [[\\reference[__target_]] .. rst_context.whitespace_to_underscore(string.strip(str)) .. "]{}"
    elseif underscores == "__" then -- normal reference
        rst_context.anonymous_targets = rst_context.anonymous_targets + 1
        sub = sub .. [[\\reference[__target_anon_]] .. rst_context.anonymous_targets .. "]{}"
    end
    return sub .. [[{\\RSTsubstitution]] .. str:gsub("%s", "") .. "}"
end

function rst_context.escape (str)
    str = str:gsub("\\(.)", "%1")
    return str
end

function rst_context.joinindented (tab)
    return table.concat (tab, "")
end

local corresponding = {
    ['"'] = '"',
    ["'"] = "'",
    ["{"] = "}",
    ["("] = ")",
    ["["] = "]",
    ["<"] = ">",
}

local inline_parser = P{
    [1] = "block",

    block = Cs(V"inline_as_first"^-1 * (V"enclosed" + V"inline_element" + 1)^1),

    inline_element = V"precede_inline"
                    * Cs(V"inline_do_elements")
                    * V"succede_inline"
                    + V"footnote_reference"
                    ,

    -- Ugly but needed in case the first element of a paragraph is inline
    -- formatted.
    inline_as_first = V"inline_do_elements" * V"succede_inline",

    inline_do_elements = V"strong_emphasis"
                     + V"substitution_reference"
                     + V"anon_reference"
                     + V"reference"
                     + V"emphasis"
                     + V"inline_literal"
                     + V"interpreted_text"
                     + V"inline_internal_target"
                     + V"link_standalone"
                     ,

    precede_inline = V"spacing"
                   + V"eol"
                   + -P(1)
                   + S[['"([{<-/:]]
                   + P"‘" + P"“" + P"’" + P"«" + P"¡" + P"¿"
                   + V"inline_delimiter"
                   + P"„", -- not in standard Murkin reST

    succede_inline = V"spacing"
                   + S[['")]}>-/:.,;!?\]]
                   + P"’" + P"”" + P"»"
                   + V"inline_delimiter"
                   + -P(1)
                   + P"“", -- non-standard again but who cares

    enclosed = V"precede_inline"^-1
             * Cg(V"quote_single" + V"quote_double" + V"leftpar", "lastgroup")
             * V"inline_delimiter"
             * Cmt(C(V"quote_single" + V"quote_double" + V"rightpar") * Cb("lastgroup"), function(s, i, char, oldchar)
                    return corresponding[oldchar] == char
                end)
             * V"succede_inline"^-1
             * -V"underscore"
             ,

    space = P" ",
    whitespace = (P" " + Cs(P"\t") / "        " + Cs(S"\v") / " "),
    spacing = V"whitespace"^1,

    eol = P"\n",
    --inline_delimiters = P"‐" + P"‑" + P"‒" + P"–" + V"emdash" + V"space",        -- inline markup
    inline_delimiter = P"‐" + P"‑" + P"‒" + P"–" + V"emdash" + V"space"
                     + V"bareia"
                     + V"asterisk"
                     + V"bar"
                     + V"lsquare" + V"rsquare"
                     ,        -- inline markup
    asterisk = P"*",
    quote_single = P"'",
    quote_double = P'"',
    double_asterisk = V"asterisk" * V"asterisk",
    bareia = P"`",
    backslash = P"\\",
    bar = P"|",
    double_bareia = V"bareia" * V"bareia",
    escaped_bareia = (Cs(V"backslash") / "" * V"bareia") + 1,
    colon = P":",
    semicolon = P";",
    underscore = P"_",
    double_underscore = V"underscore" * V"underscore",
    dot = P".",
    interpunct = P"·",
    comma = P",",
    dash = P"-",
    emdash = P"—",
    ellipsis   = P"…" + P"...",
    exclamationmark = P"!",
    questionmark = P"?",
    interrobang = P"‽",
    double_dash = V"dash" * V"dash",
    triple_dash = V"double_dash" * V"dash",
    hyphen = P"‐",
    dashes = V"dash" + P"‒" + P"–" + V"emdash" + P"―",

    lparenthesis = P"(",
    rparenthesis = P")",
    lsquare = P"[",
    rsquare = P"]",
    lbrace = P"{",
    rbrace = P"}",
    less    = P"<",
    greater = P">",
    leftpar  = V"lparenthesis" + V"lsquare" + V"lbrace" + V"less",
    rightpar = V"rparenthesis" + V"rsquare" + V"rbrace" + V"greater",

    --groupchars = S"()[]{}",
    groupchars = V"leftpar" + V"rightpar",
    apostrophe = P"’" + P"'",

    guillemets = P"«" + P"»",
    quotationmarks= P"‘" + P"’" + P"“" + P"”",
    solidus= P"⁄",
    slash = P"/",

    gartenzaun = P"#",
    digit  = R"09",
    letter = R"az" + R"AZ",

    punctuation = V"apostrophe"
                + V"colon" 
                + V"comma" 
                + V"dashes"
                + V"dot" 
                + V"ellipsis"
                + V"exclamationmark"
                + V"guillemets"
                + V"hyphen"
                + V"interpunct"
                + V"interrobang"
                + V"questionmark" 
                + V"quotationmarks"
                + V"semicolon" 
                + V"slash"
                + V"solidus"
                + V"underscore"
                ,

    emphasis        = (V"asterisk" - V"double_asterisk") 
                    * Cs((1 - V"spacing" - V"eol" - V"asterisk")
                       * ((1 - (1 * V"asterisk"))^0 
                        * (1 - V"spacing" - V"eol" - V"asterisk"))^-1) 
                    * V"asterisk" 
                    / rst_context.emphasis,

    strong_emphasis = V"double_asterisk" 
                    * Cs((1 - V"spacing" - V"eol" - V"asterisk")
                       * ((1 - (1 * V"double_asterisk"))^0 
                        * (1 - V"spacing" - V"eol" - V"asterisk"))^-1) 
                    * V"double_asterisk"  
                    / rst_context.strong_emphasis,

    inline_literal  = V"double_bareia"
                    * C ((V"escaped_bareia" - V"spacing" - V"eol" - V"bareia")
                       * ((V"escaped_bareia" - (1 * V"double_bareia"))^0
                        * (V"escaped_bareia" - V"spacing" - V"eol" - V"bareia"))^-1)
                    * V"double_bareia"
                    / rst_context.literal,

    interpreted_text = C(V"role_marker"^-1)
                     * (V"bareia" - V"double_bareia")
                     * C ((1 - V"spacing" - V"eol" - V"bareia")
                        * ((1 - (1 * V"bareia"))^0
                         * (1 - V"spacing" - V"eol" - V"bareia"))^-1)
                     * V"bareia"
                     * C(V"role_marker"^-1)
                     / rst_context.interpreted_text,

    role_marker = V"colon" * (V"letter" + V"dash" + V"underscore" + V"dot")^1 * V"colon",

    link_standalone = C(V"uri")
                    / rst_context.link_standalone,

    anon_reference = Cs(V"anon_normal_reference" + V"anon_phrase_reference")
              / rst_context.anon_reference,

    anon_normal_reference = (1 - V"underscore" - V"spacing" - V"eol" - V"punctuation" - V"groupchars")^1 * V"double_underscore",

    anon_phrase_reference = (V"bareia" - V"double_bareia")
                     * C((1 - V"bareia")^1)
                     * V"bareia" * V"double_underscore"
                     ,

    reference = Cs(V"normal_reference" + V"phrase_reference")
              / rst_context.reference,

    normal_reference = (1 - V"underscore" - V"spacing" - V"eol" - V"punctuation" - V"groupchars")^1 * V"underscore",

    phrase_reference = (V"bareia" - V"double_bareia")
                     * C((1 - V"bareia")^1)
                     * V"bareia" * V"underscore"
                     ,

    footnote_reference = V"lsquare" 
                       * Cs(V"footnote_label" + V"citation_reference_label") 
                       * V"rsquare" 
                       * V"underscore"
                       / rst_context.footnote_reference
                       ,

    footnote_label = V"digit"^1
                   + V"gartenzaun" * V"letter"^1
                   + V"gartenzaun"
                   + V"asterisk"
                   ,

    citation_reference_label = V"letter" * (1 - V"rsquare")^1,

    inline_internal_target = V"underscore"
                           * V"bareia"
                           * Cs((1 - V"bareia")^1)
                           * V"bareia"
                           / rst_context.inline_internal_target
                           ,

    substitution_reference = V"bar"
                           * C((1 - V"bar")^1)
                           * V"bar"
                           * C((V"double_underscore" + V"underscore")^-1)
                           / rst_context.substitution_reference
                           ,

--------------------------------------------------------------------------------
-- Urls
--------------------------------------------------------------------------------
    uri = V"url_protocol" * V"url_domain" * (V"slash" * V"url_path")^0,

    url_protocol = (P"http" + P"ftp" + P"shttp" + P"sftp") * P"://",
    url_domain_char = 1 - V"dot" - V"spacing" - V"eol" - V"punctuation",
    url_domain = V"url_domain_char"^1 * (V"dot" * V"url_domain_char"^1)^0,
    url_path_char = R("az", "AZ", "09") + S"-_.!~*'()",
    url_path = V"slash" * (V"url_path_char"^1 * V"slash"^-1)^1,
}

function rst_context.paragraph (data)
    local str
    if not data then
        return ""
    elseif type(data) == "table" then
        str = helpers.string.wrapat(inline_parser:match(table.concat(data, " ")), 65)
    else
        str = data
    end
    return string.format([[

\\startparagraph
%s
\\stopparagraph
]], str)
end

local sectionlevels = {
    [1] = "chapter",
    [2] = "section",
    [3] = "subsection",
    [4] = "subsubsection",
    [5] = "subsubsubsection",
}

local function get_line_pattern (chr)
    return P(chr)^1 * (-P(1))
end

function rst_context.section (...)  -- TODO general cleanup; move validity
    local tab = { ... }             -- checking to parser.
    local section, str = true, ""
    local adornchar 
    local ulen = unicode.utf8.len
    if #tab == 3 then -- TODO use unicode length with ConTeXt
        adornchar = tab[1]:sub(1,1)
        section = ulen(tab[1]) >= ulen(tab[2])
        --section = get_line_pattern(adornchar):match(tab[1]) ~= nil and section
        str = string.strip(tab[2])
    else -- no overline
        adornchar = tab[2]:sub(1,1)
        section = ulen(tab[1]) <= ulen(tab[2])
        --section = get_line_pattern(adornchar):match(tab[2]) ~= nil and section
        str = tab[1]
    end

    if section then -- determine level
        local level = rst_context.last_section_level
        local rca = rst_context.collected_adornments
        if rca[adornchar] then
            level = rca[adornchar]
        else
            level = level + 1
            rca[adornchar] = level
            rst_context.last_section_level = level
        end

        ref = get_context_reference (str)

        str = string.format("\n\\\\%s[%s]{%s}\n", sectionlevels[level], ref, str)
    else
        return [[{\\bf fix your sectioning!}\\endgraf}]]
    end

    return section and str or ""
end

-- Prime time for the fancybreak module.
function rst_context.transition (str)
    rst_context.addsetups("breaks")
    --return "\\fancybreak\n"
    return "\\fancybreak{$* * *$}\n"
end

function rst_context.bullet_marker(str)
    return "marker"
end

-- This one should ignore escaped spaces.
do
    local stripper = P{
        [1] = "stripper",
        stripper = V"space"^0 * C((V"space"^0 * V"nospace"^1)^0),
        space    = S(" \t\v\n"),
        escaped  = P"\\" * V"space",
        nospace  = V"escaped" + (1 - V"space"),
    }
    function string.strip(str)
        return stripper:match(str) or ""
    end 
end

local enumeration_types = {
    ["*"] = "*", -- unordered bulleted
    ["+"] = "*",
    ["-"] = "*",
    ["•"] = "*",
    ["‣"] = "*",
    ["⁃"] = "*",

    ["#"] = "n", -- numbered lists and conversion
    ["A"] = "A",
    ["a"] = "a",
    ["I"] = "R",
    ["i"] = "r",
}

-- \setupitemize[left=(, right=), margin=4em, stopper=]

local stripme   = S"()."
local dontstrip = 1 - stripme
local itemstripper = stripme^0 * C(dontstrip^1) * stripme^0

local function parse_itemstring(str)
    local offset = nil
    local setup = ",fit][itemalign=flushright,"
    -- string.match is slightly faster than string.find
    if str:match("^%(") then
        setup = setup .. [[left=(,]]
    end
    if str:match("%)$") then
        setup = setup .. [[right=)]]
    end
    if str:match("%.$") then
        setup = setup .. [[stopper={.\\space}]]
    end
    setup = setup

    str = itemstripper:match(str)
    str = enumeration_types[str] or str
    if str:match("^%d") then
        offset = tonumber(str:match("^%d+")) - 1
        str = "n"
    end
    return {setup = setup, str = str, offset = offset}
end

function rst_context.startitemize(str)
    local setup = ""
    local result = ""
    local offset
    str = string.strip(str)

    local listtype = enumeration_types[str] or parse_itemstring(str)

    if type(listtype) == "table" then
        --print(type(listtype), listtype[2])
        setup = listtype.setup
        offset = listtype.offset
        listtype = listtype.str
    end

    result = [[
\\startitemize[]] .. listtype .. setup .. [[]
]] 
    if offset then
        result = result .. [[

\\setnumber[itemgroup:itemize]{]] .. offset .. [[}
]]
    end
    return result
end

function rst_context.stopitemize(str)
    return str .. [[
\\stopitemize
]]
end

function rst_context.bullet_item (str)
    return [[

\\item ]] .. inline_parser:match(str) .. [[

]]
end

--------------------------------------------------------------------------------
-- Definition lists 
--------------------------------------------------------------------------------
-- TODO define proper setups (probably bnf-like and some narrower for def-paragraphs)

function rst_context.deflist (list)
    rst_context.addsetups("deflist")

    local deflist = [[
\\startRSTdefinitionlist
]] 
    for nd, item in ipairs(list) do
        print(#item)
        local term = item[1]
        local nc = 2
        local tmp = [[

  \\RSTdeflistterm{]] .. string.strip(term) .. "}"
        if #item > 2 then
            while nc < #item do
                tmp = tmp .. [[

  \\RSTdeflistclassifier{]] .. string.strip(item[nc]) .. "}"
                nc = nc + 1
            end
        end
        tmp = tmp .. [[

  \\RSTdeflistdefinition{%
]]
        for np, par in ipairs(item[#item]) do -- definitions, multi-paragraph
            tmp = tmp .. [[
    \\RSTdeflistparagraph{%
]] .. inline_parser:match(par) .. "}\n"
        end
        tmp = tmp .. "  }"
        deflist = deflist .. tmp
    end
    return deflist .. [[

\\stopRSTdefinitionlist
]]
end

--------------------------------------------------------------------------------
-- Field lists
--------------------------------------------------------------------------------

-- TODO Do something useful with field lists. For now I'm not sure what as the
-- bibliography directives from the reST specification seem to make sense only
-- when using docinfo and, after all, we have .bib files that are portable.

function rst_context.field_list (str)
    return [[

\\startfieldlist]] .. str .. [[\\stopfieldlist
]]
end

function rst_context.field_name (str)
    return [[\\fieldname{]] .. str .. [[}]]
end

function rst_context.field_body (str)
    return [[\\fieldbody{]] .. str .. [[}]]
end

function rst_context.field (tab)
    local name, body = tab[1], tab[2]
    return string.format([[

  \\startfield
    \\fieldname{%s}
    \\fieldbody{%s}
  \\stopfield
]], name, inline_parser:match(body))
end

function rst_context.line_comment (str)
    print(">>"..str.."<<")
    return "% " .. str
end

function rst_context.block_comment (str)
    print(">>"..str.."<<")
    return string.format([[

\iffalse
%s\fi
]], str)
end

function rst_context.option_list (str)
    return [[
\\setupTABLE[c][first] [background=color, backgroundcolor=grey, style=\tt]
\\setupTABLE[c][each]  [frame=off]
\\setupTABLE[r][each]  [frame=off]
\\bTABLE[split=yes,option=stretch]
\\bTABLEhead
\\bTR
  \\bTH  Option \\eTH
  \\bTH  Description \\eTH
\\eTR
\\eTABLEhead
\\bTABLEbody
]] .. inline_parser:match(str) .. [[

\\eTABLEbody
\\eTABLE
]]
end

function rst_context.option_item (tab)
    return string.format([[\\bTR\\bTC %s \\eTC\\bTC %s \\eTC\\eTR
]], tab[1], tab[2])
end

function rst_context.test(str)
    print("This:>>"..str.."<<")
    return ":"
end

function rst_context.literal_block (str, included)
    local indent = P" "^1
    local stripme = indent:match(str) or 0

    local strip = P{
        [1] = "strip",
        strip = Cs(V"line"^1),
        eol = P"\n",
        restofline = (1 - V"eol")^0,
        stop = Cs(V"eol" * P" "^0) * -P(1) / "", -- remove trailing blank lines
        line = Cs(V"restofline" * (V"stop" + V"eol")) / function (line)
            return #line > stripme and line:sub(stripme) or line
        end,
    }

    str = strip:match(str)
    str = [[

\starttyping[lines=hyphenated]
]] .. str .. [[

\stoptyping
]]
    if included then -- escaping can ruin your day
        return str:gsub("\\", "\\\\")
    else
        return str
    end
end

function rst_context.included_literal_block (str)
    return rst_context.literal_block(str, true)
end

function rst_context.line_block (str)
    rst_context.addsetups("lines")
    return [[

\\startlines
]] .. inline_parser:match(str) .. [[\\stoplines
]]
end

function rst_context.line_block_line(str)
    str = str:gsub("\n", " ")
    return str .. "\n"
end

function rst_context.line_block_empty()
    return "\n"
end

function rst_context.block_quote (tab)
    rst_context.addsetups("blockquote")
    local str = [[
\\startlinecorrection
\\blank[small]
\\startblockquote
]] .. inline_parser:match(tab[1]) .. [[

\\stopblockquote
]]

    return tab[2] and str .. [[
\\blank[small]
\\startattribution
]] .. inline_parser:match(tab[2]) .. [[
\\stopattribution
\\blank[small]
\\stoplinecorrection
]]  or str .. [[
\\blank[small]
\\stoplinecorrection
]] 
end

--function rst_context.table (str)
    --return [[
--\\startlinecorrection
--]] .. str .. [[

--\\stoplinecorrection
--]]
--end

function rst_context.grid_table (tab)
    local body = ""
    local nr = 1
    local head
    if tab.has_head then
        head = [[
\\setupTABLE[c][each]  [frame=off]
\\setupTABLE[r][each]  [frame=off]
%\\startlinecorrection
\\bTABLE[split=repeat,option=stretch]
\\bTABLEhead
]]
        while nr <= tab.head_end do
            local r = tab.rows[nr]
        --for i,r in ipairs(tab.rows) do
            local isempty = true
            for n, cell in ipairs(r) do
                if cell.variant == "normal" then
                    isempty = false
                    break
                end
            end

            if not isempty then
                local row = [[\\bTR]]
                for n,c in ipairs(r) do
                    if not (c.parent or
                            c.variant == "separator") then
                        local celltext = inline_parser:match(c.stripped)
                        if c.span.x or c.span.y then
                            local span_exp = "["
                            if c.span.x then
                                span_exp = span_exp .. "nc=" .. c.span.x .. ","
                            end
                            if c.span.y then
                                span_exp = span_exp .. "nr=" .. c.span.y
                            end
                            celltext  = span_exp .. "] " .. celltext

                        end

                        row = row .. "\n  " .. [[\\bTH ]] .. celltext .. [[\\eTH]]
                    end
                end
                head = head .. row .. "\n" .. [[\\eTR]] .. "\n"
            end
            nr = nr + 1
        end
        head = head .. [[
\\eTABLEhead
\\bTABLEbody
]] 
    else
        head = [[
\\setupTABLE[c][each]  [frame=off]
\\setupTABLE[r][each]  [frame=off]
%\\startlinecorrection
\\bTABLE[split=repeat,option=stretch]
\\bTABLEbody
]] 
    end
    while nr <= #tab.rows do
        local r = tab.rows[nr]
    --for i,r in ipairs(tab.rows) do
        local isempty = true
        for n, cell in ipairs(r) do
            if cell.variant == "normal" then
                isempty = false
                break
            end
        end

        if not isempty then
            local row = [[\\bTR]]
            for n,c in ipairs(r) do
                if not (c.parent or
                        c.variant == "separator") then
                    local celltext = inline_parser:match(c.stripped)
                    if c.span.x or c.span.y then
                        local span_exp = "["
                        if c.span.x then
                            span_exp = span_exp .. "nc=" .. c.span.x .. ","
                        end
                        if c.span.y then
                            span_exp = span_exp .. "nr=" .. c.span.y
                        end
                        celltext  = span_exp .. "] " .. celltext

                    end

                    row = row .. "\n  " .. [[\\bTC ]] .. celltext .. [[\\eTC]]
                end
            end
            body = body .. row .. "\n" .. [[\\eTR]] .. "\n"
        end
        nr = nr + 1
    end
    local tail = [[
\\eTABLEbody
\\eTABLE
%\\stoplinecorrection
]]
    return head .. body .. tail
end


function rst_context.simple_table(tab)
    local head
    local nr = 1
    if tab.head_end then
        head = [[
\\setupTABLE[c][each]  [frame=off]
\\setupTABLE[r][each]  [frame=off]
%\\startlinecorrection
\\bTABLE[split=yes,option=stretch]
\\bTABLEhead
]]
        while nr <= tab.head_end do
            local row = tab[nr]
            if not row.ignore then
                dbg_write(">hr>" .. #row)
                head = head .. [[\\bTR]]
                for nc,cell in ipairs(row) do
                    dbg_write("%7s | ", cell.content)
                    local celltext = inline_parser:match(cell.content)
                    if cell.span then
                        head = head .. string.format([=[\\bTH[nc=%s]%s\\eTH]=], cell.span.x, celltext)
                    else
                        head = head .. [[\\bTH ]] .. celltext .. [[\\eTH]]
                    end
                end
                dbg_write("\n")
                head = head .. "\\\\eTR\n"
            end
            nr = nr + 1
        end

        head = head .. [[
\\eTABLEhead
\\bTABLEbody
]] 
    else
        head = [[
\\setupTABLE[c][each]  [frame=off]
\\setupTABLE[r][each]  [frame=off]
%\\startlinecorrection
\\bTABLE[split=yes,option=stretch]
\\bTABLEbody
]] 
    end
    local tail = [[
\\eTABLEbody
\\eTABLE
%\\stoplinecorrection
]]
    local body = ""
    while nr <= #tab do
        local row = tab[nr]
        if not row.ignore then
            dbg_write(">tr>" .. #row)
            body = body .. [[\\bTR]]
            for nc,cell in ipairs(row) do
                dbg_write("%7s | ", cell.content)
                local celltext = inline_parser:match(cell.content)
                if cell.span then
                    body = body .. string.format([=[\\bTC[nc=%s]%s\\eTC]=], cell.span.x, celltext)
                else
                    body = body .. [[\\bTC ]] .. celltext .. [[\\eTC]]
                end
            end
            dbg_write("\n")
            body = body .. "\\\\eTR\n"
        end
        nr = nr + 1
    end
    return head .. body .. tail
end

function rst_context.footnote (label, content)
    local tf = state.footnotes
    rst_context.addsetups("footnotes")
    if label:match("^%d+$") then -- all digits
        tf.numbered[tonumber(label)] = rst_context.escape(inline_parser:match(content))
    elseif label == "#" then --autonumber
        repeat -- until next unrequested number
            tf.autonumber = tf.autonumber + 1
        until tf.numbered[tf.autonumber] == nil
        tf.numbered[tf.autonumber] = rst_context.escape(inline_parser:match(content))
    elseif label:match("^#.+$") then
        local thelabel = label:match("^#(.+)$")
        tf.autolabel[thelabel] = rst_context.escape(inline_parser:match(content))
    elseif label == "*" then
        rst_context.addsetups("footnote_symbol")
        tf.symbol[#tf.symbol+1] = rst_context.escape(inline_parser:match(content))
    else -- “citation reference” treated like ordinary footnote
        repeat -- until next unrequested number
            tf.autonumber = tf.autonumber + 1
        until tf.numbered[tf.autonumber] == nil
        tf.numbered[tf.autonumber] = rst_context.escape(inline_parser:match(content))
    end
    return ""
end

function rst_context.substitution_definition (subtext, directive, data)
    data = table.concat(data, "\n")
    print(subtext,directive,data)
    local rs = rst_context.substitutions
    rs[subtext] = { directive = directive, data = data }
    return ""
end

optional_setups = {}
function optional_setups.footnote_symbol ()
    local setup = [[
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Footnotes with symbol conversion                              %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\definenote[symbolnote][footnote]
\setupnote [symbolnote][way=bypage,numberconversion=set 2]
]]
    return setup
end

function optional_setups.footnotes ()
    local tf = state.footnotes
    local fn = [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Footnotes                                                     %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
]]
    local buffer = [[

%% %s
\startbuffer[%s]
%s\stopbuffer
]]
    
    for nf, note in next, tf.numbered do
        fn = fn .. string.format(buffer, "Autonumbered footnote", "__footnote_number_"..nf, note)
    end
    for nf, note in next, tf.autolabel do
        fn = fn .. string.format(buffer, "Labeled footnote", "__footnote_label_"..nf, note)
    end
    for nf, note in next, tf.symbol do
        fn = fn .. string.format(buffer, "Symbol footnote", "__footnote_symbol_"..nf, note)
    end
    return fn
end

function optional_setups.references ()
    local refs = rst_context.collected_references
    local function resolve_indirect (r)
        if r and r:match(".*_$") then -- pointing elsewhere
            --print(">>"..r.."<<",">>"..r:match("^`?([^`]*)`?_$").."<<", refs[r:match("^`?([^`]*)`?_$")])
            return resolve_indirect (refs[r:match("^`?([^`]*)`?_$")]) or "need another run!" -- TODO multiple runs && data collection
        end
        return r
    end

    local refsection = [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% References                                                    %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

]]
    local references = {}
    local ref_keys = {}
    for ref, target in next, refs do
        ref_keys[#ref_keys+1] = [[__target_]] .. rst_context.whitespace_to_underscore(ref)
        target = resolve_indirect(target)
        references[#references+1] = string.format([[
\useURL[__target_%s] [%s] []   [%s] ]], rst_context.whitespace_to_underscore(ref), target, ref)
    end
    refsection = refsection .. table.concat(references, "\n")
    -- this is needed in order to select the right reference command later
    refsection = refsection .. "\n\n" .. [[\def\RSTexternalreferences{]] .. table.concat(ref_keys, ",") .. [[}

% #1 target name, #2 link text
\def\RSTchoosegoto#1#2{%
  \rawdoifinsetelse{#1}{\RSTexternalreferences}
    {\from[#1]}
    {\goto{#2}[#1]}
}
]]

    return refsection
end

--------------------------------------------------------------------------------
-- Directives for use with |substitutions|
--------------------------------------------------------------------------------

rst_context.directives = {}
rst_context.directives.images_done = {}

rst_context.directives.image = function(name, data)
    local img = ""
    local images_done = rst_context.directives.images_done
    if not images_done[name] then
        img = img .. string.format([[

\useexternalfigure[%s][%s][]
]], name, data)
    images_done[name] = true
    end
    img = img .. string.format([[
\def\RSTsubstitution%s{
  \placefigure[here]{%s}{\externalfigure[%s]}
}
]], name, name, name)
    return img
end

rst_context.directives.ctx = function(name, data)
    local ctx = string.format([[

\startbuffer[%s]
%s
\stopbuffer
\def\RSTsubstitution%s{
  \getbuffer[%s]
}
]], name, data, name, name)
    return ctx
end

rst_context.directives.lua = function(name, data)
    local luacode = string.format([[

\startbuffer[%s]
\startluacode
%s
\stopluacode
\stopbuffer
\def\RSTsubstitution%s{%%
  \getbuffer[%s]%%
}
]], name, data, name, name)
    return luacode
end

rst_context.directives.replace = function(name, data)
    return string.format([[

\def\RSTsubstitution%s{%s}
]], name, data)
end

function optional_setups.substitutions ()
    local directives = rst_context.directives
    local substitutions = [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Substitutions                                                 %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
]]
    local rs = rst_context.substitutions
    for name, content in next, rs do
        local directive, data = content.directive, content.data
        name, data = name:gsub("%s", ""), string.strip(data)
        substitutions = substitutions .. directives[directive](name, data)
    end
    return substitutions
end

function optional_setups.blockquote ()
    return [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Blockquotes                                                   %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\setupdelimitedtext  [blockquote][style={\tfx}] % awful placeholder
\definedelimitedtext[attribution][blockquote]
\setupdelimitedtext [attribution][style={\tfx\it}]
]]
end

function optional_setups.deflist ()
    return [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Definitionlist                                                %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\def\startRSTdefinitionlist{
  \bgroup
  \def      \RSTdeflistterm##1{{\bf ##1}}
  \def\RSTdeflistclassifier##1{\hbox to 1em{\it ##1}}
  \def\RSTdeflistdefinition##1{%
    \startnarrower[left]
    ##1%
    \stopnarrower}
  \def\RSTdeflistparagraph ##1{%
    \startparagraph{%
      \noindentation ##1
    \stopparagraph}
  }
}

\let\stopRSTdefinitionlist\egroup
]]
end

function optional_setups.lines ()
    return [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Lines environment (line blocks)                               %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\setuplines[%
  space=on,%
  before={\startlinecorrection\blank[small]},%
  after={\blank[small]\stoplinecorrection},%
]
]]
end

function optional_setups.breaks ()
    return [[

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Fancy transitions                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\usemodule[fancybreak]
\setupfancybreak[symbol=star]
]]
end

return rst_context