9302844829

Committed 30 May 2024 12:51PM UTC coverage: 74.707% (+1.7%) from 73.034%

Build # 9302844829

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1931 from alerque/stylua

Run Details

156 of 166 new or added lines in 4 files covered. (93.98%)

1 existing line in 1 file now uncovered.

11939 of 15981 relevant lines covered (74.71%)

7260.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.64

/packages/math/texlike.lua

local syms = require("packages.math.unicode-symbols")
local bits = require("core.parserbits")

local epnf = require("epnf")
local lpeg = require("lpeg")

local atomType = syms.atomType
local symbolDefaults = syms.symbolDefaults
local symbols = syms.symbols

-- Grammar to parse TeX-like math
-- luacheck: push ignore
-- stylua: ignore start
---@diagnostic disable: undefined-global, unused-local, lowercase-global
local mathGrammar = function (_ENV)
   local _ = WS^0
   local eol = S"\r\n"
   local digit = R("09")
   local natural = digit^1 / tostring
   local pos_natural = R("19") * digit^0 / tonumber
   local ctrl_word = R("AZ", "az")^1
   local ctrl_symbol = P(1) - S"{}\\"
   local ctrl_sequence_name = C(ctrl_word + ctrl_symbol) / 1
   local comment = (
         P"%" *
         P(1-eol)^0 *
         eol^-1
      )
   local utf8cont = R("\128\191")
   local utf8code = lpeg.R("\0\127")
      + lpeg.R("\194\223") * utf8cont
      + lpeg.R("\224\239") * utf8cont * utf8cont
      + lpeg.R("\240\244") * utf8cont * utf8cont * utf8cont
   -- Identifiers inside \mo and \mi tags
   local sileID = C(bits.identifier + P(1)) / 1
   local mathMLID = (utf8code - S"\\{}%")^1 / function (...)
         local ret = ""
         local t = {...}
         for _,b in ipairs(t) do
         ret = ret .. b
         end
         return ret
      end
   local group = P"{" * V"mathlist" * (P"}" + E("`}` expected"))
   local element_no_infix =
      V"def" +
      V"command" +
      group +
      V"argument" +
      V"atom"
   local element =
      V"supsub" +
      V"subsup" +
      V"sup" +
      V"sub" +
      element_no_infix
   local sep = S",;" * _
   local quotedString = (P'"' * C((1-P'"')^1) * P'"')
   local value = ( quotedString + (1-S",;]")^1 )
   local pair = Cg(sileID * _ * "=" * _ * C(value)) * sep^-1 / function (...)
      local t = {...}; return t[1], t[#t]
   end
   local list = Cf(Ct"" * pair^0, rawset)
   local parameters = (
         P"[" *
         list *
         P"]"
      )^-1 / function (a)
            return type(a)=="table" and a or {}
         end
   local dim2_arg_inner = Ct(V"mathlist" * (P"&" * V"mathlist")^0) /
      function (t)
         t.id = "mathlist"
         return t
      end
   local dim2_arg =
      Cg(P"{" *
         dim2_arg_inner *
         (P"\\\\" * dim2_arg_inner)^1 *
         (P"}" + E("`}` expected"))
         ) / function (...)
            local t = {...}
            -- Remove the last mathlist if empty. This way,
            -- `inner1 \\ inner2 \\` is the same as `inner1 \\ inner2`.
            if not t[#t][1] or not t[#t][1][1] then table.remove(t) end
            return pl.utils.unpack(t)
         end

   START "texlike_math"
   texlike_math = V"mathlist" * EOF"Unexpected character at end of math code"
   mathlist = (comment + (WS * _) + element)^0
   supsub = element_no_infix * _ * P"^" * _ * element_no_infix * _ *
      P"_" * _ * element_no_infix
   subsup = element_no_infix * _ * P"_" * _ * element_no_infix * _ *
      P"^" * _ * element_no_infix
   sup = element_no_infix * _ * P"^" * _ * element_no_infix
   sub = element_no_infix * _ * P"_" * _ * element_no_infix
   atom = natural + C(utf8code - S"\\{}%^_&") +
      (P"\\{" + P"\\}") / function (s) return string.sub(s, -1) end
   command = (
         P"\\" *
         Cg(ctrl_sequence_name, "command") *
         Cg(parameters, "options") *
         (dim2_arg + group^0)
      )
   def = P"\\def" * _ * P"{" *
      Cg(ctrl_sequence_name, "command-name") * P"}" * _ *
      --P"[" * Cg(digit^1, "arity") * P"]" * _ *
      P"{" * V"mathlist" * P"}"
   argument = P"#" * Cg(pos_natural, "index")
end
-- luacheck: pop
-- stylua: ignore end
---@diagnostic enable: undefined-global, unused-local, lowercase-global

local mathParser = epnf.define(mathGrammar)

local commands = {}

-- A command type is a type for each argument it takes: either string or MathML
-- tree. If a command has no type, it is assumed to take only trees.
-- Tags like <mi>, <mo>, <mn> take a string, and this needs to be propagated in
-- commands that use them.

local objType = {
  tree = 1,
  str = 2
}

local function inferArgTypes_aux (accumulator, typeRequired, body)
  if type(body) == "table" then
    if body.id == "argument" then
      local ret = accumulator
      table.insert(ret, body.index, typeRequired)
      return ret
    elseif body.id == "command" then
      if commands[body.command] then
        local cmdArgTypes = commands[body.command][1]
        if #cmdArgTypes ~= #body then
          SU.error("Wrong number of arguments (" .. #body ..
            ") for command " .. body.command .. " (should be " ..
            #cmdArgTypes .. ")")
        else
          for i = 1, #cmdArgTypes do
            accumulator = inferArgTypes_aux(accumulator, cmdArgTypes[i], body[i])
          end
        end
        return accumulator
      elseif body.command == "mi" or body.command == "mo" or body.command == "mn" then
        if #body ~= 1 then
          SU.error("Wrong number of arguments ("..#body..") for command "..
            body.command.." (should be 1)")
        end
        accumulator = inferArgTypes_aux(accumulator, objType.str, body[1])
        return accumulator
      else
        -- Not a macro, recurse on children assuming tree type for all
        -- arguments
        for _, child in ipairs(body) do
          accumulator = inferArgTypes_aux(accumulator, objType.tree, child)
        end
        return accumulator
      end
    elseif body.id == "atom" then
      return accumulator
    else
      -- Simply recurse on children
      for _, child in ipairs(body) do
        accumulator = inferArgTypes_aux(accumulator, typeRequired, child)
      end
      return accumulator
    end
  else SU.error("invalid argument to inferArgTypes_aux") end
end

local inferArgTypes = function (body)
  return inferArgTypes_aux({}, objType.tree, body)
end

local function registerCommand (name, argTypes, func)
  commands[name] = { argTypes, func }
end

-- Computes func(func(... func(init, k1, v1), k2, v2)..., k_n, v_n), i.e. applies
-- func on every key-value pair in the table. Keys with numeric indices are
-- processed in order. This is an important property for MathML compilation below.
local function fold_pairs (func, table)
  local accumulator = {}
  for k, v in pl.utils.kpairs(table) do
    accumulator = func(v, k, accumulator)
  end
  for i, v in ipairs(table) do
    accumulator = func(v, i, accumulator)
  end
  return accumulator
end

local function forall (pred, list)
  for _,x in ipairs(list) do
    if not pred(x) then return false end
  end
  return true
end

local compileToStr = function (argEnv, mathlist)
  if #mathlist == 1 and mathlist.id == "atom" then
    -- List is a single atom
    return mathlist[1]
  elseif #mathlist == 1 and mathlist[1].id == "argument" then
    return argEnv[mathlist[1].index]
  elseif mathlist.id == "argument" then
    return argEnv[mathlist.index]
  else
    local ret = ""
    for _,elt in ipairs(mathlist) do
      if elt.id == "atom" then
        ret = ret .. elt[1]
      elseif elt.id == "command" and symbols[elt.command] then
        ret = ret .. symbols[elt.command]
      else
        SU.error("Encountered non-character token in command that takes a string")
      end
    end
    return ret
  end
end

local function compileToMathML_aux (_, arg_env, tree)
  if type(tree) == "string" then return tree end
  local function compile_and_insert (child, key, accumulator)
    if type(key) ~= "number" then
      accumulator[key] = child
      return accumulator
    -- Compile all children, except if this node is a macro definition (no
    -- evaluation "under lambda") or the application of a registered macro
    -- (since evaluating the nodes depends on the macro's signature, it is more
    -- complex and done below)..
    elseif tree.id == "def" or (tree.id == "command" and commands[tree.command]) then
      -- Conserve unevaluated child
      table.insert(accumulator, child)
    else
      -- Compile next child
      local comp = compileToMathML_aux(nil, arg_env, child)
      if comp then
        if comp.id == "wrapper" then
          -- Insert all children of the wrapper node
          for _, inner_child in ipairs(comp) do
            table.insert(accumulator, inner_child)
          end
        else
          table.insert(accumulator, comp)
        end
      end
    end
    return accumulator
  end
  tree = fold_pairs(compile_and_insert, tree)
  if tree.id == "texlike_math" then
    tree.command = "math"
    -- If the outermost `mrow` contains only other `mrow`s, remove it
    -- (allowing vertical stacking).
    if forall(function (c) return c.command == "mrow" end, tree[1]) then
      tree[1].command = "math"
      return tree[1]
    end
  elseif tree.id == "mathlist" then
    -- Turn mathlist into `mrow` except if it has exactly one `mtr` or `mtd`
    -- child.
    -- Note that `def`s have already been compiled away at this point.
    if #tree == 1 and (tree[1].command == "mtr" or tree[1].command == "mtd") then
      return tree[1]
    else tree.command = "mrow" end
    tree.command = "mrow"
  elseif tree.id == "atom" then
    local codepoints = {}
    for _, cp in luautf8.codes(tree[1]) do
      table.insert(codepoints, cp)
    end
    local cp = codepoints[1]
    if #codepoints == 1 and ( -- If length of UTF-8 string is 1
       cp >= SU.codepoint("A") and cp <= SU.codepoint("Z") or
       cp >= SU.codepoint("a") and cp <= SU.codepoint("z") or
       cp >= SU.codepoint("Α") and cp <= SU.codepoint("Ω") or
       cp >= SU.codepoint("α") and cp <= SU.codepoint("ω")
    ) then
        tree.command = "mi"
    elseif lpeg.match(lpeg.R("09")^1, tree[1]) then
      tree.command = "mn"
    else
      tree.command = "mo"
    end
    tree.options = {}
  -- Translate TeX-like sub/superscripts to `munderover` or `msubsup`,
  -- depending on whether the base is a big operator
  elseif tree.id == "sup" and tree[1].command == "mo"
      and tree[1].atom == atomType.bigOperator then
    tree.command = "mover"
  elseif tree.id == "sub" and tree[1].command == "mo"
      and symbolDefaults[tree[1][1]].atom == atomType.bigOperator then
      tree.command = "munder"
  elseif tree.id == "subsup" and tree[1].command == "mo"
      and symbolDefaults[tree[1][1]].atom == atomType.bigOperator then
    tree.command = "munderover"
  elseif tree.id == "supsub" and tree[1].command == "mo"
      and symbolDefaults[tree[1][1]].atom == atomType.bigOperator then
    tree.command = "munderover"
    local tmp = tree[2]
    tree[2] = tree[3]
    tree[3] = tmp
  elseif tree.id == "sup" then
    tree.command = "msup"
  elseif tree.id == "sub" then
      tree.command = "msub"
  elseif tree.id == "subsup" then
    tree.command = "msubsup"
  elseif tree.id == "supsub" then
    tree.command = "msubsup"
    local tmp = tree[2]
    tree[2] = tree[3]
    tree[3] = tmp
  elseif tree.id == "def" then
    local commandName = tree["command-name"]
    local argTypes = inferArgTypes(tree[1])
    registerCommand(commandName, argTypes, function (compiledArgs)
      return compileToMathML_aux(nil, compiledArgs, tree[1])
    end)
    return nil
  elseif tree.id == "command" and commands[tree.command] then
    local argTypes = commands[tree.command][1]
    local cmdFun = commands[tree.command][2]
    local applicationTree = tree
    local cmdName = tree.command
    if #applicationTree ~= #argTypes then
      SU.error("Wrong number of arguments (" .. #applicationTree ..
        ") for command " .. cmdName .. " (should be " ..
        #argTypes .. ")")
    end
    -- Compile every argument
    local compiledArgs = {}
    for i,arg in pairs(applicationTree) do
      if type(i) == "number" then
        if argTypes[i] == objType.tree then
          table.insert(compiledArgs, compileToMathML_aux(nil, arg_env, arg))
        else
          local x = compileToStr(arg_env, arg)
          table.insert(compiledArgs, x)
        end
      else
        -- Not an argument but an attribute. Add it to the compiled
        -- argument tree as-is
        compiledArgs[i] = applicationTree[i]
      end
    end
    local res = cmdFun(compiledArgs)
    if res.command == "mrow" then
      -- Mark the outer mrow to be unwrapped in the parent
      res.id = "wrapper"
    end
    return res
  elseif tree.id == "command" and symbols[tree.command] then
    local atom = {id = "atom", [1] = symbols[tree.command]}
    tree = compileToMathML_aux(nil, arg_env, atom)
  elseif tree.id == "argument" then
    if arg_env[tree.index] then
      return arg_env[tree.index]
    else
      SU.error("Argument #"..tree.index.." has escaped its scope (probably not fully applied command).")
    end
  end
  tree.id = nil
  return tree
end

local function printMathML (tree)
  if type(tree) == "string" then
    return tree
  end
  local result = "\\" .. tree.command
  if tree.options then
    local options = {}
    for k,v in pairs(tree.options) do
      table.insert(options, k .. "=" .. v)
    end
    if #options > 0 then
      result = result .. "[" .. table.concat(options, ", ") .. "]"
    end
  end
  if #tree > 0 then
    result = result .. "{"
    for _, child in ipairs(tree) do
      result = result .. printMathML(child)
    end
    result = result .. "}"
  end
  return result
end

local function compileToMathML (_, arg_env, tree)
  local result = compileToMathML_aux(_, arg_env, tree)
  SU.debug("texmath", function ()
    return "Resulting MathML: " .. printMathML(result)
  end)
  return result
end

local function convertTexlike (_, content)
  local ret = epnf.parsestring(mathParser, content[1])
  SU.debug("texmath", function ()
    return "Parsed TeX math: " .. pl.pretty.write(ret)
  end)
  return ret
end

registerCommand("%", {}, function ()
  return { "%", command = "mo", options = {} }
end)
registerCommand("mi", { [1] = objType.str }, function (x) return x end)
registerCommand("mo", { [1] = objType.str }, function (x) return x end)
registerCommand("mn", { [1] = objType.str }, function (x) return x end)

compileToMathML(nil, {}, convertTexlike(nil, {[==[
  \def{frac}{\mfrac{#1}{#2}}
  \def{bi}{\mi[mathvariant=bold-italic]{#1}}
  \def{dsi}{\mi[mathvariant=double-struck]{#1}}

  % Standard spaces gleaned from plain TeX
  \def{thinspace}{\mspace[width=thin]}
  \def{negthinspace}{\mspace[width=-thin]}
  \def{,}{\thinspace}
  \def{!}{\negthinspace}
  \def{medspace}{\mspace[width=med]}
  \def{negmedspace}{\mspace[width=-med]}
  \def{>}{\medspace}
  \def{thickspace}{\mspace[width=thick]}
  \def{negthickspace}{\mspace[width=-thick]}
  \def{;}{\thickspace}
  \def{enspace}{\mspace[width=1en]}
  \def{enskip}{\enspace}
  \def{quad}{\mspace[width=1em]}
  \def{qquad}{\mspace[width=2em]}

  % Modulus operator forms
  \def{bmod}{\mo{mod}}
  \def{pmod}{\quad(\mo{mod} #1)}
]==]}))

return { convertTexlike, compileToMathML }

1	local syms = require("packages.math.unicode-symbols")	12✔
2	local bits = require("core.parserbits")	12✔
3
4	local epnf = require("epnf")	12✔
5	local lpeg = require("lpeg")	12✔
6
7	local atomType = syms.atomType	12✔
8	local symbolDefaults = syms.symbolDefaults	12✔
9	local symbols = syms.symbols	12✔
10
11	-- Grammar to parse TeX-like math
12	-- luacheck: push ignore
13	-- stylua: ignore start
14	---@diagnostic disable: undefined-global, unused-local, lowercase-global
15	local mathGrammar = function (_ENV)
16	local _ = WS^0	12✔
17	local eol = S"\r\n"	12✔
18	local digit = R("09")	12✔
19	local natural = digit^1 / tostring	12✔
20	local pos_natural = R("19") * digit^0 / tonumber	12✔
21	local ctrl_word = R("AZ", "az")^1	12✔
22	local ctrl_symbol = P(1) - S"{}\\"	12✔
23	local ctrl_sequence_name = C(ctrl_word + ctrl_symbol) / 1	12✔
24	local comment = (
25	P"%" *	12✔
26	P(1-eol)^0 *	12✔
27	eol^-1	12✔
28	)
29	local utf8cont = R("\128\191")	12✔
30	local utf8code = lpeg.R("\0\127")	12✔
31	+ lpeg.R("\194\223") * utf8cont	12✔
32	+ lpeg.R("\224\239") * utf8cont * utf8cont	12✔
33	+ lpeg.R("\240\244") * utf8cont * utf8cont * utf8cont	12✔
34	-- Identifiers inside \mo and \mi tags
35	local sileID = C(bits.identifier + P(1)) / 1	12✔
36	local mathMLID = (utf8code - S"\\{}%")^1 / function (...)	12✔
NEW 37	local ret = ""	×
NEW 38	local t = {...}	×
NEW 39	for _,b in ipairs(t) do	×
NEW 40	ret = ret .. b	×
41	end
NEW 42	return ret	×
43	end
44	local group = P"{" * V"mathlist" * (P"}" + E("`}` expected"))	24✔
45	local element_no_infix =
46	V"def" +	12✔
47	V"command" +	12✔
48	group +	12✔
49	V"argument" +	12✔
50	V"atom"	12✔
51	local element =
52	V"supsub" +	12✔
53	V"subsup" +	12✔
54	V"sup" +	12✔
55	V"sub" +	12✔
56	element_no_infix	12✔
57	local sep = S",;" * _	12✔
58	local quotedString = (P'"' * C((1-P'"')^1) * P'"')	12✔
59	local value = ( quotedString + (1-S",;]")^1 )	12✔
60	local pair = Cg(sileID * _ * "=" * _ * C(value)) * sep^-1 / function (...)	12✔
61	local t = {...}; return t[1], t[#t]	161✔
62	end
63	local list = Cf(Ct"" * pair^0, rawset)	12✔
64	local parameters = (
65	P"[" *	12✔
66	list *	12✔
67	P"]"	12✔
68	)^-1 / function (a)	12✔
69	return type(a)=="table" and a or {}	491✔
70	end
71	local dim2_arg_inner = Ct(V"mathlist" * (P"&" * V"mathlist")^0) /	12✔
72	function (t)
73	t.id = "mathlist"	16✔
74	return t	16✔
75	end
76	local dim2_arg =
77	Cg(P"{" *	24✔
78	dim2_arg_inner *	12✔
79	(P"\\\\" * dim2_arg_inner)^1 *	12✔
80	(P"}" + E("`}` expected"))	24✔
NEW 81	) / function (...)	×
82	local t = {...}	4✔
83	-- Remove the last mathlist if empty. This way,
84	-- `inner1 \\ inner2 \\` is the same as `inner1 \\ inner2`.
85	if not t[#t][1] or not t[#t][1][1] then table.remove(t) end	4✔
86	return pl.utils.unpack(t)	4✔
87	end
88
89	START "texlike_math"	12✔
90	texlike_math = V"mathlist" * EOF"Unexpected character at end of math code"	24✔
91	mathlist = (comment + (WS * _) + element)^0	12✔
92	supsub = element_no_infix * _ * P"^" * _ * element_no_infix * _ *	12✔
93	P"_" * _ * element_no_infix	12✔
94	subsup = element_no_infix * _ * P"_" * _ * element_no_infix * _ *	12✔
95	P"^" * _ * element_no_infix	12✔
96	sup = element_no_infix * _ * P"^" * _ * element_no_infix	12✔
97	sub = element_no_infix * _ * P"_" * _ * element_no_infix	12✔
98	atom = natural + C(utf8code - S"\\{}%^_&") +	12✔
99	(P"\\{" + P"\\}") / function (s) return string.sub(s, -1) end	12✔
NEW 100	command = (	×
101	P"\\" *	12✔
102	Cg(ctrl_sequence_name, "command") *	12✔
103	Cg(parameters, "options") *	12✔
104	(dim2_arg + group^0)	12✔
105	)	12✔
106	def = P"\\def" * _ * P"{" *	12✔
107	Cg(ctrl_sequence_name, "command-name") * P"}" * _ *	12✔
108	--P"[" * Cg(digit^1, "arity") * P"]" * _ *
109	P"{" * V"mathlist" * P"}"	12✔
110	argument = P"#" * Cg(pos_natural, "index")	12✔
111	end
112	-- luacheck: pop
113	-- stylua: ignore end
114	---@diagnostic enable: undefined-global, unused-local, lowercase-global
115
116	local mathParser = epnf.define(mathGrammar)	12✔
117
118	local commands = {}	12✔
119
120	-- A command type is a type for each argument it takes: either string or MathML
121	-- tree. If a command has no type, it is assumed to take only trees.
122	-- Tags like <mi>, <mo>, <mn> take a string, and this needs to be propagated in
123	-- commands that use them.
124
125	local objType = {	12✔
126	tree = 1,
127	str = 2	×
128	}
129
130	local function inferArgTypes_aux (accumulator, typeRequired, body)
131	if type(body) == "table" then	736✔
132	if body.id == "argument" then	736✔
133	local ret = accumulator	66✔
134	table.insert(ret, body.index, typeRequired)	66✔
135	return ret	66✔
136	elseif body.id == "command" then	670✔
137	if commands[body.command] then	248✔
138	local cmdArgTypes = commands[body.command][1]	127✔
139	if #cmdArgTypes ~= #body then	127✔
140	SU.error("Wrong number of arguments (" .. #body ..	×
141	") for command " .. body.command .. " (should be " ..	×
142	#cmdArgTypes .. ")")	×
143	else
144	for i = 1, #cmdArgTypes do	182✔
145	accumulator = inferArgTypes_aux(accumulator, cmdArgTypes[i], body[i])	110✔
146	end
147	end
148	return accumulator	127✔
149	elseif body.command == "mi" or body.command == "mo" or body.command == "mn" then	121✔
150	if #body ~= 1 then	×
151	SU.error("Wrong number of arguments ("..#body..") for command "..	×
152	body.command.." (should be 1)")	×
153	end
154	accumulator = inferArgTypes_aux(accumulator, objType.str, body[1])	×
155	return accumulator	×
156	else
157	-- Not a macro, recurse on children assuming tree type for all
158	-- arguments
159	for _, child in ipairs(body) do	147✔
160	accumulator = inferArgTypes_aux(accumulator, objType.tree, child)	52✔
161	end
162	return accumulator	121✔
163	end
164	elseif body.id == "atom" then	422✔
165	return accumulator	104✔
166	else
167	-- Simply recurse on children
168	for _, child in ipairs(body) do	738✔
169	accumulator = inferArgTypes_aux(accumulator, typeRequired, child)	840✔
170	end
171	return accumulator	318✔
172	end
173	else SU.error("invalid argument to inferArgTypes_aux") end	×
174	end
175
176	local inferArgTypes = function (body)
177	return inferArgTypes_aux({}, objType.tree, body)	235✔
178	end
179
180	local function registerCommand (name, argTypes, func)
181	commands[name] = { argTypes, func }	283✔
182	end
183
184	-- Computes func(func(... func(init, k1, v1), k2, v2)..., k_n, v_n), i.e. applies
185	-- func on every key-value pair in the table. Keys with numeric indices are
186	-- processed in order. This is an important property for MathML compilation below.
187	local function fold_pairs (func, table)
188	local accumulator = {}	1,439✔
189	for k, v in pl.utils.kpairs(table) do	11,827✔
190	accumulator = func(v, k, accumulator)	7,510✔
191	end
192	for i, v in ipairs(table) do	3,435✔
193	accumulator = func(v, i, accumulator)	3,992✔
194	end
195	return accumulator	1,439✔
196	end
197
198	local function forall (pred, list)
199	for _,x in ipairs(list) do	57✔
200	if not pred(x) then return false end	90✔
201	end
202	return true	12✔
203	end
204
205	local compileToStr = function (argEnv, mathlist)
206	if #mathlist == 1 and mathlist.id == "atom" then	114✔
207	-- List is a single atom
208	return mathlist[1]	×
209	elseif #mathlist == 1 and mathlist[1].id == "argument" then	114✔
210	return argEnv[mathlist[1].index]	3✔
211	elseif mathlist.id == "argument" then	111✔
212	return argEnv[mathlist.index]	×
213	else
214	local ret = ""	111✔
215	for _,elt in ipairs(mathlist) do	443✔
216	if elt.id == "atom" then	332✔
217	ret = ret .. elt[1]	332✔
218	elseif elt.id == "command" and symbols[elt.command] then	×
219	ret = ret .. symbols[elt.command]	×
220	else
221	SU.error("Encountered non-character token in command that takes a string")	×
222	end
223	end
224	return ret	111✔
225	end
226	end
227
228	local function compileToMathML_aux (_, arg_env, tree)
229	if type(tree) == "string" then return tree end	1,847✔
230	local function compile_and_insert (child, key, accumulator)
231	if type(key) ~= "number" then	5,751✔
232	accumulator[key] = child	3,755✔
233	return accumulator	3,755✔
234	-- Compile all children, except if this node is a macro definition (no
235	-- evaluation "under lambda") or the application of a registered macro
236	-- (since evaluating the nodes depends on the macro's signature, it is more
237	-- complex and done below)..
238	elseif tree.id == "def" or (tree.id == "command" and commands[tree.command]) then	1,996✔
239	-- Conserve unevaluated child
240	table.insert(accumulator, child)	386✔
241	else
242	-- Compile next child
243	local comp = compileToMathML_aux(nil, arg_env, child)	1,610✔
244	if comp then	1,610✔
245	if comp.id == "wrapper" then	1,375✔
246	-- Insert all children of the wrapper node
247	for _, inner_child in ipairs(comp) do	184✔
248	table.insert(accumulator, inner_child)	94✔
249	end
250	else
251	table.insert(accumulator, comp)	1,285✔
252	end
253	end
254	end
255	return accumulator	1,996✔
256	end
257	tree = fold_pairs(compile_and_insert, tree)	2,878✔
258	if tree.id == "texlike_math" then	1,439✔
259	tree.command = "math"	57✔
260	-- If the outermost `mrow` contains only other `mrow`s, remove it
261	-- (allowing vertical stacking).
262	if forall(function (c) return c.command == "mrow" end, tree[1]) then	159✔
263	tree[1].command = "math"	12✔
264	return tree[1]	12✔
265	end
266	elseif tree.id == "mathlist" then	1,382✔
267	-- Turn mathlist into `mrow` except if it has exactly one `mtr` or `mtd`
268	-- child.
269	-- Note that `def`s have already been compiled away at this point.
270	if #tree == 1 and (tree[1].command == "mtr" or tree[1].command == "mtd") then	306✔
271	return tree[1]	×
272	else tree.command = "mrow" end	306✔
273	tree.command = "mrow"	306✔
274	elseif tree.id == "atom" then	1,076✔
275	local codepoints = {}	408✔
276	for _, cp in luautf8.codes(tree[1]) do	828✔
277	table.insert(codepoints, cp)	420✔
278	end
279	local cp = codepoints[1]	408✔
280	if #codepoints == 1 and ( -- If length of UTF-8 string is 1	408✔
281	cp >= SU.codepoint("A") and cp <= SU.codepoint("Z") or	963✔
282	cp >= SU.codepoint("a") and cp <= SU.codepoint("z") or	945✔
283	cp >= SU.codepoint("Α") and cp <= SU.codepoint("Ω") or	630✔
284	cp >= SU.codepoint("α") and cp <= SU.codepoint("ω")	624✔
285	) then	×
286	tree.command = "mi"	131✔
287	elseif lpeg.match(lpeg.R("09")^1, tree[1]) then	277✔
288	tree.command = "mn"	108✔
289	else
290	tree.command = "mo"	169✔
291	end
292	tree.options = {}	408✔
293	-- Translate TeX-like sub/superscripts to `munderover` or `msubsup`,
294	-- depending on whether the base is a big operator
295	elseif tree.id == "sup" and tree[1].command == "mo"	668✔
296	and tree[1].atom == atomType.bigOperator then	×
297	tree.command = "mover"	×
298	elseif tree.id == "sub" and tree[1].command == "mo"	668✔
299	and symbolDefaults[tree[1][1]].atom == atomType.bigOperator then	5✔
300	tree.command = "munder"	1✔
301	elseif tree.id == "subsup" and tree[1].command == "mo"	667✔
302	and symbolDefaults[tree[1][1]].atom == atomType.bigOperator then	10✔
303	tree.command = "munderover"	8✔
304	elseif tree.id == "supsub" and tree[1].command == "mo"	659✔
305	and symbolDefaults[tree[1][1]].atom == atomType.bigOperator then	×
306	tree.command = "munderover"	×
307	local tmp = tree[2]	×
308	tree[2] = tree[3]	×
309	tree[3] = tmp	×
310	elseif tree.id == "sup" then	659✔
311	tree.command = "msup"	14✔
312	elseif tree.id == "sub" then	645✔
313	tree.command = "msub"	32✔
314	elseif tree.id == "subsup" then	613✔
315	tree.command = "msubsup"	6✔
316	elseif tree.id == "supsub" then	607✔
317	tree.command = "msubsup"	×
318	local tmp = tree[2]	×
319	tree[2] = tree[3]	×
320	tree[3] = tmp	×
321	elseif tree.id == "def" then	607✔
322	local commandName = tree["command-name"]	235✔
323	local argTypes = inferArgTypes(tree[1])	235✔
324	registerCommand(commandName, argTypes, function (compiledArgs)	470✔
325	return compileToMathML_aux(nil, compiledArgs, tree[1])	90✔
326	end)
327	return nil	235✔
328	elseif tree.id == "command" and commands[tree.command] then	372✔
329	local argTypes = commands[tree.command][1]	202✔
330	local cmdFun = commands[tree.command][2]	202✔
331	local applicationTree = tree	202✔
332	local cmdName = tree.command	202✔
333	if #applicationTree ~= #argTypes then	202✔
334	SU.error("Wrong number of arguments (" .. #applicationTree ..	×
335	") for command " .. cmdName .. " (should be " ..	×
336	#argTypes .. ")")	×
337	end
338	-- Compile every argument
339	local compiledArgs = {}	202✔
340	for i,arg in pairs(applicationTree) do	1,161✔
341	if type(i) == "number" then	959✔
342	if argTypes[i] == objType.tree then	151✔
343	table.insert(compiledArgs, compileToMathML_aux(nil, arg_env, arg))	74✔
344	else
345	local x = compileToStr(arg_env, arg)	114✔
346	table.insert(compiledArgs, x)	114✔
347	end
348	else
349	-- Not an argument but an attribute. Add it to the compiled
350	-- argument tree as-is
351	compiledArgs[i] = applicationTree[i]	808✔
352	end
353	end
354	local res = cmdFun(compiledArgs)	202✔
355	if res.command == "mrow" then	202✔
356	-- Mark the outer mrow to be unwrapped in the parent
357	res.id = "wrapper"	90✔
358	end
359	return res	202✔
360	elseif tree.id == "command" and symbols[tree.command] then	170✔
361	local atom = {id = "atom", [1] = symbols[tree.command]}	53✔
362	tree = compileToMathML_aux(nil, arg_env, atom)	106✔
363	elseif tree.id == "argument" then	117✔
364	if arg_env[tree.index] then	37✔
365	return arg_env[tree.index]	37✔
366	else
367	SU.error("Argument #"..tree.index.." has escaped its scope (probably not fully applied command).")	×
368	end
369	end
370	tree.id = nil	953✔
371	return tree	953✔
372	end
373
374	local function printMathML (tree)
375	if type(tree) == "string" then	×
376	return tree	×
377	end
378	local result = "\\" .. tree.command	×
379	if tree.options then	×
380	local options = {}	×
381	for k,v in pairs(tree.options) do	×
382	table.insert(options, k .. "=" .. v)	×
383	end
384	if #options > 0 then	×
385	result = result .. "[" .. table.concat(options, ", ") .. "]"	×
386	end
387	end
388	if #tree > 0 then	×
389	result = result .. "{"	×
390	for _, child in ipairs(tree) do	×
391	result = result .. printMathML(child)	×
392	end
393	result = result .. "}"	×
394	end
395	return result	×
396	end
397
398	local function compileToMathML (_, arg_env, tree)
399	local result = compileToMathML_aux(_, arg_env, tree)	57✔
400	SU.debug("texmath", function ()	114✔
401	return "Resulting MathML: " .. printMathML(result)	×
402	end)
403	return result	57✔
404	end
405
406	local function convertTexlike (_, content)
407	local ret = epnf.parsestring(mathParser, content[1])	57✔
408	SU.debug("texmath", function ()	114✔
409	return "Parsed TeX math: " .. pl.pretty.write(ret)	×
410	end)
411	return ret	57✔
412	end
413
414	registerCommand("%", {}, function ()	24✔
415	return { "%", command = "mo", options = {} }	1✔
416	end)
417	registerCommand("mi", { [1] = objType.str }, function (x) return x end)	103✔
418	registerCommand("mo", { [1] = objType.str }, function (x) return x end)	31✔
419	registerCommand("mn", { [1] = objType.str }, function (x) return x end)	13✔
420
421	compileToMathML(nil, {}, convertTexlike(nil, {[==[	24✔
422	\def{frac}{\mfrac{#1}{#2}}
423	\def{bi}{\mi[mathvariant=bold-italic]{#1}}
424	\def{dsi}{\mi[mathvariant=double-struck]{#1}}
425
426	% Standard spaces gleaned from plain TeX
427	\def{thinspace}{\mspace[width=thin]}
428	\def{negthinspace}{\mspace[width=-thin]}
429	\def{,}{\thinspace}
430	\def{!}{\negthinspace}
431	\def{medspace}{\mspace[width=med]}
432	\def{negmedspace}{\mspace[width=-med]}
433	\def{>}{\medspace}
434	\def{thickspace}{\mspace[width=thick]}
435	\def{negthickspace}{\mspace[width=-thick]}
436	\def{;}{\thickspace}
437	\def{enspace}{\mspace[width=1en]}
438	\def{enskip}{\enspace}
439	\def{quad}{\mspace[width=1em]}
440	\def{qquad}{\mspace[width=2em]}
441
442	% Modulus operator forms
443	\def{bmod}{\mo{mod}}
444	\def{pmod}{\quad(\mo{mod} #1)}
445	]==]}))
446
447	return { convertTexlike, compileToMathML }	12✔

sile-typesetter / sile / 9302844829

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous