@@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30Types and functions for conversion of OMML into TeXMath.
30Types and functions for conversion of OMML into TeXMath.
33−module Text.Pandoc.Readers.Docx.OMath ( elemToExps
33+module Text.Pandoc.Readers.Docx.OMath ( elemToExps
36import Text.XML.Light
36import Text.XML.Light
@@ -39,16 +39,19 @@ import Data.List (intersperse)
39import qualified Text.TeXMath.Types as TM
39import qualified Text.TeXMath.Types as TM
40import Control.Applicative ((<$>))
40import Control.Applicative ((<$>))
42−type NameSpaces = [(String, String)]
44−elemName :: NameSpaces -> String -> String -> QName
45−elemName ns prefix name = (QName name (lookup prefix ns) (Just prefix))
47−isElem :: NameSpaces -> String -> String -> Element -> Bool
42+isElem :: String -> String -> Element -> Bool
48−isElem ns prefix name element =
43+isElem prefix name element =
44+ let qp = fromMaybe "" (qPrefix (elName element))
49− qName (elName element) == name &&
46+ qName (elName element) == name &&
50− qURI (elName element) == (lookup prefix ns)
47+ qp == prefix
49+hasElemName:: String -> String -> QName -> Bool
50+hasElemName prefix name qn =
51+ let qp = fromMaybe "" (qPrefix qn)
53data OMath = OMath [OMathElem]
56data OMath = OMath [OMathElem]
54 deriving Show
57 deriving Show
@@ -143,15 +146,15 @@ data GroupStyle = GroupStyle { groupChr :: Maybe Char
143defaultGroupStyle :: GroupStyle
146defaultGroupStyle :: GroupStyle
144defaultGroupStyle = GroupStyle {groupChr = Nothing, groupPos = Nothing}
147defaultGroupStyle = GroupStyle {groupChr = Nothing, groupPos = Nothing}
146−elemToMath :: NameSpaces -> Element -> Maybe OMath
149+elemToMath :: Element -> Maybe OMath
147−elemToMath ns element | isElem ns "m" "oMath" element =
150+elemToMath element | isElem "m" "oMath" element =
148− Just $ OMath $ mapMaybe (elemToMathElem ns) (elChildren element)
151+ Just $ OMath $ mapMaybe (elemToMathElem) (elChildren element)
149−elemToMath _ _ = Nothing
152+elemToMath _ = Nothing
151−elemToBase :: NameSpaces -> Element -> Maybe Base
154+elemToBase :: Element -> Maybe Base
152−elemToBase ns element | isElem ns "m" "e" element =
155+elemToBase element | isElem "m" "e" element =
153− Just $ Base $ mapMaybe (elemToMathElem ns) (elChildren element)
156+ Just $ Base $ mapMaybe (elemToMathElem) (elChildren element)
154−elemToBase _ _ = Nothing
157+elemToBase _ = Nothing
156-- TODO: The right way to do this is to use the ampersand to break the
159-- TODO: The right way to do this is to use the ampersand to break the
157-- text lines into multiple columns. That's tricky, though, and this
160-- text lines into multiple columns. That's tricky, though, and this
@@ -164,38 +167,38 @@ filterAmpersand (OMathRun mrPr elems) =
164 OMathRun mrPr (map f elems)
167 OMathRun mrPr (map f elems)
165filterAmpersand e = e
168filterAmpersand e = e
167−elemToBaseNoAmpersand :: NameSpaces -> Element -> Maybe Base
170+elemToBaseNoAmpersand :: Element -> Maybe Base
168−elemToBaseNoAmpersand ns element | isElem ns "m" "e" element =
171+elemToBaseNoAmpersand element | isElem "m" "e" element =
169 return $ Base $
172 return $ Base $
171− (\e -> (elemToMathElem ns e >>= (return . filterAmpersand)))
174+ (\e -> (elemToMathElem e >>= (return . filterAmpersand)))
172 (elChildren element)
175 (elChildren element)
173−elemToBaseNoAmpersand _ _ = Nothing
176+elemToBaseNoAmpersand _ = Nothing
175−elemToOMathRunStyle :: NameSpaces -> Element -> OMathRunStyle
178+elemToOMathRunStyle :: Element -> OMathRunStyle
176−elemToOMathRunStyle ns element =
179+elemToOMathRunStyle element =
177 let lit =
180 let lit =
179− findChild (elemName ns "m" "lit") element >>=
182+ filterChildName (hasElemName"m" "lit") element >>=
180− findAttr (elemName ns "m" "val")
183+ findAttrBy (hasElemName"m" "val")
182 Just "on" -> True
185 Just "on" -> True
183 _ -> False
186 _ -> False
185 OMathRunStyle { oMathLit = lit
188 OMathRunStyle { oMathLit = lit
186− , oMathRunTextStyle = (elemToOMathRunTextStyle ns element)
189+ , oMathRunTextStyle = (elemToOMathRunTextStyle element)
189−elemToOMathRunTextStyle :: NameSpaces -> Element -> OMathRunTextStyle
192+elemToOMathRunTextStyle :: Element -> OMathRunTextStyle
190−elemToOMathRunTextStyle ns element
193+elemToOMathRunTextStyle element
191− | Just mrPr <- findChild (elemName ns "m" "rPr") element
194+ | Just mrPr <- filterChildName (hasElemName"m" "rPr") element
192− , Just _ <- findChild (elemName ns "m" "nor") mrPr =
195+ , Just _ <- filterChildName (hasElemName"m" "nor") mrPr =
194− | Just mrPr <- findChild (elemName ns "m" "rPr") element =
197+ | Just mrPr <- filterChildName (hasElemName"m" "rPr") element =
195 let scr =
198 let scr =
197− findChild (elemName ns "m" "scr") mrPr >>=
200+ filterChildName (hasElemName"m" "scr") mrPr >>=
198− findAttr (elemName ns "m" "val")
201+ findAttrBy (hasElemName"m" "val")
200 Just "roman" -> Just ORoman
203 Just "roman" -> Just ORoman
201 Just "script" -> Just OScript
204 Just "script" -> Just OScript
@@ -207,8 +210,8 @@ elemToOMathRunTextStyle ns element
210− findChild (elemName ns "m" "sty") mrPr >>=
213+ filterChildName (hasElemName"m" "sty") mrPr >>=
211− findAttr (elemName ns "m" "val")
214+ findAttrBy (hasElemName"m" "val")
213 Just "p" -> Just OPlain
216 Just "p" -> Just OPlain
214 Just "b" -> Just OBold
217 Just "b" -> Just OBold
@@ -221,192 +224,192 @@ elemToOMathRunTextStyle ns element
224−elemToNAryStyle :: NameSpaces -> Element -> NAryStyle
227+elemToNAryStyle :: Element -> NAryStyle
225−elemToNAryStyle ns element
228+elemToNAryStyle element
226− | Just narypr <- findChild (QName "naryPr" (lookup "m" ns) (Just "m")) element =
229+ | Just narypr <- filterChildName (hasElemName"m" "naryPr") element =
228− chr = findChild (QName "chr" (lookup "m" ns) (Just "m")) narypr >>=
231+ chr = filterChildName (hasElemName"m" "chr") narypr >>=
229− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
232+ findAttrBy (hasElemName"m" "val") >>=
230 Just . head
233 Just . head
231− limLoc = findChild (QName "limLoc" (lookup "m" ns) (Just "m")) narypr >>=
234+ limLoc = filterChildName (hasElemName"m" "limLoc") narypr >>=
232− findAttr (QName "val" (lookup "m" ns) (Just "m"))
235+ findAttrBy (hasElemName"m" "val")
233 limLoc' = case limLoc of
236 limLoc' = case limLoc of
234 Just "undOver" -> UnderOver
237 Just "undOver" -> UnderOver
235 Just "subSup" -> SubSup
238 Just "subSup" -> SubSup
236 _ -> SubSup
239 _ -> SubSup
238 NAryStyle { nAryChar = chr, nAryLimLoc = limLoc'}
241 NAryStyle { nAryChar = chr, nAryLimLoc = limLoc'}
239−elemToNAryStyle _ _ = defaultNAryStyle
242+elemToNAryStyle _ = defaultNAryStyle
241−elemToDelimStyle :: NameSpaces -> Element -> DelimStyle
244+elemToDelimStyle :: Element -> DelimStyle
242−elemToDelimStyle ns element
245+elemToDelimStyle element
243− | Just dPr <- findChild (QName "dPr" (lookup "m" ns) (Just "m")) element =
246+ | Just dPr <- filterChildName (hasElemName"m" "dPr") element =
244− let begChr = findChild (QName "begChr" (lookup "m" ns) (Just "m")) dPr >>=
247+ let begChr = filterChildName (hasElemName"m" "begChr") dPr >>=
245− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
248+ findAttrBy (hasElemName"m" "val") >>=
246 (\c -> if null c then (Just ' ') else (Just $ head c))
249 (\c -> if null c then (Just ' ') else (Just $ head c))
247− sepChr = findChild (QName "sepChr" (lookup "m" ns) (Just "m")) dPr >>=
250+ sepChr = filterChildName (hasElemName"m" "sepChr") dPr >>=
248− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
251+ findAttrBy (hasElemName"m" "val") >>=
249 (\c -> if null c then (Just ' ') else (Just $ head c))
252 (\c -> if null c then (Just ' ') else (Just $ head c))
250− endChr = findChild (QName "endChr" (lookup "m" ns) (Just "m")) dPr >>=
253+ endChr = filterChildName (hasElemName"m" "endChr") dPr >>=
251− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
254+ findAttrBy (hasElemName"m" "val") >>=
252 (\c -> if null c then (Just ' ') else (Just $ head c))
255 (\c -> if null c then (Just ' ') else (Just $ head c))
254 DelimStyle { delimBegChar = begChr
257 DelimStyle { delimBegChar = begChr
255 , delimSepChar = sepChr
258 , delimSepChar = sepChr
256 , delimEndChar = endChr}
259 , delimEndChar = endChr}
257−elemToDelimStyle _ _ = defaultDelimStyle
260+elemToDelimStyle _ = defaultDelimStyle
259−elemToGroupStyle :: NameSpaces -> Element -> GroupStyle
262+elemToGroupStyle :: Element -> GroupStyle
260−elemToGroupStyle ns element
263+elemToGroupStyle element
261− | Just gPr <- findChild (QName "groupChrPr" (lookup "m" ns) (Just "m")) element =
264+ | Just gPr <- filterChildName (hasElemName"m" "groupChrPr") element =
262− let chr = findChild (QName "chr" (lookup "m" ns) (Just "m")) gPr >>=
265+ let chr = filterChildName (hasElemName"m" "chr") gPr >>=
263− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
266+ findAttrBy (hasElemName"m" "val") >>=
264 Just . head
267 Just . head
265− pos = findChild (QName "pos" (lookup "m" ns) (Just "m")) gPr >>=
268+ pos = filterChildName (hasElemName"m" "pos") gPr >>=
266− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
269+ findAttrBy (hasElemName"m" "val") >>=
267 (\s -> Just $ if s == "top" then Top else Bottom)
270 (\s -> Just $ if s == "top" then Top else Bottom)
269 GroupStyle { groupChr = chr, groupPos = pos }
272 GroupStyle { groupChr = chr, groupPos = pos }
270−elemToGroupStyle _ _ = defaultGroupStyle
273+elemToGroupStyle _ = defaultGroupStyle
272−elemToMathElem :: NameSpaces -> Element -> Maybe OMathElem
275+elemToMathElem :: Element -> Maybe OMathElem
273−elemToMathElem ns element | isElem ns "m" "acc" element = do
276+elemToMathElem element | isElem "m" "acc" element = do
274 let accChar =
277 let accChar =
275− findChild (elemName ns "m" "accPr") element >>=
278+ filterChildName (hasElemName"m" "accPr") element >>=
276− findChild (elemName ns "m" "chr") >>=
279+ filterChildName (hasElemName"m" "chr") >>=
277− findAttr (elemName ns "m" "val") >>=
280+ findAttrBy (hasElemName"m" "val") >>=
278 Just . head
281 Just . head
279 accPr = AccentStyle { accentChar = accChar}
282 accPr = AccentStyle { accentChar = accChar}
280− base <- findChild (elemName ns "m" "e") element >>=
283+ base <- filterChildName (hasElemName"m" "e") element >>=
281− elemToBase ns
284+ elemToBase
282 return $ Accent accPr base
285 return $ Accent accPr base
283−elemToMathElem ns element | isElem ns "m" "bar" element = do
286+elemToMathElem element | isElem "m" "bar" element = do
284− barPr <- findChild (QName "barPr" (lookup "m" ns) (Just "m")) element >>=
287+ barPr <- filterChildName (hasElemName"m" "barPr") element >>=
285− findChild (QName "pos" (lookup "m" ns) (Just "m")) >>=
288+ filterChildName (hasElemName"m" "pos") >>=
286− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
289+ findAttrBy (hasElemName"m" "val") >>=
288 Just $ BarStyle {
291 Just $ BarStyle {
289 barPos = (if s == "bot" then Bottom else Top)
292 barPos = (if s == "bot" then Bottom else Top)
291− base <- findChild (QName "e" (lookup "m" ns) (Just "m")) element >>=
294+ base <- filterChildName (hasElemName"m" "e") element >>=
292− elemToBase ns
295+ elemToBase
293 return $ Bar barPr base
296 return $ Bar barPr base
294−elemToMathElem ns element | isElem ns "m" "box" element =
297+elemToMathElem element | isElem "m" "box" element =
295− findChild (elemName ns "m" "e") element >>=
298+ filterChildName (hasElemName"m" "e") element >>=
296− elemToBase ns >>=
299+ elemToBase >>=
297 (\b -> return $ Box b)
300 (\b -> return $ Box b)
298−elemToMathElem ns element | isElem ns "m" "borderBox" element =
301+elemToMathElem element | isElem "m" "borderBox" element =
299− findChild (elemName ns "m" "e") element >>=
302+ filterChildName (hasElemName"m" "e") element >>=
300− elemToBase ns >>=
303+ elemToBase >>=
301 (\b -> return $ BorderBox b)
304 (\b -> return $ BorderBox b)
302−elemToMathElem ns element | isElem ns "m" "d" element =
305+elemToMathElem element | isElem "m" "d" element =
303− let style = elemToDelimStyle ns element
306+ let style = elemToDelimStyle element
305− return $ Delimiter style $ mapMaybe (elemToBase ns) (elChildren element)
308+ return $ Delimiter style $ mapMaybe (elemToBase) (elChildren element)
306−elemToMathElem ns element | isElem ns "m" "eqArr" element =
309+elemToMathElem element | isElem "m" "eqArr" element =
307− return $ EquationArray $ mapMaybe (elemToBaseNoAmpersand ns) (elChildren element)
310+ return $ EquationArray $ mapMaybe (elemToBaseNoAmpersand) (elChildren element)
308−elemToMathElem ns element | isElem ns "m" "f" element = do
311+elemToMathElem element | isElem "m" "f" element = do
309− num <- findChild (elemName ns "m" "num") element
312+ num <- filterChildName (hasElemName"m" "num") element
310− den <- findChild (elemName ns "m" "den") element
313+ den <- filterChildName (hasElemName"m" "den") element
311− let numElems = mapMaybe (elemToMathElem ns) (elChildren num)
314+ let numElems = mapMaybe (elemToMathElem) (elChildren num)
312− denElems = mapMaybe (elemToMathElem ns) (elChildren den)
315+ denElems = mapMaybe (elemToMathElem) (elChildren den)
313 return $ Fraction numElems denElems
316 return $ Fraction numElems denElems
314−elemToMathElem ns element | isElem ns "m" "func" element = do
317+elemToMathElem element | isElem "m" "func" element = do
315− fName <- findChild (elemName ns "m" "fName") element
318+ fName <- filterChildName (hasElemName"m" "fName") element
316− base <- findChild (elemName ns "m" "e") element >>=
319+ base <- filterChildName (hasElemName"m" "e") element >>=
317− elemToBase ns
320+ elemToBase
318− let fnElems = mapMaybe (elemToMathElem ns) (elChildren fName)
321+ let fnElems = mapMaybe (elemToMathElem) (elChildren fName)
319 return $ Function fnElems base
322 return $ Function fnElems base
320−elemToMathElem ns element | isElem ns "m" "groupChr" element =
323+elemToMathElem element | isElem "m" "groupChr" element =
321− let style = elemToGroupStyle ns element
324+ let style = elemToGroupStyle element
323− findChild (elemName ns "m" "e") element >>=
326+ filterChildName (hasElemName"m" "e") element >>=
324− elemToBase ns >>=
327+ elemToBase >>=
325 (\b -> return $ Group style b)
328 (\b -> return $ Group style b)
326−elemToMathElem ns element | isElem ns "m" "limLow" element = do
329+elemToMathElem element | isElem "m" "limLow" element = do
327− base <- findChild (elemName ns "m" "e") element
330+ base <- filterChildName (hasElemName"m" "e") element
328− >>= elemToBase ns
331+ >>= elemToBase
329− lim <- findChild (elemName ns "m" "lim") element
332+ lim <- filterChildName (hasElemName"m" "lim") element
330− let limElems = mapMaybe (elemToMathElem ns) (elChildren lim)
333+ let limElems = mapMaybe (elemToMathElem) (elChildren lim)
331 return $ LowerLimit base limElems
334 return $ LowerLimit base limElems
332−elemToMathElem ns element | isElem ns "m" "limUpp" element = do
335+elemToMathElem element | isElem "m" "limUpp" element = do
333− base <- findChild (elemName ns "m" "e") element
336+ base <- filterChildName (hasElemName"m" "e") element
334− >>= elemToBase ns
337+ >>= elemToBase
335− lim <- findChild (elemName ns "m" "lim") element
338+ lim <- filterChildName (hasElemName"m" "lim") element
336− let limElems = mapMaybe (elemToMathElem ns) (elChildren lim)
339+ let limElems = mapMaybe (elemToMathElem) (elChildren lim)
337 return $ UpperLimit base limElems
340 return $ UpperLimit base limElems
338−elemToMathElem ns element | isElem ns "m" "m" element = do
341+elemToMathElem element | isElem "m" "m" element = do
339− let rows = findChildren (elemName ns "m" "mr") element
342+ let rows = filterChildrenName (hasElemName"m" "mr") element
340− let bases = mapMaybe (\mr -> mapM (elemToBase ns) (elChildren mr)) rows
343+ let bases = mapMaybe (\mr -> mapM (elemToBase) (elChildren mr)) rows
341 return $ Matrix bases
344 return $ Matrix bases
342−elemToMathElem ns element | isElem ns "m" "nary" element = do
345+elemToMathElem element | isElem "m" "nary" element = do
343− let style = elemToNAryStyle ns element
346+ let style = elemToNAryStyle element
344− sub <- findChild (elemName ns "m" "sub") element >>=
347+ sub <- filterChildName (hasElemName"m" "sub") element >>=
345− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
348+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
346− sup <- findChild (elemName ns "m" "sup") element >>=
349+ sup <- filterChildName (hasElemName"m" "sup") element >>=
347− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
350+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
348− base <- findChild (elemName ns "m" "e") element >>=
351+ base <- filterChildName (hasElemName"m" "e") element >>=
349− elemToBase ns
352+ elemToBase
350 return $ NAry style sub sup base
353 return $ NAry style sub sup base
351−elemToMathElem ns element | isElem ns "m" "rad" element = do
354+elemToMathElem element | isElem "m" "rad" element = do
352− deg <- findChild (elemName ns "m" "deg") element >>=
355+ deg <- filterChildName (hasElemName"m" "deg") element >>=
353− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
356+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
354− base <- findChild (elemName ns "m" "e") element >>=
357+ base <- filterChildName (hasElemName"m" "e") element >>=
355− elemToBase ns
358+ elemToBase
356 return $ Radical deg base
359 return $ Radical deg base
357−elemToMathElem ns element | isElem ns "m" "phant" element = do
360+elemToMathElem element | isElem "m" "phant" element = do
358− base <- findChild (elemName ns "m" "e") element >>=
361+ base <- filterChildName (hasElemName"m" "e") element >>=
359− elemToBase ns
362+ elemToBase
360 return $ Phantom base
363 return $ Phantom base
361−elemToMathElem ns element | isElem ns "m" "sPre" element = do
364+elemToMathElem element | isElem "m" "sPre" element = do
362− sub <- findChild (elemName ns "m" "sub") element >>=
365+ sub <- filterChildName (hasElemName"m" "sub") element >>=
363− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
366+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
364− sup <- findChild (elemName ns "m" "sup") element >>=
367+ sup <- filterChildName (hasElemName"m" "sup") element >>=
365− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
368+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
366− base <- findChild (elemName ns "m" "e") element >>=
369+ base <- filterChildName (hasElemName"m" "e") element >>=
367− elemToBase ns
370+ elemToBase
368 return $ PreSubSuper sub sup base
371 return $ PreSubSuper sub sup base
369−elemToMathElem ns element | isElem ns "m" "sSub" element = do
372+elemToMathElem element | isElem "m" "sSub" element = do
370− base <- findChild (elemName ns "m" "e") element >>=
373+ base <- filterChildName (hasElemName"m" "e") element >>=
371− elemToBase ns
374+ elemToBase
372− sub <- findChild (elemName ns "m" "sub") element >>=
375+ sub <- filterChildName (hasElemName"m" "sub") element >>=
373− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
376+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
374 return $ Sub base sub
377 return $ Sub base sub
375−elemToMathElem ns element | isElem ns "m" "sSubSup" element = do
378+elemToMathElem element | isElem "m" "sSubSup" element = do
376− base <- findChild (elemName ns "m" "e") element >>=
379+ base <- filterChildName (hasElemName"m" "e") element >>=
377− elemToBase ns
380+ elemToBase
378− sub <- findChild (elemName ns "m" "sub") element >>=
381+ sub <- filterChildName (hasElemName"m" "sub") element >>=
379− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
382+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
380− sup <- findChild (elemName ns "m" "sup") element >>=
383+ sup <- filterChildName (hasElemName"m" "sup") element >>=
381− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
384+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
382 return $ SubSuper base sub sup
385 return $ SubSuper base sub sup
383−elemToMathElem ns element | isElem ns "m" "sSup" element = do
386+elemToMathElem element | isElem "m" "sSup" element = do
384− base <- findChild (elemName ns "m" "e") element >>=
387+ base <- filterChildName (hasElemName"m" "e") element >>=
385− elemToBase ns
388+ elemToBase
386− sup <- findChild (elemName ns "m" "sup") element >>=
389+ sup <- filterChildName (hasElemName"m" "sup") element >>=
387− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
390+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
388 return $ Super base sup
391 return $ Super base sup
389−elemToMathElem ns element | isElem ns "m" "r" element = do
392+elemToMathElem element | isElem "m" "r" element = do
390− let mrPr = elemToOMathRunStyle ns element
393+ let mrPr = elemToOMathRunStyle element
391− mrElems <- elemToOMathRunElems ns element
394+ mrElems <- elemToOMathRunElems element
392 return $ OMathRun mrPr mrElems
395 return $ OMathRun mrPr mrElems
393−elemToMathElem _ _ = Nothing
396+elemToMathElem _ = Nothing
395−elemToOMathRunElem :: NameSpaces -> Element -> Maybe OMathRunElem
398+elemToOMathRunElem :: Element -> Maybe OMathRunElem
396−elemToOMathRunElem ns element
399+elemToOMathRunElem element
397− | isElem ns "w" "t" element
400+ | isElem "w" "t" element
398− || isElem ns "m" "t" element
401+ || isElem "m" "t" element
399− || isElem ns "w" "delText" element = Just $ TextRun $ strContent element
402+ || isElem "w" "delText" element = Just $ TextRun $ strContent element
400− | isElem ns "w" "br" element = Just LnBrk
403+ | isElem "w" "br" element = Just LnBrk
401− | isElem ns "w" "tab" element = Just Tab
404+ | isElem "w" "tab" element = Just Tab
402 | otherwise = Nothing
405 | otherwise = Nothing
404−elemToOMathRunElems :: NameSpaces -> Element -> Maybe [OMathRunElem]
407+elemToOMathRunElems :: Element -> Maybe [OMathRunElem]
405−elemToOMathRunElems ns element
408+elemToOMathRunElems element
406− | isElem ns "w" "r" element
409+ | isElem "w" "r" element
407− || isElem ns "m" "r" element =
410+ || isElem "m" "r" element =
408− Just $ mapMaybe (elemToOMathRunElem ns) (elChildren element)
411+ Just $ mapMaybe (elemToOMathRunElem) (elChildren element)
409−elemToOMathRunElems _ _ = Nothing
412+elemToOMathRunElems _ = Nothing
411----- And now the TeXMath Creation
414----- And now the TeXMath Creation
@@ -655,62 +658,62 @@ baseToExp' :: Base -> [TM.Exp]
655baseToExp' (Base mathElems) =
658baseToExp' (Base mathElems) =
656 concatMap oMathElemToExps mathElems
659 concatMap oMathElemToExps mathElems
658−elemToExps :: NameSpaces -> Element -> Maybe [TM.Exp]
661+elemToExps :: Element -> Maybe [TM.Exp]
659−elemToExps ns element = oMathToExps <$> (elemToMath ns element)
662+elemToExps element = oMathToExps <$> (elemToMath element)
662−elemToExps' :: NameSpaces -> Element -> Maybe [TM.Exp]
665+elemToExps' :: Element -> Maybe [TM.Exp]
663−elemToExps' ns element | isElem ns "m" "acc" element = do
666+elemToExps' element | isElem "m" "acc" element = do
664− let chr = findChild (elemName ns "m" "accPr") element >>=
667+ let chr = filterChildName (hasElemName "m" "accPr") element >>=
665− findChild (elemName ns "m" "chr") >>=
668+ filterChildName (hasElemName "m" "chr") >>=
666− findAttr (elemName ns "m" "val") >>=
669+ findAttrBy (hasElemName "m" "val") >>=
667 Just . head
670 Just . head
668 chr' = case chr of
671 chr' = case chr of
669 Just c -> c
672 Just c -> c
670 Nothing -> '\180' -- default to acute.
673 Nothing -> '\180' -- default to acute.
671− baseExp <- findChild (elemName ns "m" "e") element >>=
674+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
672− elemToBase ns >>=
675+ elemToBase >>=
673 (return . baseToExp)
676 (return . baseToExp)
674 return $ [TM.EOver False baseExp (TM.ESymbol TM.Accent [chr'])]
677 return $ [TM.EOver False baseExp (TM.ESymbol TM.Accent [chr'])]
675−elemToExps' ns element | isElem ns "m" "bar" element = do
678+elemToExps' element | isElem "m" "bar" element = do
676− pos <- findChild (elemName ns "m" "barPr") element >>=
679+ pos <- filterChildName (hasElemName "m" "barPr") element >>=
677− findChild (elemName ns "m" "pos") >>=
680+ filterChildName (hasElemName "m" "pos") >>=
678− findAttr (elemName ns "m" "val")
681+ findAttrBy (hasElemName "m" "val")
679− baseExp <- findChild (elemName ns "m" "e") element >>=
682+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
680− elemToBase ns >>=
683+ elemToBase >>=
681 (return . baseToExp)
684 (return . baseToExp)
682 case pos of
685 case pos of
683 "top" -> Just [TM.EOver False baseExp (TM.ESymbol TM.Accent "\175")]
686 "top" -> Just [TM.EOver False baseExp (TM.ESymbol TM.Accent "\175")]
684 "bot" -> Just [TM.EUnder False baseExp (TM.ESymbol TM.Accent "\818")]
687 "bot" -> Just [TM.EUnder False baseExp (TM.ESymbol TM.Accent "\818")]
685 _ -> Nothing
688 _ -> Nothing
686−elemToExps' ns element | isElem ns "m" "box" element = do
689+elemToExps' element | isElem "m" "box" element = do
687− baseExp <- findChild (elemName ns "m" "e") element >>=
690+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
688− elemToBase ns >>=
691+ elemToBase >>=
689 (return . baseToExp)
692 (return . baseToExp)
690 return [baseExp]
693 return [baseExp]
691−elemToExps' ns element | isElem ns "m" "borderBox" element = do
694+elemToExps' element | isElem "m" "borderBox" element = do
692 -- TODO: This needs to be "\\boxed" somehow.
695 -- TODO: This needs to be "\\boxed" somehow.
693− baseExp <- findChild (elemName ns "m" "e") element >>=
696+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
694− elemToBase ns >>=
697+ elemToBase >>=
695 (return . baseToExp)
698 (return . baseToExp)
696 return [baseExp]
699 return [baseExp]
697−elemToExps' ns element | isElem ns "m" "d" element =
700+elemToExps' element | isElem "m" "d" element =
698 let baseExps = mapMaybe
701 let baseExps = mapMaybe
699− (\e -> (elemToBase ns e >>= (return . baseToExp)))
702+ (\e -> (elemToBase e >>= (return . baseToExp)))
700 (elChildren element)
703 (elChildren element)
701 inDelimExps = map Right baseExps
704 inDelimExps = map Right baseExps
702− dPr = findChild (elemName ns "m" "dPr") element
705+ dPr = filterChildName (hasElemName "m" "dPr") element
703 begChr = dPr >>=
706 begChr = dPr >>=
704− findChild (elemName ns "m" "begChr") >>=
707+ filterChildName (hasElemName "m" "begChr") >>=
705− findAttr (elemName ns "m" "val") >>=
708+ findAttrBy (hasElemName "m" "val") >>=
706 (\c -> if null c then (Just ' ') else (Just $ head c))
709 (\c -> if null c then (Just ' ') else (Just $ head c))
707 sepChr = dPr >>=
710 sepChr = dPr >>=
708− findChild (elemName ns "m" "sepChr") >>=
711+ filterChildName (hasElemName "m" "sepChr") >>=
709− findAttr (elemName ns "m" "val") >>=
712+ findAttrBy (hasElemName "m" "val") >>=
710 (\c -> if null c then (Just ' ') else (Just $ head c))
713 (\c -> if null c then (Just ' ') else (Just $ head c))
711 endChr = dPr >>=
714 endChr = dPr >>=
712− findChild (elemName ns "m" "endChr") >>=
715+ filterChildName (hasElemName "m" "endChr") >>=
713− findAttr (elemName ns "m" "val") >>=
716+ findAttrBy (hasElemName "m" "val") >>=
714 (\c -> if null c then (Just ' ') else (Just $ head c))
717 (\c -> if null c then (Just ' ') else (Just $ head c))
715 beg = fromMaybe '(' begChr
718 beg = fromMaybe '(' begChr
716 end = fromMaybe ')' endChr
719 end = fromMaybe ')' endChr
@@ -718,38 +721,38 @@ elemToExps' ns element | isElem ns "m" "d" element =
718 exps = intersperse (Left [sep]) inDelimExps
721 exps = intersperse (Left [sep]) inDelimExps
720 Just [TM.EDelimited [beg] [end] exps]
723 Just [TM.EDelimited [beg] [end] exps]
721−elemToExps' ns element | isElem ns "m" "eqArr" element =
724+elemToExps' element | isElem "m" "eqArr" element =
722− let bases = mapMaybe (elemToBaseNoAmpersand ns) (elChildren element)
725+ let bases = mapMaybe (elemToBaseNoAmpersand) (elChildren element)
723 baseExps = map (\b -> [baseToExp' b]) bases
726 baseExps = map (\b -> [baseToExp' b]) bases
725 return [TM.EArray [] baseExps]
728 return [TM.EArray [] baseExps]
726−elemToExps' ns element | isElem ns "m" "f" element = do
729+elemToExps' element | isElem "m" "f" element = do
727− num <- findChild (elemName ns "m" "num") element
730+ num <- filterChildName (hasElemName "m" "num") element
728− den <- findChild (elemName ns "m" "den") element
731+ den <- filterChildName (hasElemName "m" "den") element
729− let numExp = TM.EGrouped $ concat $ mapMaybe (elemToExps' ns) (elChildren num)
732+ let numExp = TM.EGrouped $ concat $ mapMaybe (elemToExps') (elChildren num)
730− denExp = TM.EGrouped $ concat $ mapMaybe (elemToExps' ns) (elChildren den)
733+ denExp = TM.EGrouped $ concat $ mapMaybe (elemToExps') (elChildren den)
731 return $ [TM.EFraction TM.NormalFrac numExp denExp]
734 return $ [TM.EFraction TM.NormalFrac numExp denExp]
732−elemToExps' ns element | isElem ns "m" "func" element = do
735+elemToExps' element | isElem "m" "func" element = do
733− fName <- findChild (elemName ns "m" "fName") element
736+ fName <- filterChildName (hasElemName "m" "fName") element
734− baseExp <- findChild (elemName ns "m" "e") element >>=
737+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
735− elemToBase ns >>=
738+ elemToBase >>=
736 (return . baseToExp)
739 (return . baseToExp)
737 -- We need a string for the fname, but omml gives it to us as a
740 -- We need a string for the fname, but omml gives it to us as a
738 -- series of oMath elems. We're going to filter out the oMathRuns,
741 -- series of oMath elems. We're going to filter out the oMathRuns,
739 -- which should work for us most of the time.
742 -- which should work for us most of the time.
740 let fnameString = concatMap expToString $
743 let fnameString = concatMap expToString $
741− concat $ mapMaybe (elemToExps' ns) (elChildren fName)
744+ concat $ mapMaybe (elemToExps') (elChildren fName)
742 return [TM.EMathOperator fnameString, baseExp]
745 return [TM.EMathOperator fnameString, baseExp]
743−elemToExps' ns element | isElem ns "m" "groupChr" element = do
746+elemToExps' element | isElem "m" "groupChr" element = do
744− let gPr = findChild (elemName ns "m" "groupChrPr") element
747+ let gPr = filterChildName (hasElemName "m" "groupChrPr") element
745 chr = gPr >>=
748 chr = gPr >>=
746− findChild (elemName ns "m" "chr") >>=
749+ filterChildName (hasElemName "m" "chr") >>=
747− findAttr (elemName ns "m" "val")
750+ findAttrBy (hasElemName "m" "val")
748 pos = gPr >>=
751 pos = gPr >>=
749− findChild (elemName ns "m" "pos") >>=
752+ filterChildName (hasElemName "m" "pos") >>=
750− findAttr (elemName ns "m" "val")
753+ findAttrBy (hasElemName "m" "val")
751− baseExp <- findChild (elemName ns "m" "e") element >>=
754+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
752− elemToBase ns >>=
755+ elemToBase >>=
753 (return . baseToExp)
756 (return . baseToExp)
754 case pos of
757 case pos of
755 Just "top" ->
758 Just "top" ->
@@ -765,48 +768,48 @@ elemToExps' ns element | isElem ns "m" "groupChr" element = do
766 return [TM.EUnder False baseExp (TM.ESymbol TM.Accent [chr'])]
769 return [TM.EUnder False baseExp (TM.ESymbol TM.Accent [chr'])]
767 _ -> Nothing
770 _ -> Nothing
768−elemToExps' ns element | isElem ns "m" "limLow" element = do
771+elemToExps' element | isElem "m" "limLow" element = do
769− baseExp <- findChild (elemName ns "m" "e") element
772+ baseExp <- filterChildName (hasElemName "m" "e") element
770− >>= elemToBase ns
773+ >>= elemToBase
771 >>= (return . baseToExp)
774 >>= (return . baseToExp)
772− limExp <- findChild (elemName ns "m" "lim") element
775+ limExp <- filterChildName (hasElemName "m" "lim") element
773− >>= (\e -> Just $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
776+ >>= (\e -> Just $ concat $ mapMaybe (elemToExps') (elChildren e))
774 >>= (return . TM.EGrouped)
777 >>= (return . TM.EGrouped)
775 return [TM.EUnder True limExp baseExp]
778 return [TM.EUnder True limExp baseExp]
776−elemToExps' ns element | isElem ns "m" "limUpp" element = do
779+elemToExps' element | isElem "m" "limUpp" element = do
777− baseExp <- findChild (elemName ns "m" "e") element
780+ baseExp <- filterChildName (hasElemName "m" "e") element
778− >>= elemToBase ns
781+ >>= elemToBase
779 >>= (return . baseToExp)
782 >>= (return . baseToExp)
780− limExp <- findChild (elemName ns "m" "lim") element
783+ limExp <- filterChildName (hasElemName "m" "lim") element
781− >>= (\e -> Just $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
784+ >>= (\e -> Just $ concat $ mapMaybe (elemToExps') (elChildren e))
782 >>= (return . TM.EGrouped)
785 >>= (return . TM.EGrouped)
783 return [TM.EOver True limExp baseExp]
786 return [TM.EOver True limExp baseExp]
784−elemToExps' ns element | isElem ns "m" "m" element =
787+elemToExps' element | isElem "m" "m" element =
785− let rows = findChildren (elemName ns "m" "mr") element
788+ let rows = filterChildrenName (hasElemName "m" "mr") element
786 rowExps = map
789 rowExps = map
787 (\mr -> mapMaybe
790 (\mr -> mapMaybe
788− (\e -> (elemToBase ns e >>= return . baseToExp'))
791+ (\e -> (elemToBase e >>= return . baseToExp'))
789 (elChildren mr))
792 (elChildren mr))
792 return [TM.EArray [TM.AlignCenter] rowExps]
795 return [TM.EArray [TM.AlignCenter] rowExps]
793−elemToExps' ns element | isElem ns "m" "nary" element = do
796+elemToExps' element | isElem "m" "nary" element = do
794− let naryPr = findChild (elemName ns "m" "naryPr") element
797+ let naryPr = filterChildName (hasElemName "m" "naryPr") element
795 naryChr = naryPr >>=
798 naryChr = naryPr >>=
796− findChild (elemName ns "m" "chr") >>=
799+ filterChildName (hasElemName "m" "chr") >>=
797− findAttr (elemName ns "m" "val")
800+ findAttrBy (hasElemName "m" "val")
798 opChr = case naryChr of
801 opChr = case naryChr of
799 Just (c:_) -> c
802 Just (c:_) -> c
800 _ -> '\8747' -- default to integral
803 _ -> '\8747' -- default to integral
801 limLoc = naryPr >>=
804 limLoc = naryPr >>=
802− findChild (elemName ns "m" "limLoc") >>=
805+ filterChildName (hasElemName "m" "limLoc") >>=
803− findAttr (elemName ns "m" "val")
806+ findAttrBy (hasElemName "m" "val")
804− subExps <- findChild (elemName ns "m" "sub") element >>=
807+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
805− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
808+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
806− supExps <- findChild (elemName ns "m" "sup") element >>=
809+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
807− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
810+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
808− baseExp <- findChild (elemName ns "m" "e") element >>=
811+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
809− elemToBase ns >>=
812+ elemToBase >>=
810 (return . baseToExp)
813 (return . baseToExp)
811 case limLoc of
814 case limLoc of
812 Just "undOvr" -> return [TM.EUnderover True
815 Just "undOvr" -> return [TM.EUnderover True
@@ -820,63 +823,63 @@ elemToExps' ns element | isElem ns "m" "nary" element = do
820 (TM.EGrouped supExps)
823 (TM.EGrouped supExps)
821 , baseExp]
824 , baseExp]
823−elemToExps' ns element | isElem ns "m" "phant" element = do
826+elemToExps' element | isElem "m" "phant" element = do
824− baseExp <- findChild (elemName ns "m" "e") element >>=
827+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
825− elemToBase ns >>=
828+ elemToBase >>=
826 (return . baseToExp)
829 (return . baseToExp)
827 return [TM.EPhantom baseExp]
830 return [TM.EPhantom baseExp]
828−elemToExps' ns element | isElem ns "m" "rad" element = do
831+elemToExps' element | isElem "m" "rad" element = do
829− degExps <- findChild (elemName ns "m" "deg") element >>=
832+ degExps <- filterChildName (hasElemName "m" "deg") element >>=
830− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
833+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
831− baseExp <- findChild (elemName ns "m" "e") element >>=
834+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
832− elemToBase ns >>=
835+ elemToBase >>=
833 (return . baseToExp)
836 (return . baseToExp)
834 return $ case degExps of
837 return $ case degExps of
835 [] -> [TM.ESqrt baseExp]
838 [] -> [TM.ESqrt baseExp]
836 ds -> [TM.ERoot (TM.EGrouped ds) baseExp]
839 ds -> [TM.ERoot (TM.EGrouped ds) baseExp]
837−elemToExps' ns element | isElem ns "m" "sPre" element = do
840+elemToExps' element | isElem "m" "sPre" element = do
838− subExps <- findChild (elemName ns "m" "sub") element >>=
841+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
839− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
842+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
840− supExps <- findChild (elemName ns "m" "sup") element >>=
843+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
841− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
844+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
842− baseExp <- findChild (elemName ns "m" "e") element >>=
845+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
843− elemToBase ns >>=
846+ elemToBase >>=
844 (return . baseToExp)
847 (return . baseToExp)
845 return [TM.ESubsup
848 return [TM.ESubsup
846 (TM.EIdentifier "")
849 (TM.EIdentifier "")
847 (TM.EGrouped subExps)
850 (TM.EGrouped subExps)
848 (TM.EGrouped supExps)
851 (TM.EGrouped supExps)
849 , baseExp]
852 , baseExp]
850−elemToExps' ns element | isElem ns "m" "sSub" element = do
853+elemToExps' element | isElem "m" "sSub" element = do
851− baseExp <- findChild (elemName ns "m" "e") element >>=
854+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
852− elemToBase ns >>=
855+ elemToBase >>=
853 (return . baseToExp)
856 (return . baseToExp)
854− subExps <- findChild (elemName ns "m" "sub") element >>=
857+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
855− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
858+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
856 return [TM.ESub baseExp (TM.EGrouped subExps)]
859 return [TM.ESub baseExp (TM.EGrouped subExps)]
857−elemToExps' ns element | isElem ns "m" "sSubSup" element = do
860+elemToExps' element | isElem "m" "sSubSup" element = do
858− baseExp <- findChild (elemName ns "m" "e") element >>=
861+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
859− elemToBase ns >>=
862+ elemToBase >>=
860 (return . baseToExp)
863 (return . baseToExp)
861− subExps <- findChild (elemName ns "m" "sub") element >>=
864+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
862− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
865+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
863− supExps <- findChild (elemName ns "m" "sup") element >>=
866+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
864− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
867+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
865 return [TM.ESubsup baseExp (TM.EGrouped subExps) (TM.EGrouped supExps)]
868 return [TM.ESubsup baseExp (TM.EGrouped subExps) (TM.EGrouped supExps)]
866−elemToExps' ns element | isElem ns "m" "sSup" element = do
869+elemToExps' element | isElem "m" "sSup" element = do
867− baseExp <- findChild (elemName ns "m" "e") element >>=
870+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
868− elemToBase ns >>=
871+ elemToBase >>=
869 (return . baseToExp)
872 (return . baseToExp)
870− supExps <- findChild (elemName ns "m" "sup") element >>=
873+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
871− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
874+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
872 return [TM.ESuper baseExp (TM.EGrouped supExps)]
875 return [TM.ESuper baseExp (TM.EGrouped supExps)]
873−elemToExps' ns element | isElem ns "m" "r" element = do
876+elemToExps' element | isElem "m" "r" element = do
874− let mrPr = findChild (elemName ns "m" "rPr") element
877+ let mrPr = filterChildName (hasElemName "m" "rPr") element
875 lit = mrPr >>=
878 lit = mrPr >>=
876− findChild (elemName ns "m" "lit") >>=
879+ filterChildName (hasElemName "m" "lit") >>=
877− findAttr (elemName ns "m" "val")
880+ findAttrBy (hasElemName "m" "val")
878− txtSty = elemToOMathRunTextStyle ns element
881+ txtSty = elemToOMathRunTextStyle element
879− mrElems <- elemToOMathRunElems ns element
882+ mrElems <- elemToOMathRunElems element
880 return $ case oMathRunTextStyleToTextType txtSty of
883 return $ case oMathRunTextStyleToTextType txtSty of
881 Nothing -> [TM.EIdentifier $ oMathRunElemsToString mrElems]
884 Nothing -> [TM.EIdentifier $ oMathRunElemsToString mrElems]
882 Just textType ->
885 Just textType ->
@@ -885,7 +888,7 @@ elemToExps' ns element | isElem ns "m" "r" element = do
885 [TM.EText textType (oMathRunElemsToString mrElems)]
888 [TM.EText textType (oMathRunElemsToString mrElems)]
887 [TM.EStyled textType [TM.EIdentifier $ oMathRunElemsToString mrElems]]
890 [TM.EStyled textType [TM.EIdentifier $ oMathRunElemsToString mrElems]]
888−elemToExps' _ _ = Nothing
891+elemToExps' _ = Nothing
890expToString :: TM.Exp -> String
893expToString :: TM.Exp -> String
891expToString (TM.ENumber s) = s
894expToString (TM.ENumber s) = s