X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Freport.git;a=blobdiff_plain;f=pret-lam.lua;h=41ffbc7f779b28f28e188a38669dd0c3ecad8c4a;hp=ea07811759ae40920b5ef4d6a4f8e174a3e3fa1f;hb=03068992fa44475f901eb34cec49f2a2304b473f;hpb=1864c65fe74e332c5aca3ccb9878b98aa1aa93e7 diff --git a/pret-lam.lua b/pret-lam.lua index ea07811..41ffbc7 100644 --- a/pret-lam.lua +++ b/pret-lam.lua @@ -6,7 +6,7 @@ local utf = unicode.utf8 -vis = buffers.newvisualizer("lam") +local vis = buffers.newvisualizer("lam") local colors = { "prettytwo", @@ -17,24 +17,47 @@ local colors = { -- Symbols that should have a different representation local symbols = { - [' '] = {repr = '\\obs '}, + -- Note, the space we replace with is a Unicode non-breaking space + -- (U+00A0). + [' '] = {repr = ' '}, ['_'] = {repr = '\\_'}, - ['->'] = {repr = '\\rightarrow'}, + ['->'] = {repr = '→'}, + ['=>'] = {repr = '⇒'}, -- The default * sits very high above the baseline, \ast (u+2217) looks -- better. ['*'] = {repr = '\\ast'}, - ['~'] = {repr = '\\sim'}, + ['~'] = {repr = '\\HDLine[width=.20 * \\the\\textwidth]'}, + ['|'] = {repr = '\\char' .. utf.byte('|')}, + -- Use ▶ from our roman font, since Iwona doesn't have the glyph + ['▶'] = {repr = '{\\rm{}▶}'}, } - -- Keywords that should be bold local keywords = { ['case'] = {}, ['of'] = {}, ['let'] = {}, + ['letrec'] = {}, + ['letnonrec'] = {}, ['in'] = {}, + ['DEFAULT'] = {small = true}, } +local in_block = 0 +local submatches = {} +local bases = {} +-- Store the last line for each indent level +local indentlines = {} + +function array_concat(a1, a2) + local res = a1 + for k,v in ipairs(a2) do + table.insert(res, v) + end + return res +end + + -- See if str starts with a symbol, and return the remaining string and that -- symbol. If no symbol from the table is matched, just returns the first -- character. We can do a lookup directly, since symbols can be different in @@ -95,55 +118,162 @@ local function do_subscripts(word) submatches[#submatches+1] = "^(" .. base .. ")([%a%d])$" -- Seconde, the base with a longer prefix that includes at least -- one of +-, (to catch things like ri+1, but not return). - submatches[#submatches+1] = "^(" .. base .. ")([%a%d]*[%-%+%,]+[%a%d%-%+%,]*)$" + submatches[#submatches+1] = "^(" .. base .. ")([%a%d]*[%-%+,]+[%a%d%-%+,]*)$" end end return word end +-- Do proper aligning for subsequent lines. For example, in +-- foo = bar +-- | baz +-- We replace the spaces in the second line with a skip with the same with as +-- "foo ", to align the | with the =. +-- For this, we keep a table "indentlines", which contains all previous lines +-- with smaller indent levels that are still "in scope" (e.g., have not yet +-- been followed by a line with a smaller indent level). For example: +-- line1 +-- line2 +-- line3 +-- line4 +-- line5 +-- After the last line, the table will contain: +-- { 0 = "line1", 2 = " line4", 4 = " line5"} +-- In other words, line3 is no longer in scope since it is "hidden" by +-- line4, and line is no longer in scope since it is replaced by line4. +local function do_indent(line) + newind, rest = utf.match(line, '^(%s*)(.*)') + prev = -1 + -- Loop all the previous lines + for indent, unused in pairs(indentlines) do + if indent > #newind then + -- Remove any lines with a larger indent + indentlines[indent] = nil + elseif indent < #newind and indent > prev then + -- Find the last line (e.g, with the highest indent) with an + -- indent smaller than the new indent. This is the line from which + -- we need to copy the indent. + prev = indent + end + end + + -- Always store this line, possibly overwriting a previous line with the + -- same indent + indentlines[#newind] = line + + if prev ~= -1 then + -- If there is a previous line with a smaller indent, make sure we + -- align with it. We do this by taking a prefix from that previous + -- line just as long as our indent. This gives us a bunch of + -- whitespace, with a few non-whitespace characters. We find out the + -- width of this prefix, and put whitespace just as wide as that + -- prefix before the current line, instead of the whitespace + -- characters that were there. + -- Doing this is slightly risky, since the prefix might contain + -- unfinished markup (e.g., \foo{bar without the closing }). We might + -- need to solve this later. + copyind = utf.sub(indentlines[prev], 1, #newind) + setwidth = "\\setwidthof{" .. copyind .. "}\\to\\pretlamalignwidth" + hskip = "\\hskip\\pretlamalignwidth" + print("{" .. setwidth .. hskip .. "}" .. rest) + return "{" .. setwidth .. hskip .. "}" .. rest + end + -- No previous line? Just return the unmodified line then + return line +end + + +-- Mark the begin of a block of lambda formatted buffers or expressions. This +-- means that, until you call end_of_block again, the subscript bases are +-- shared. For example, if you have \lam{y1} some text \lam{yn} within a +-- single block, the yn will properly get subscripted. Be sure to call +-- end_of_block again! +-- +-- Blocks can be partially nested, meaning that the block +-- won't be closed until end_of_block was called exactly as often as +-- begin_of_block. However, subscripts from the inner block can still +-- influence subscripts in the outer block. +function vis.begin_of_block() + vis.begin_of_display() + in_block = in_block + 1 +end + +-- Ends the current block +function vis.end_of_block() + in_block = in_block - 1 +end + function vis.begin_of_display() - -- Initially allow subscripts using _ or just appending a number (later, - -- we will add extra patterns here. - submatches = {"^(%a*)_([%a%d,]+)$", "^(%a+)(%d+)$"} - -- This stores all the bases we've encountered so far (to prevent - -- duplicates). For each of them there will be a pattern in submatches - -- above. - bases = {} + if in_block == 0 then + -- Initially allow subscripts using _ or just appending a number (later, + -- we will add extra patterns here. + submatches = {"^(%a*)_([%a%d,]+)$", "^(%a+)(%d[%d,]+)$"} + -- This stores all the bases we've encountered so far (to prevent + -- duplicates). For each of them there will be a pattern in submatches + -- above. + bases = {} + end + indentlines = {} end + -- Make things work for inline typeing (e.g., \type{}) as well. vis.begin_of_inline = vis.begin_of_display vis.end_of_inline = vis.end_of_display function vis.flush_line(str,nested) - local result, state = { }, 0 - local finish, change = buffers.finish_state, buffers.change_state - -- Set the colorscheme, which is used by finish_state and change_state - buffers.currentcolors = colors + buffers.flush_result(vis.do_line(str, false), nested) +end + +function vis.do_line(str, no_indent) + result = {} + if not no_indent then + -- Allow ignore of the indentation stuff when we're calling ourselves + -- for a partial line. + str = do_indent(str) + end while str ~= "" do local found = false local word, symbol - -- See if the next token is a word - word, str = take_word(str) - if word then - if keywords[res] then - -- Make all keywords bold - word = "{\\bold " .. word .. "}" + local text, rest = utf.match(str, "^%-%-(.-)%-%-(.*)") + if text then + table.insert(result, '\\strikethrough{') + -- Recursively call ourselves to handle spaces gracefully. + result = array_concat(result, vis.do_line(text, true)) + table.insert(result, '}') + -- Eat the processed characters + str = rest + elseif utf.match(str, "^%-%-") then + table.insert(result, '{\\italic{--') + -- Recursively call ourselves to handle spaces gracefully. + result = array_concat(result, vis.do_line(utf.sub(str, 3), true)) + table.insert(result, '}}') + -- Done with this line + str = '' + else + -- See if the next token is a word + word, str = take_word(str) + if word then + if keywords[res] then + -- Make all keywords bold + word = "{\\bold " .. word .. "}" + if keywords[res].small then + word = "\\small" .. word -- Curlies were added above + end + else + -- Process any subscripts in the word + word = do_subscripts(word) + end + table.insert(result, word) else - -- Process any subscripts in the word - word = do_subscripts(word) + -- The next token is not a word, it must be a symbol + symbol, str = take_symbol(str) + table.insert(result, symbol) end - else - -- The next token is not a word, it must be a symbol - symbol, str = take_symbol(str) end - - -- Append the resulting token - result[#result+1] = word or symbol end - state = finish(state, result) - buffers.flush_result(result,nested) + return result end -- vim: set sw=4 sts=4 expandtab ai: