diff options
Diffstat (limited to 'Master/texmf-dist/source/generic/tex4ht/tex4ht-jsml-xtpipes.tex')
-rw-r--r-- | Master/texmf-dist/source/generic/tex4ht/tex4ht-jsml-xtpipes.tex | 3902 |
1 files changed, 3902 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/generic/tex4ht/tex4ht-jsml-xtpipes.tex b/Master/texmf-dist/source/generic/tex4ht/tex4ht-jsml-xtpipes.tex new file mode 100644 index 00000000000..fa1cd703fdc --- /dev/null +++ b/Master/texmf-dist/source/generic/tex4ht/tex4ht-jsml-xtpipes.tex @@ -0,0 +1,3902 @@ +% $Id: tex4ht-jsml-xtpipes.tex 740 2020-06-13 22:35:32Z karl $ +% htlatex tex4ht-jsml-xtpipes "xhtml,next,3" "" "-d./" +% +% Copyright 2009-2020 TeX Users Group +% Copyright 2002-2009 Eitan M. Gurari +% Released under LPPL 1.3c+. +% See tex4ht-cpright.tex for license text. + +\documentclass{article} + \Configure{ProTex}{log,<<<>>>,title,list,`,[[]]} +\begin{document} + + +\input{common} +\input{tex4ht-cpright} +\input{tex4ht-dir} + +%%%%%%%%%%%%%%%%%% +\part{Script for xtpipes} +%%%%%%%%%%%%%%%%%% + + +%%%%%%%%%%%%%%%%%% +\section{Outline} +%%%%%%%%%%%%%%%%%% + +\AtEndDocument{\OutputCodE\<jsml.4xt\>} + +\Needs{"xmllint --valid --noout jsml.4xt"} + + +\<jsml.4xt\><<< +<?xml version="1.0" encoding="UTF-8" ?> +<!DOCTYPE xtpipes SYSTEM "xtpipes.dtd" > +<!-- jsml.4xt (`version), generated from `jobname.tex + Copyright (C) 2009-2010 TeX Users Group + Copyright (C) `CopyYear.2002. Eitan M. Gurari +`<TeX4ht copyright`> --> +<xtpipes signature="jsml.4xt (`version)"> + <sax content-handler="xtpipes.util.ScriptsManager, tex4ht.GroupMn, tex4ht.JsmlFilter" + lexical-handler="xtpipes.util.ScriptsManagerLH" > + `<numbers in math`> + `<special sub and super scripts`> + `<span frac elements`> + `<short cut modifiers`> + `<over and under scripts`> + `<bold math`> + `<capital math letters`> + `<remove multline eqnum cell`> + `<inline math`> + `<display math`> + `<replace characters`> + `<remove empty split entries`> + `<boundaries on theorems`> + `<br into BREAK`> + `<short notation for empty elements`> + </sax> +</xtpipes> +>>> + + + `<non short tag br elements`> + + `<inline math`> + `<display math`> + `<measure tables`> + + + + +\<inline math\><<< +<script element="span::inline-math" > + `<compress numeric subscripts`> + `<set levels for hyper complex fracs`> + `<set levels for sub and sup scripts`> + `<set levels for roots`> + <set name="inline-math" > + `<open xslt script`> + `<shared display and inline math 1`> + `<eliminate inline math narrative`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="inline-math" /> + `<eliminate extra math pauses`> + <set name="inline-math-2" > + `<open xslt script`> + `<shared display and inline math 2`> + `<eliminate inline math narrative 2`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="inline-math-2" /> +</script> +>>> + + +\<display math\><<< +<script element="div::display-math" > + `<compress numeric subscripts`> + `<set levels for hyper complex fracs`> + `<set levels for sub and sup scripts`> + `<set levels for roots`> + <set name="display-math" > + `<open xslt script`> + `<shared display and inline math 1`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="display-math" /> + `<eliminate extra math pauses`> + <set name="display-math-2" > + `<open xslt script`> + `<shared display and inline math 2`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="display-math-2" /> + `<set empty elements for the w3 browser`> +</script> +>>> + + + + +\<shared display and inline math 1\><<< +`<remove super mn-group`> +`<sayas punctuation`> +`<sayas digits`> +`<sayas math letters`> +`<get content template`> +`<eliminate baseline script marks`> +`<clean begin and mid script marks`> +`<mixed fractions`> +`<'minus' into 'negative'`> +`<compress limit script`> +`<remove scrip indicators from primes`> +`<remove scrip indicators from degree`> +>>> + + +\<shared display and inline math 2\><<< +`<get content template`> +`<replace nested baseline script marks`> +`<remove marks on empty scripts`> +`<eliminate begin script marks`> +>>> + + + + +\AtEndDocument{\OutputCodE\<HtJsml.java\>} + +\ifdojava + \Needs{" + javac HtJsml.java -d \XTPIPES +"} +\fi + +\<HtJsml.java\><<< +package tex4ht; +/* HtJsml.java (`version), generated from `jobname.tex + Copyright (C) 2009-2010 TeX Users Group + Copyright (C) `CopyYear.2002. Eitan M. Gurari +`<TeX4ht copyright`> */ +import org.w3c.dom.*; +public class HtJsml { + `<HtJsml utility members`> + `<static void mnGroup(dom)`> + `<static void fracLevel(dom)`> + `<static void scriptLevel(dom)`> + `<static void rootLevel(dom)`> +} +>>> + + + + +%%%%%%%%%%%%%%%%%% +\section{Numbers in Math} +%%%%%%%%%%%%%%%%%% + + +%%%%%%%%%%%%% +\subsection{Group MN / MO-Punctuation} +%%%%%%%%%%%%% + + +\AtEndDocument{% + \OutputCodE\<GroupMn.java\> + } +\ifdojava + \Needs{" + javac GroupMn.java -d \XTPIPES +"} +\fi + +\<GroupMn.java\><<< +package tex4ht; +/* GroupMn.java (`version), generated from `jobname.tex + Copyright (C) 2009-2010 TeX Users Group + Copyright (C) `CopyYear.2002. Eitan M. Gurari +`<TeX4ht copyright`> */ +import org.xml.sax.helpers.*; +import org.xml.sax.*; +import java.io.PrintWriter; + +public class GroupMn extends XMLFilterImpl { + PrintWriter out = null; + boolean inMn = false; + String ns; + int level = -1; + public GroupMn( PrintWriter out, PrintWriter log, boolean trace){ + this.out = out; + } + public void startElement(String ns, String sName, + String qName, Attributes attr) { + level++; + try{ + if( inMn ){ + if( level == 0 ){ `<consider end of num`> } + } else { `<consider start of num`> } + super.startElement(ns, sName, qName, attr); + } catch( Exception e ){ + System.out.println( "--- GroupMn Error 1 --- " + e); + } + } + public void endElement(String ns, String sName, String qName){ + try{ + if( level < 0) { + `<endElement: consider end of num`> + } + super.endElement(ns, sName, qName); + } catch( Exception e ){ + System.out.println( "--- GroupMn Error 2 --- " + e); + } + level--; + } + public void characters(char[] ch, int start, int length){ + try{ + if ( inMn && (level < 0) ) { + String s = new String(ch, start, length); + if (!s.trim().equals("")) { + inMn = false; + super.endElement(ns, "mn-group", "mn-group"); + } } + super.characters(ch, start, length); + } catch( Exception e ){ + System.out.println( "--- GroupMn Error 3 --- " + e); +} } } +>>> + +\<consider start of num\><<< +if( qName.equals( "mn" ) ){ + inMn = true; level = 0; + Attributes att = new AttributesImpl(); + super.startElement(ns, "mn-group", "mn-group", att); + this.ns = ns; +} else if( qName.equals( "mo" ) ){ + String cls = attr.getValue( "class" ); + if( (cls != null) && cls.equals("MathClass-punc") ){ + inMn = true; level = 0; + Attributes att = new AttributesImpl(); + super.startElement(ns, "mn-group", "mn-group", att); + this.ns = ns; +} } +>>> + +\<consider end of num\><<< +if( !qName.equals( "mn" ) ){ + if( qName.equals( "mo" ) ){ + String cls = attr.getValue( "class" ); + if( (cls == null) || !cls.equals("MathClass-punc") ){ + inMn = false; + super.endElement(ns, "mn-group", "mn-group"); + } + } else { + inMn = false; + super.endElement(ns, "mn-group", "mn-group"); +} } +>>> + +\<endElement: consider end of num\><<< +if( inMn ){ + inMn = false; + super.endElement(ns, "mn-group", "mn-group"); +} +>>> + +%%%%%%%%%%%%% +\subsection{Outline of Post Original Partition} +%%%%%%%%%%%%% + + +\<numbers in math\><<< +<script element="mn-group" > + `<missed partitions to mn groups`> + <set name="merge" > + `<open xslt script`> + `<merge digits`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="merge" /> +</script> +>>> + + + +\<missed partitions to mn groups\><<< +<dom name="." xml="." method="mnGroup" class="tex4ht.HtJsml" /> +`<remove xml declaration`> +>>> + + +\<static void mnGroup(dom)\><<< +private static Document dom; +public static void mnGroup(Node d) { + dom = (Document) d; + setMnGroup(dom.getFirstChild()); +} +private static void setMnGroup(Node node) { + if( node.getNodeName().equals( "mn-group" ) ){ + boolean bool = false; + `<get mn characters`> + if( bool ){ + `<mark remove commas, if comma after period`> + `<mark remove commas, if not spaced correctly`> + `<cond remove commas`> + `<remove punc, on consecutive periods`> + `<remove punc at end`> + } + `<reset mn-group`> + } else if (node.hasChildNodes()) { + NodeList children = node.getChildNodes(); + for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE) { + setMnGroup(child); +} } } } +>>> + +%%%%%%%%%%%%% +\subsection{Mark Partition of MN Group} +%%%%%%%%%%%%% + +Consecutive digits and punctation characters are grouped together, and +then ungrouped at characters that are marked by `x'. + + +\<get mn characters\><<< +NodeList children = node.getChildNodes(); +int n = children.getLength(); +char [] digit = new char[n]; +for (int i = 0; i < n; i++) { + Node child = children.item(i).getFirstChild(); + if( child == null ){ + digit[i] = 'x'; + } else if( child.getNodeType() != Node.TEXT_NODE ){ + digit[i] = 'x'; + } else { + String s = child.getNodeValue(); + if( s.length() != 1 ){ + digit[i] = 'x'; + } else { + char ch = s.charAt(0); + if( (ch >= '0') && (ch <= '9') ){ + digit[i] = '0'; bool = true; + } else if( (ch == '.') || (ch == ',') ){ digit[i] = ch; } + else { digit[i] = 'x';} +} } } +>>> + +\<mark remove commas, if comma after period\><<< +bool = false; +for (int i = 0; i < n; i++) { + if( digit[i] == '.' ){ + for (; i < n; i++) { + if( digit[i] == ',' ){ + bool = true; break; + } } + break; +} } +>>> + +\<mark remove commas, if not spaced correctly\><<< +if( !bool ){ + for (int i = 0; i < n; i++) { + if( digit[i] == ',' ){ + if( ( ((i+3) >= n) + || (digit[i+1] != '0') + || (digit[i+2] != '0') + || (digit[i+3] != '0') + ) + || + ( + ((i+4) < n) && (digit[i+4] == '0') + ) + || + ( + (i>3) && (digit[i-4] == '0') + ) + ){ bool = true; break; + } else { i += 3; } +} } } +>>> + +\<cond remove commas\><<< +if( bool ){ + for (int i = 0; i < n; i++) { + if( digit[i] == ',' ){ digit[i] = 'x'; } +} } +>>> + + +\<remove punc, on consecutive periods\><<< +bool = false; +for (int i = 0; i < n; i++) { + if( (digit[i] == 'x') + || (digit[i] == ',') ){ bool = false; } + else if( digit[i] == '.' ){ + if( bool ){ + for (int j = 0; j < n; j++) { + if( (digit[j] == '.') || (digit[j] == ',') ){ + digit[j] = 'x'; + } } + break; + } + bool = true; +} } +>>> + +\<remove punc at end\><<< +if( digit[n-1] == '.' ){ digit[n-1] = 'x'; } +>>> + +%%%%%%%%%%%%% +\subsection{Realize the Sub Partition} +%%%%%%%%%%%%% + + +\<reset mn-group\><<< +Node parent = node.getParentNode(); +Element g = dom.createElement( "mn-group-s" ); +Element cur = dom.createElement( "mn-group" ); +for(int i=0; i<n; i++ ){ + Node child = node.getFirstChild(); + node.removeChild( child ); + if( digit[i] == 'x' ){ + if( cur.hasChildNodes() ){ g.appendChild( cur ); } + g.appendChild( child ); + cur = dom.createElement( "mn-group" ); + } else { + cur.appendChild( child ); +} } +if( cur.hasChildNodes() ){ g.appendChild( cur ); } +parent.replaceChild( g, node ); +>>> + + +%%%%%%%%%%%%% +\subsection{Reset MNs} +%%%%%%%%%%%%% + + + + +\<merge digits\><<< +<xsl:template match="mn-group" > + <xsl:choose> + <xsl:when test=" not(child::mn) "> + <xsl:apply-templates select="*|text()" /> + </xsl:when> + <xsl:otherwise> + <mn> + <xsl:value-of select="." /> + </mn> + </xsl:otherwise> + </xsl:choose> +</xsl:template> +>>> + + + + + + + + +\<remove super mn-group\><<< +<xsl:template match="mn-group-s" > + <xsl:apply-templates select="*|@*|text()|comment()" /> +</xsl:template> +>>> + + + +%%%%%%%%%%%%% +\subsection{Pronounced Letters} +%%%%%%%%%%%%% + + + +\<sayas math letters \><<< +<xsl:template match="mi[ .='a' ]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <SAYAS SUB="aih">a</SAYAS> + </xsl:copy> +</xsl:template> +>>> + + +%%%%%%%%%%%%% +\subsection{Pronounced Punctuation in math} +%%%%%%%%%%%%% + +TTSs might ignore punctuation marks. We want these +symbols in math. + +\<sayas punctuation\><<< +<xsl:template match="mo[ + (@class='MathClass-punc') + and ( (.='.') or (.=',') or (.='!') + or (.=';') or (.=':') or (.='?') ) +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <BREAK SIZE="small"/> + <xsl:choose> + <xsl:when test=" .='.' " > + <SAYAS SUB="dot">.</SAYAS> + </xsl:when> + <xsl:when test=" .=',' " > + <SAYAS SUB="comma">,</SAYAS> + </xsl:when> + <xsl:when test=" .=';' " > + <SAYAS SUB="semicolon">;</SAYAS> + </xsl:when> + <xsl:when test=" .=':' " > + <SAYAS SUB="colon">:</SAYAS> + </xsl:when> + <xsl:when test=" .='!' " > + <SAYAS SUB="exclamation mark">!</SAYAS> + </xsl:when> + <xsl:when test=" .='?' " > + <SAYAS SUB="question mark">?</SAYAS> + </xsl:when> + </xsl:choose> + <BREAK SIZE="small"/> + </xsl:copy> +</xsl:template> +>>> + + +\<sayas digits\><<< +<xsl:template match="mn[ + `<mn modified above`> + or + `<mn modified under`> +]" > + <xsl:copy> + <SAYAS CLASS="digits"> + <xsl:value-of select="." /> + </SAYAS> + </xsl:copy> +</xsl:template> +>>> + + +\<mn modified above\><<< +ancestor::mover[ + not( descendant::*[ + (count( `<math content element`> ) > 1) + ]) + and + ( + preceding-sibling::*[1][self::dot or self::mn-group-s] + or + following-sibling::*[1][self::dot or self::mn-group-s] + ) +] +>>> + + + +\<mn modified under\><<< +ancestor::munder[ + not( descendant::*[ + (count( `<math content element`> ) > 1) + ]) + and + ( + preceding-sibling::*[1][self::dot or self::mn-group-s] + or + following-sibling::*[1][self::dot or self::mn-group-s] + ) +] +>>> + + +%%%%%%%%%%%%%%%%%% +\section{Process Characters} +%%%%%%%%%%%%%%%%%% + + + + + +%%%%%%%%%%%%% +\subsection{'minus' into 'negative'} +%%%%%%%%%%%%% + + + +\<'minus' into 'negative'\><<< +<xsl:template match="mo[ + (@class = 'MathClass-bin') + and + ( normalize-space(.) = + normalize-space(descendant::span[@class = 'ch 2212']) + ) + and + ( preceding-sibling::*[1][ + (@title='speech-extra') + or (@class='MathClass-bin') + or (@class='MathClass-rel') + or (@class='MathClass-punc') + or (@class='MathClass-op') + or self::mn-group-s [ child::* [ + (position() = last()) + and + (@class='MathClass-punc') + ] ] ] + and + ( + following-sibling::*[1][ self::mn-group-s + or self::mi ] + or + (count(following-sibling::*[ + not(@title = 'speech-extra') + ]) = 1) + ) + or + not(preceding-sibling::*) and following-sibling::* + ) +]" > + <xsl:copy> + <xsl:attribute name="class"> + <xsl:text>mo-unary</xsl:text> + </xsl:attribute> + <xsl:apply-templates select="*|text()|comment()" + mode="minus-neg" /> + </xsl:copy> +</xsl:template> +>>> + + +\<'minus' into 'negative'\><<< +<xsl:template match="*|@*|text()|comment()" mode="minus-neg" > + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" + mode="minus-neg" /> + </xsl:copy> +</xsl:template> +>>> + +\begin{verbatim} +<span class="begin-script"> subscript </span> +<mo class="MathClass-bin"> + <span class="char"> + <span class="ch 2212">minus</span> + </span> +</mo> +<mn>2</mn> +\end{verbatim} + + + + +\<'minus' into 'negative'\><<< +<xsl:template match="text()" mode="minus-neg" > + <xsl:choose> + <xsl:when test=" . = 'minus' " > + <xsl:text>negative</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:value-of select="." /> + </xsl:otherwise> + </xsl:choose> +</xsl:template> +>>> + + +%%%%%%%%%%%%%%%%%% +\subsection{Capital Letters in Math} +%%%%%%%%%%%%%%%%%% + +\<capital math letters\><<< +<script element="mi" > + <set name="math-cap" > + `<open xslt script`> + `<span.mi cap letters`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="math-cap" /> +</script> +>>> + + +\<span.mi cap letters\><<< +<xsl:template match="mi" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:if test=" string-length(.) = 1 " > + <xsl:if test=" + (translate(.,'ABCDEFGHIJKLMNOPQRSTUVWXYZ', + '') = '' ) + " > + <span class="capital-description" + title="speech-extra" > + <xsl:text> capital </xsl:text> + </span> + </xsl:if> + </xsl:if> + <xsl:apply-templates select="*|text()|comment()" /> + </xsl:copy> +</xsl:template> +>>> + + + +%%%%%%%%%%%%% +\subsection{Right Apostrophes} +%%%%%%%%%%%%% + + + +\<replace characters\><<< +<script element="PARA" > + <set name="apostro" > + `<open xslt script`> + `<right apostrophe in prose`> + `<delimiters in marks of enumerated lists`> + `<remove empty paragraphs`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="apostro" /> +</script> +>>> + + +\<right apostrophe in prose\><<< +<xsl:template match="span[ + (@class = 'char-del') + and child::span [ @class = 'ch 2019' ] +]" > + <xsl:text>'</xsl:text> +</xsl:template> +>>> + + +%%%%%%%%%%%%% +\subsection{Delimiters on List Marks} +%%%%%%%%%%%%% + + + +\<delimiters in marks of enumerated lists\><<< +<xsl:template match="PROS[ parent::SENT[@class='ol-mark'] ]" > + <xsl:copy> + <xsl:apply-templates + select="*[not(@class='char-del')]|@*|text()|comment()" /> + </xsl:copy> +</xsl:template> +>>> + + +%%%%%%%%%%%%%%%%%% +\section{Clean Up} +%%%%%%%%%%%%%%%%%% + + +%%%%%%%%%%%%% +\subsection{Extra Math Pauses} +%%%%%%%%%%%%% + + +Deletes pauses that are not separated by text from their immediate +predecessors. + +An earlier XSLT-based approach was very slow, and died +on nodes with large numbers of children. + + +\<eliminate extra math pauses\><<< +<sax name="." xml="." content-handler="tex4ht.JsmlMathBreak" /> +>>> + + +\AtEndDocument{% + \OutputCodE\<JsmlMathBreak.java\> + } + +\ifdojava + \Needs{" + javac -classpath \LIB xtpipes.jar + JsmlMathBreak.java + -d \XTPIPES . +"} +\fi + +\<JsmlMathBreak.java\><<< +package tex4ht; +/* JsmlMathBreak.java (`version), generated from `jobname.tex + Copyright (C) 2009-2010 TeX Users Group + Copyright (C) `CopyYear.2002. Eitan M. Gurari +`<TeX4ht copyright`> */ + +import xtpipes.XtpipesUni; +import org.xml.sax.*; +import org.xml.sax.helpers.DefaultHandler; +import java.io.*; +import java.lang.reflect.*; +import java.util.HashMap; + +public class JsmlMathBreak extends DefaultHandler { + PrintWriter out = null; + boolean delete = false; + public JsmlMathBreak(PrintWriter out, + HashMap<String,Object> scripts, + Method method, PrintWriter log, boolean trace) { + this.out = out; + } + public void characters(char[] ch, int start, int length) { + String s = XtpipesUni.toUni(ch, start, length, "<>&"); + out.print( s ); + if( !s.trim().equals("") ){ + delete = false; + } } + public void startElement(String ns, String sName, + String qName, + Attributes atts) { + if( !( delete && qName.equals("BREAK") ) ){ + String s = "<" + qName + "\n"; + for (int i = 0; i < atts.getLength(); i++) { + String name = atts.getQName(i); + if (name != "xmlns") { + s += (" " + name + "=\"" + + XtpipesUni.toUni(atts.getValue(i), "<>&\"") + + "\""); + } } + if( qName.equals( "BREAK" ) ){ + s += "/"; + delete = true; + } + s += ">"; + out.print(s); + } } + public void endElement(String ns, String sName, String qName) { + if( !qName.equals( "BREAK" ) ){ + String s = "</" + qName + ">"; + out.print(s); +} } } +>>> + + + +\begin{verbatim} + </mrow> + <span class="end-root" title="speech-extra"> + <BREAK SIZE="medium"/> + <level prefix="end" depth="1">end end root</level> + <BREAK SIZE="medium"/> + </span> +</mroot> +<span class="end-math" title="speech-extra"> + <BREAK SIZE="small"/> + <PROS PITCH="-5">end math</PROS> + <BREAK SIZE="medium"/> +\end{verbatim} + + +%%%%%%%%%%%%% +\subsection{Line Breaks} +%%%%%%%%%%%%% + + +\<br into BREAK\><<< +<script element="br" > + <set name="br" > + `<open xslt script`> + `<append br with BREAK`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="br" /> +</script> +>>> + + +\<append br with BREAK\><<< +<xsl:template match="br" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + </xsl:copy> + <BREAK SIZE="small"/> +</xsl:template> +>>> +>>> + + +%%%%%%%%%%%%%%%%%% +\subsection{Empty Elements} +%%%%%%%%%%%%%%%%%% + + + +\marginpar{??????} + +Can we avoid empty non-empty representations without of the +following(Example: +\verb+\documentclass{article} \begin{document} \section{Section One} This is Section 1 \end{document} + +) + + +\<short notation for empty elements\><<< +<script element="BREAK" > + <set name="BREAK" > + `<open xslt script`> + `<empty BREAK`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="BREAK" /> +</script> +>>> + + +\<empty BREAK\><<< +<xsl:template match="BREAK" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + </xsl:copy> +</xsl:template> +>>> + + + +%%%%%%%%%%%%% +\subsection{Empty Array Cells} +%%%%%%%%%%%%% + +Empty array celles at end of rows can make it more difficult to +detect deletable baseline indicators. + + + +\<remove multline eqnum cell\><<< +<script element="tr" > + <set name="eqnum" > + `<open xslt script`> + `<remove empty cells from rows`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="eqnum" /> +</script> +>>> + +\<remove multline eqnum cell\><<< +<script element="mtr" > + <set name="eqnum" > + `<open xslt script`> + `<remove empty cells from rows`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="eqnum" /> +</script> +>>> + +\<remove empty cells from rows\><<< +<xsl:template match="div[ + (parent::tr or parent::mtr) + and ( normalize-space(.) = '' ) + and not( normalize-space(following-sibling::*) != '' ) +]" > +</xsl:template> +>>> + + +%%%%%%%%%%%%% +\subsection{Paragraphs (JsmlFilter.java)} +%%%%%%%%%%%%% + +\<remove empty paragraphs\><<< +<xsl:template match=" PARA[ normalize-space(.) = '' ] " > +</xsl:template> +>>> + + +The following adds PARA on `p' paragraphs, ul. + + + + +\AtEndDocument{ % + \OutputCodE\<JsmlFilter.java\> + } +\ifdojava + \Needs{" + javac JsmlFilter.java -d \XTPIPES +"} +\fi + +\<JsmlFilter.java\><<< +package tex4ht; +/* JsmlFilter.java (`version), generated from `jobname.tex + Copyright (C) 2009-2010 TeX Users Group + Copyright (C) `CopyYear.2002. Eitan M. Gurari +`<TeX4ht copyright`> */ +import org.xml.sax.helpers.*; +import org.xml.sax.*; +import java.io.PrintWriter; + +public class JsmlFilter extends XMLFilterImpl { + PrintWriter out = null; + public JsmlFilter( PrintWriter out, PrintWriter log, boolean trace ){ + this.out = out; + } + public void startElement(String ns, String sName, + String qName, Attributes attr) { + try{ + if( `<elements for PARA?`> ){ + Attributes att = new AttributesImpl(); + super.startElement(ns, "PARA", "PARA", att); + } + super.startElement(ns, sName, qName, attr); + } catch( Exception e ){ + System.out.println( "--- JsmlFilter Error 1 --- " + e); + } } + public void endElement(String ns, String sName, String qName){ + try{ + super.endElement(ns, sName, qName); + if( `<elements for PARA?`> ){ + super.endElement(ns, "PARA", "PARA"); + } + } catch( Exception e ){ + System.out.println( "--- JsmlFilter Error 2 --- " + e); +} } } +>>> + + + + +\<elements for PARA?\><<< + qName.equals( "p" ) +|| qName.equals( "h2" ) +|| qName.equals( "h3" ) +|| qName.equals( "h4" ) +|| qName.equals( "ul" ) +|| qName.equals( "ol" ) +|| qName.equals( "li" ) +|| qName.equals( "dd" ) +|| qName.equals( "dl" ) +>>> + + +%%%%%%%%%%%%% +\subsection{Remove Split Arrays} +%%%%%%%%%%%%% + +\<remove empty split entries\><<< +<script element="div::split-side" > + <set name="clean-split" > + `<open xslt script`> + `<get content template`> + `<clean math split`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="clean-split" /> +</script> +>>> + + +\<clean math split\><<< +<xsl:template match=" div[ @class='split-side' ] +" > + <xsl:variable name="content"> + <xsl:apply-templates select="*" mode="content" /> + </xsl:variable> + <xsl:if test=" + string-length( normalize-space( $content )) != 0 + " > + <xsl:copy> + <xsl:apply-templates select=" *|@*|text()|comment() " /> + </xsl:copy> + </xsl:if> +</xsl:template> +>>> + + +%%%%%%%%%%%%% +\section{Eliminate Inline Math Narrative} +%%%%%%%%%%%%% + + +%%%%%%%%%%%%% +\subsection{Core Content of One Element} +%%%%%%%%%%%%% + + +\<eliminate inline math narrative NO\><<< +<xsl:template match="span[ + (@class = 'inline-math') + and + (count( `<math content element`> ) = 1) +]" > + <xsl:copy> + <xsl:choose> + <xsl:when test="child::mfrac or child::msqrt + or child::mover or child::munder + "> + <xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> + </xsl:attribute> + <BREAK SIZE="small"/> + <xsl:apply-templates + select="`<math content element`>" /> + </xsl:when> + <xsl:otherwise> + `<non-adjacent narrative`> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + + +\<non-adjacent narrative\><<< +<xsl:variable name="content"> + <xsl:apply-templates + select="`<math content element`>" + mode="content" /> +</xsl:variable> +<xsl:choose> + `<math narrative of length one`> + `<math narrative of just one element`> + `<simple sub or sup`> + <xsl:otherwise> + <xsl:apply-templates + select="*|@*|text()|comment()" /> + </xsl:otherwise> +</xsl:choose> +>>> + + + + + +\<math content element\><<< +child::*[ not(@title = 'speech-extra') + and not( self::BREAK ) + ] +>>> + + + + +\<math narrative of length one\><<< +<xsl:when test=" + string-length( normalize-space( $content )) = 1 +" > + <xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> + </xsl:attribute> + <xsl:apply-templates + select="`<math content element`>" /> +</xsl:when> +>>> + +\<math narrative of just one element\><<< +<xsl:when test=" + not(`<math content element`> + / descendant::* [ + count(child::*[ + not(self::BREAK) + ] ) > 1 + ] ) +" > + <xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> + </xsl:attribute> + <PROS PITCH="-5"> + <BREAK SIZE="small"/> + <xsl:apply-templates + select="`<math content element`>" /> + <BREAK SIZE="small"/> + </PROS> +</xsl:when> +>>> + + +\<simple sub or sup\><<< +<xsl:when test=" child::*[ + (position() = 2) + and + (self::msub or self::msup or self::msubsup) +]" > + <xsl:variable name="content"> + <xsl:apply-templates + select="child::*[2] / child::*[ + (@class = 'mrow-base') + or (@class = 'limits-mrow-base') ]" + mode="content" /> + </xsl:variable> + <xsl:choose> + <xsl:when test=" + string-length( normalize-space( $content )) = 1 + or + (translate($content,'0123456789 ','') = '') + " > + <xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> + </xsl:attribute> + <PROS PITCH="-5"> + <BREAK SIZE="small"/> + <xsl:apply-templates select="*[2]" /> + <BREAK SIZE="small"/> + </PROS> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()" /> + </xsl:otherwise> + </xsl:choose> +</xsl:when> +>>> + + +\begin{verbatim} +<span class="inline-math"> + <msub> + <mrow class="mrow-base"> + <mi>C</mi> + </mrow> + <mrow class="mrow-sub"> + <mi>i</mi> + </mrow> + </msub> +</span> +\end{verbatim} + + + + +%%%%%%%%%%%%% +\subsection{Unary Op} +%%%%%%%%%%%%% + +The `mo-unary' is established in the first pass over inline-math, +so we need to wait for the second pass with the following. + + +\<eliminate inline math narrative NO 2\><<< +<xsl:template match="span[ + (@class = 'inline-math') + and + (count( `<math content element`> ) = 2) + and + ( child::mo[ + (@class = 'mo-unary') + and + following-sibling::*[1] + / self::mi + ] + or + child::mi[ + following-sibling::*[1] + [ (@class = 'MathClass-open-close') + and + not(child::*[2] + / child::*[ not(self::BREAK) ] + / child::*[ not(self::BREAK) ] ) + ] ] + ) +]" > + <xsl:copy> + <xsl:choose> + `<when func on shallow arg`> + <xsl:otherwise> + `<unary op on short content`> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + +\<when func on shallow arg\><<< +<xsl:when test=" + child::mrow[ @class = 'MathClass-open-close' ] +" > + <xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> + </xsl:attribute> + <PROS PITCH="-5"> + <BREAK SIZE="small"/> + <xsl:apply-templates + select="`<math content element`>" /> + <BREAK SIZE="small"/> + </PROS> +</xsl:when> +>>> + +\<unary op on short content\><<< +<xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> +</xsl:attribute> +<PROS PITCH="-5"> +<BREAK SIZE="small"/> + <xsl:apply-templates + select="`<math content element`>" /> +<BREAK SIZE="small"/> +</PROS> +>>> + + + +%%%%%%%%%%%%% +\subsection{Shallow Expression} +%%%%%%%%%%%%% + + +\<eliminate inline math narrative NO 2\><<< +<xsl:template match="span[ + (@class = 'inline-math') + and + not( child::*[ + not(self::mo) + and not(self::mi) + and not(self::mn) + and not(self::mn-group-s) + and not( @title='speech-extra' ) + and not( self::mfrac[ + preceding-sibling::*[1][self::mn ] + ] + ) + and not( self::msub + / child::*[1][ + child::mo[ @class = 'MathClass-op' ] + and + not(child::*[2]) + ] + ) + ] ) +]" > + <xsl:copy> + `<shallow expression`> + </xsl:copy> +</xsl:template> +>>> + +\<shallow expression\><<< +<xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> +</xsl:attribute> +<PROS PITCH="-5"> +<BREAK SIZE="small"/> + <xsl:apply-templates + select="`<math content element`> | text()" /> +<BREAK SIZE="small"/> +</PROS> +>>> + + + + +%%%%%%%%%%%%% +\subsection{Shallow Delimited Expression} +%%%%%%%%%%%%% + + +\<eliminate inline math narrative NO 2\><<< +<xsl:template match="span[ + (@class = 'inline-math') + and + (count( `<math content element`> ) = 1) + and + child::mrow[ @class='MathClass-open-close' ] + / child::mrow[ + not( child::*[ + not(self::mo) and not(self::mn-group-s) + and not(self::mi) and not(self::BREAK) + and not( @title='speech-extra' ) + ]) + ] +]" > + <xsl:copy> + `<shallow delimited expression`> + </xsl:copy> +</xsl:template> +>>> + +\<shallow delimited expression\><<< +<xsl:attribute name="class"> + <xsl:text>semi-math</xsl:text> +</xsl:attribute> +<PROS PITCH="-5"> +<BREAK SIZE="small"/> + <xsl:apply-templates select="mrow" /> +<BREAK SIZE="small"/> +</PROS> +>>> + + + +%%%%%%%%%%%%%%%%%% +\section{Superscripts and Subscripts} +%%%%%%%%%%%%%%%%%% + +%%%%%%%%%%%%% +\subsection{Insert Sub-Levels Info} +%%%%%%%%%%%%% + + + + +\<set levels for sub and sup scripts\><<< +<dom name="." xml="." method="scriptLevel" class="tex4ht.HtJsml" /> +`<remove xml declaration`> +>>> + + + +\<static void scriptLevel(dom)\><<< +public static void scriptLevel(Node dom) { + setScriptLevel(dom.getFirstChild(), ""); +} +private static void setScriptLevel(Node node, String prefix) { + String clName = null; + if (node.hasChildNodes()) { + if (node.hasAttributes()) { + Node cl = node.getAttributes().getNamedItem("class"); + if (cl != null) { + clName = cl.getNodeValue(); + if( clName.equals("mrow-sub") + || + clName.equals("mrow-super") + ){ + `<append script prefix`> + } } } + String ndName = node.getNodeName(); + if( + ndName.equals("msqrt") + || + ndName.equals("mroot") + ){ prefix = ""; } + `<script invoke children`> +} } +>>> + +\<script invoke children\><<< +NodeList children = node.getChildNodes(); +for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE) { + setScriptLevel(child, prefix); +} } +>>> + +\<append script prefix\><<< +if( !prefix.equals("") ){ + `<use current script prefix`> +} +if( clName.equals( "mrow-sub" ) ){ + prefix += " sub "; +} else if( clName.equals( "mrow-super" ) ){ + prefix += " super "; +} +>>> + + +\<use current script prefix\><<< +Node child = node.getFirstChild(); +if( (child.getNodeType() == Node.ELEMENT_NODE) + && + child.hasAttributes() +){ + Node cls = child.getAttributes().getNamedItem("class"); + if (cls != null) { + String clsName = cls.getNodeValue(); + if ( clsName.equals("begin-script") + || + clsName.equals("mid-script") + ) { + child = child.getFirstChild(); + String s = child.getNodeValue(); + ((org.w3c.dom.Text) child).setData( prefix + s ); +} } } +>>> + + + +%%%%%%%%%%%%% +\subsection{Eliminate End Script Marks} +%%%%%%%%%%%%% + + +The following takes care of end-scripts that semantically can be +merged into other end markers. + +\<eliminate baseline script marks\><<< +<xsl:template match="span[ + (@class = 'end-script') + and + ancestor::* [ following-sibling::* [ + not( @class = 'content-less' ) + ] + ][1] + / following-sibling::* [ + not( @class = 'content-less' ) + ][1] + / self::* + [ + (@class = 'end-math') + or + (@class = 'end-script') + or + (@class = 'end-root') + or + (@class = 'end-stack') + or + (@class = 'mid-stack') + or + (@class = 'end-array') + or + self::td or self::mtd or self::tr or self::mtr + or + (@title = 'implicit-baseline') + ] +]" > + <BREAK SIZE="small"/> +</xsl:template> +>>> + + + + + + +The following deals with endscripts before left sides of +tensors. + + + +\<eliminate baseline script marks\><<< +<xsl:template match="span[ + (@class = 'end-script') + and + parent::mrow / parent::msub + and + ancestor::* [ following-sibling::* ][1] + / following-sibling::* [ normalize-space(.) != '' ][1] + [ + (self::msub or self::msubsup) + and + (normalize-space(child::mrow[ + @class = 'mrow-base' ]) = '') + ] +]" > + <BREAK SIZE="small"/> +</xsl:template> +>>> + + + +\<eliminate baseline script marks\><<< +<xsl:template match="span[ + (@class = 'end-script') + and + parent::mrow /parent::*[ self::msup or self::msubsup] + and + ancestor::* [ following-sibling::* ][1] + / following-sibling::* [ normalize-space(.) != '' ][1] + [ + self::msup + and + (normalize-space(child::mrow[ + @class = 'mrow-base' ]) = '') + ] +]" > + <BREAK SIZE="small"/> +</xsl:template> +>>> + + + + + + + + +\begin{verbatim} + <span class="end-script" title="speech-extra"> + <PROS PITCH="-5"> + <BREAK SIZE="medium"/> + <span class="scripts-extra"> baseline </span> + <BREAK SIZE="small"/> + </PROS> + </span> + </mrow> +</msup> +<span class="tiny-space"/> +<msup> + <mrow class="mrow-base"/> + <mrow class="mrow-super"> + +\end{verbatim} + +%%%%%%%%%%%%% +\subsection{Clean Script Marks} +%%%%%%%%%%%%% + + +\<clean begin and mid script marks\><<< +<xsl:template match="span[ + (@class = 'begin-script') + or (@class = 'mid-script') +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select="*|text()|comment()" + mode="clean-script" /> + </xsl:copy> +</xsl:template> +<xsl:template match="*" mode="clean-script" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select="*|text()|comment()" + mode="clean-script" /> + </xsl:copy> +</xsl:template> +<xsl:template match="text()" mode="clean-script" > +</xsl:template> +<xsl:template match="span[@class = 'scripts-extra']" + mode="clean-script" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:value-of select=" + ancestor::span[ + (@class = 'begin-script') + or (@class = 'mid-script') ] [1] + " /> + </xsl:copy> +</xsl:template> +>>> + +The following is for script annotation on empty msu::base. + +\<remove marks on empty scripts\><<< +<xsl:template match="span[ + ((@class = 'begin-script') or (@class = 'mid-script')) + and + following-sibling::* + / following-sibling::span[ @class = 'end-script' ] + and + following-sibling::*[1] + / descendant-or-self::*[ not(self::PROS) ][1] + / child::*[1][ + (@class = 'mrow-base') + and + (normalize-space(.)='') + ] +]" > +</xsl:template> +>>> + +\begin{verbatim} +<span class="begin-script" title="speech-extra"> + ... +</span> +<PROS PITCH="+10"> + <msub> + <mrow class="mrow-base"/> + <mrow class="mrow-sub"> + ... + </mrow> + </msub> + <mi>n</mi> +</PROS> +<span class="end-script" title="speech-extra"> + ... +\end{verbatim} + + + +%%%%%%%%%%%%% +\subsection{Replace Nested Baseline Script Marks} +%%%%%%%%%%%%% + + +\<replace nested baseline script marks\><<< +<xsl:template match="span[ + (@class = 'end-script') + and + ancestor::*[ preceding-sibling::* [ + ((@class = 'begin-script') or (@class = 'mid-script')) ]] +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select=" + ancestor::*[ preceding-sibling::* [ + ((@class = 'begin-script') or + (@class = 'mid-script')) ]][1] + / preceding-sibling::* [ + ((@class = 'begin-script') or + (@class = 'mid-script')) ][1] + " mode="script-copy" /> + </xsl:copy> +</xsl:template> +>>> + + + +\<replace nested baseline script marks\><<< +<xsl:template match="*|@*|text()|comment()" + mode="script-copy" > + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:copy> +</xsl:template> +<xsl:template match="span[ + (@class = 'begin-script') or + (@class = 'mid-script') ]" mode="script-copy" > + <xsl:apply-templates select="*|text()|comment()" /> +</xsl:template> +>>> + + +%%%%%%%%%%%%% +\subsection{Eliminate Begin Script Marks} +%%%%%%%%%%%%% + + + +\<eliminate begin script marks\><<< +<xsl:template match="span[ + (@class = 'begin-script') + and + following-sibling::* [1] / child::*[ + (position() = 1) + and + (@class = 'mrow-base') + and + ( normalize-space(.) = '' ) + ] +]" > +</xsl:template> +>>> + + + +%%%%%%%%%%%%% +\subsection{Undo Empty Scripts} +%%%%%%%%%%%%% + + + + +\<special sub and super scripts\><<< +<script element="msup" > + <set name="m-sub-sup" > + `<open xslt script`> + `<undo if empty su`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="m-sub-sup" /> + `<superscript 2 and 3 into verbose`> +</script> +<script element="msub" > + `<sub script`> +</script> +<script element="msubsup" > + `<subsup prime`> + `<sub sup script`> + `<sub superscript 2 and 3 into verbose`> +</script> +>>> + +\<sub sup script\><<< +<set name="m-sub-sup" > + `<open xslt script`> + `<undo if empty su`> + `<close xslt script`> +</set> +<xslt name="." xml="." xsl="m-sub-sup" /> +>>> + + + +\<sub script\><<< +<set name="m-sub-sup" > + `<open xslt script`> + `<undo if empty su`> + `<msub of log`> + `<close xslt script`> +</set> +<xslt name="." xml="." xsl="m-sub-sup" /> +>>> + +\<undo if empty su\><<< +<xsl:template match="*[ + (self::msup or self::msub or self::msubsup) + and + not( + child::mrow[ @class = 'mrow-sub' ] + / child::*[ not(@title = 'speech-extra') + and + (normalize-space(.) != '') + ] + ) + and + not( + child::mrow[ @class = 'mrow-super' ] + / child::*[ not(@title = 'speech-extra') + and + (normalize-space(.) != '') + ] + ) +]" > + <xsl:apply-templates select="child::mrow[ + @class = 'mrow-base' ]/*" /> +</xsl:template> +>>> + + + +\begin{verbatim} +<msup> + <mrow class="mrow-base"> + ......... + </mrow> + <wrow class="mrow-super"> + <span class="begin-script"> superscript </span> + <span class="end-script"> baseline </span> + </mrow> +</msup> +\end{verbatim} + + + + +%%%%%%%%%%%%% +\section{Special Subscripts and Superscripts} +%%%%%%%%%%%%% + +%%%%%%%%%%%%% +\subsection{Squared} +%%%%%%%%%%%%% + + + +\<superscript 2 and 3 into verbose\><<< +<set name="m-sup-2-3" > + `<open xslt script`> + `<superscript into squared and cube`> + `<close xslt script`> +</set> +<xslt name="." xml="." xsl="m-sup-2-3" /> +>>> + +\<superscript into squared and cube\><<< +<xsl:template match="msup[ + (normalize-space( + child::mrow[ (@class = 'mrow-super') ] + / child::*[ not (@class = 'begin-script') + and + not (@class = 'end-script') + ] + ) = '2') + and `<su verbose not on op`> + and (normalize-space(mrow[@class = 'mrow-base']) != '' ) +]" > + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" + mode="squared" /> + </xsl:copy> +</xsl:template> +>>> + + +\<su verbose not on op\><<< +not( + child::mrow[ @class = 'mrow-base' ] + / child::span[ not( @title = 'speech-extra' ) ] + [ position() = last() ] + / self::* [ @class = 'mo-op' ] +) +>>> + + + + +\<superscript into squared and cube\><<< +<xsl:template match="*|@*|text()|comment()" + mode="squared" > + <xsl:copy> + <xsl:choose> + <xsl:when test=" @class = 'mrow-super' "> + <xsl:apply-templates select="@*" /> + <mo class="mo-op"> + <xsl:text> squared </xsl:text> + </mo> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()" /> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + + + + + +\begin{verbatim} +<msup> + <mrow class="mrow-base"> + <mo class="mo-op">cos</mo> + </mrow> + <mrow class="mrow-super"> + <span class="begin-script"> superscript </span> + <span class="mn">2</span> + <span class="end-script"> baseline </span> + </mrow> +</msup> +\end{verbatim} + + + + +\<superscript into squared and cube\><<< +<xsl:template match="msup[ + (normalize-space( + child::mrow[ (@class = 'mrow-super') ] + / child::*[ not (@class = 'begin-script') + and + not (@class = 'end-script') + ] + ) = '3') + and `<su verbose not on op`> + and (normalize-space(mrow[@class = 'mrow-base']) != '' ) +]" > + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" + mode="cube" /> + </xsl:copy> +</xsl:template> +>>> + + + +\<superscript into squared and cube\><<< +<xsl:template match="*|@*|text()|comment()" + mode="cube" > + <xsl:copy> + <xsl:choose> + <xsl:when test=" @class = 'mrow-super' "> + <xsl:apply-templates select="@*" /> + <mo class="mo-op"> + <xsl:text> cube </xsl:text> + </mo> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()" /> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + +\<sub superscript 2 and 3 into verbose\><<< +<set name="m-subsup-2-3" > + `<open xslt script`> + `<subsup into sub squared and cube`> + `<close xslt script`> +</set> +<xslt name="." xml="." xsl="m-subsup-2-3" /> +>>> + + + + + +\<subsup into sub squared and cube\><<< +<xsl:template match="msubsup[ + (normalize-space( + child::mrow[ (@class = 'mrow-super') ] + / child::span[ (@class != 'mid-script') + and + (@class != 'end-script') + ] + ) = '2') + and `<su verbose not on op`> +]" > + <xsl:copy> + <xsl:attribute name="class" > + <xsl:text>msub</xsl:text> + </xsl:attribute> + <xsl:apply-templates select="*|text()|comment()" + mode="sub-squared" /> + </xsl:copy> +</xsl:template> +>>> + + + +\<subsup into sub squared and cube\><<< +<xsl:template match="*|@*|text()|comment()" + mode="sub-squared" > + <xsl:copy> + <xsl:choose> + <xsl:when test=" @class = 'mrow-sub' "> + <xsl:apply-templates select="*[ + not( @class = 'end-script' ) + ] + |@*|text()|comment()" /> + <xsl:apply-templates select=" + following-sibling::*[1] / *[ + @class = 'end-script' + ] " /> + </xsl:when> + <xsl:when test=" @class = 'mrow-super' "> + <xsl:attribute name="class" > + <xsl:text>squared-super</xsl:text> + </xsl:attribute> + <mo class="mo-op"> + <xsl:text> squared </xsl:text> + </mo> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + +\<subsup into sub squared and cube\><<< +<xsl:template match="msubsup[ + (normalize-space( + child::mrow[ (@class = 'mrow-super') ] + / child::span[ (@class != 'mid-script') + and + (@class != 'end-script') + ] + ) = '3') + and `<su verbose not on op`> +]" > + <xsl:copy> + <xsl:attribute name="class" > + <xsl:text>msub</xsl:text> + </xsl:attribute> + <xsl:apply-templates select="*|text()|comment()" + mode="sub-cube" /> + </xsl:copy> +</xsl:template> +>>> + + + +\<subsup into sub squared and cube\><<< +<xsl:template match="*|@*|text()|comment()" + mode="sub-cube" > + <xsl:copy> + <xsl:choose> + <xsl:when test=" @class = 'mrow-sub' "> + <xsl:apply-templates select="*[ + not( @class = 'end-script' ) + ] + |@*|text()|comment()" /> + <xsl:apply-templates select=" + following-sibling::*[1] / *[ + @class = 'end-script' + ] " /> + </xsl:when> + <xsl:when test=" @class = 'mrow-super' "> + <xsl:attribute name="class" > + <xsl:text>cube-super</xsl:text> + </xsl:attribute> + <mo class="mo-op"> + <xsl:text> cube </xsl:text> + </mo> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + + +%%%%%%%%%%%%% +\subsection{Numeric Subscripts (Rule 77)} +%%%%%%%%%%%%% + +\<compress numeric subscripts\><<< + <set name="num-sub" > + `<open xslt script`> + `<num sub`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="num-sub" /> +>>> + + + +\<num sub\><<< +<xsl:template match="msub[ + ( + `<num sub on non-primed base`> + or + `<num sub on primed base`> + ) + and + child::mrow[ @class = 'mrow-sub' ] + / child::*[ not(@title = 'speech-extra') ][1] + / self::*[ + normalize-space(.) + = normalize-space( descendant::mn ) ] +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <BREAK SIZE="small"/> + <xsl:apply-templates select="*[1]" /> + <mrow class="mrow-sub"> + <xsl:apply-templates + select="*[2] / *[ + not(@title = 'speech-extra') + ]" /> + <BREAK SIZE="small"/> + </mrow> + </xsl:copy> +</xsl:template> +>>> + +\<num sub on non-primed base\><<< +(count( child::mrow[ @class = 'mrow-base' ] + / child::* ) = 1 ) + and child::mrow[ @class = 'mrow-base' ] / descendant::mi + and not( ancestor::*[ + self::msub or self::msup or self::msubsup + ] ) +>>> + +\<num sub on primed base\><<< +( + count( child::mrow[ @class = 'mrow-base' ] + / child::* [ + not(self::BREAK) + ] + ) = 2 ) + and child::mrow[ @class = 'mrow-base' ] [ + child::*[1][ self::mi ] + and + child::*[ + (position() > 1) + and + (normalize-space(.) = + normalize-space( + descendant-or-self::span[ + (@class = 'ch 2032') or (@class = 'ch 2033') + or (@class = 'ch 2034') + ] + )) + ] + ] + and not( ancestor::*[ + self::msub or self::msup or self::msubsup + ] ) +>>> + +\begin{verbatim} +<msub> + <mrow class="mrow-base"> + <mi>x</mi> + </mrow> + <mrow class="mrow-sub"> + <span class="begin-script" title="speech-extra"> subscript </span> + <mn>1</mn> + <span class="end-script" title="speech-extra"> baseline </span> + </mrow> +</msub> +\end{verbatim} + + + +\<num sub\><<< +<xsl:template match="msubsup[ + ( + `<num sub on non-primed base`> + ) + and + child::mrow[ @class = 'mrow-sub' ] + / child::*[ not(@title = 'speech-extra') ][1] + / self::*[ + normalize-space(.) + = normalize-space( descendant::mn ) ] +]" > + <msup> + <BREAK SIZE="small"/> + <xsl:apply-templates select="*[1]" /> + <mrow class="mrow-sub"> + <xsl:apply-templates + select="*[2] / *[ + not(@title = 'speech-extra') + ]" /> + <BREAK SIZE="small"/> + </mrow> + <xsl:apply-templates select="*[3]" /> + </msup> +</xsl:template> +>>> + +%%%%%%%%%%%%% +\subsection{Primes} +%%%%%%%%%%%%% + +\<remove scrip indicators from primes\><<< +<xsl:template match="span[ + (@class = 'begin-script') + and + following-sibling::*[ not(@title = 'speech-extra') ] [1] + / descendant-or-self::*[ not( self::PROS ) ][1] + / + child::span / child::span[ + (@class = 'ch 2032') or (@class = 'ch 2033') + or (@class = 'ch 2034') + ] +]" > + <BREAK SIZE="small"/> +</xsl:template> +>>> + + +\<remove scrip indicators from primes\><<< +<xsl:template match="span[ + (@class = 'end-script') + and + preceding-sibling::*[ not(@title = 'speech-extra') ] [1] + / descendant-or-self::*[ not( self::PROS ) ][1] + / + child::span / child::span[ + (@class = 'ch 2032') or (@class = 'ch 2033') + or (@class = 'ch 2034') + ] +]" > + <BREAK SIZE="small"/> +</xsl:template> +>>> + + + +\begin{verbatim} +<span class="msup"> + <span class="mrow-base"> + <span class="mi">x</span> + </span> + <span class="mrow-super"> + <span class="begin-script"> superscript </span> + <span class="mo-op"> + <span class="char"> + <span class="ch 2033">double prime</span> + </span> + </span> + <span class="end-script"> baseline </span> + </span> +</span> +\end{verbatim} + +\<subsup prime\><<< +<set name="subsup-prime" > + `<open xslt script`> + `<compress subsup prime`> + `<close xslt script`> +</set> +<xslt name="." xml="." xsl="subsup-prime" /> +>>> + + +\<compress subsup prime\><<< +<xsl:template match="msubsup[ + (count( + child::mrow [ @class='mrow-super' ] + / child::* [ not(@title = 'speech-extra') ] + ) = 1) + and + not( + child::mrow [ @class='mrow-super' ] + / child::* [ not(@title = 'speech-extra') ] + / descendant::*[ preceding-sibling::* + or following-sibling::*] + ) + and + child::mrow [ @class='mrow-super' ] + / child::* [ not(@title = 'speech-extra') ] + / descendant-or-self::span[ @class='char' ] + / child::span[ + (@class = 'ch 2032') or (@class = 'ch 2033') + or (@class = 'ch 2034') + ] +]" > + <msub> + <mrow class="mrow-base"> + <xsl:apply-templates select=" + child::mrow[@class = 'mrow-base'] / * + " /> + <BREAK SIZE="small"/> + <xsl:apply-templates select=" + child::mrow[@class = 'mrow-super'] + / child::* [ not(@title = 'speech-extra') ] + " /> + </mrow> + <mrow class="mrow-sub"> + <xsl:apply-templates + select="*[@class = 'mrow-sub'] /* " /> + <xsl:apply-templates select=" + child::mrow[@class = 'mrow-super'] + / child::* [ @class = 'end-script' ] + " /> + </mrow> + </msub> +</xsl:template> +>>> + + + +\begin{verbatim} +<span class="msubsup"> + <span class="mrow-base"> + <span class="mi">x</span> + </span> + <span class="mrow-sub"> + ...... + </span> + <span class="mrow-super"> + <span class="mid-script" title="speech-extra"> superscript </span> + <span class="mi"> + <span class="char" title="ch-verbose"> + <span class="ch 2032" title="ch-verbose">prime</span> + </span> + </span> + </span> +</span> +\end{verbatim} + + + +%%%%%%%%%%%%% +\subsection{Degree} +%%%%%%%%%%%%% + +\<remove scrip indicators from degree\><<< +<xsl:template match="mrow[ + (@class = 'mrow-super') + and + parent::msup + and + (count( `<math content element`> ) = 1) + and + `<math content element`> [1][ + normalize-space(.) + = + normalize-space( + descendant::span[@class = 'ch 2218'] + ) + ] +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates + select="*[not(@title = 'speech-extra') + and + not(self::BREAK) + ]" + mode="degree" /> + <BREAK SIZE="small"/> + </xsl:copy> +</xsl:template> +>>> + +\<remove scrip indicators from degree\><<< +<xsl:template match="*" mode="degree" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:choose> + <xsl:when test="self::span[ @class='ch 2218' ]" > + <xsl:text>degree</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates + select="*[not(self::BREAK)]|text()" + mode="degree"/> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + + + + +%%%%%%%%%%%%% +\subsection{Logarithms} +%%%%%%%%%%%%% + +\<msub of log\><<< +<xsl:template match=" + msub [ + normalize-space(child::*[1]) = 'log' + or + normalize-space(child::*[1]) = 'ln' +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select="child::*[1]" /> + <xsl:apply-templates select="child::*[2]" + mode="log" /> + </xsl:copy> +</xsl:template> +>>> + +\<msub of log\><<< +<xsl:template match="*" mode="log" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:choose> + <xsl:when test="parent::mrow[ @class = 'mrow-sub' ]" > + <BREAK SIZE="small"/> + <xsl:apply-templates select="*" /> + <BREAK SIZE="small"/> + <span title="speech-extra"> + <xsl:text>of</xsl:text> + </span> + <BREAK SIZE="small"/> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates + select="*[ not(@title = 'speech-extra') ]" + mode="log" /> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + +\begin{verbatim} +<msub> + <mrow class="mrow-base"> + <mo class="MathClass-op">log<BREAK SIZE="small"/></mo> + </mrow> + <mrow class="mrow-sub"> + <span class="begin-script" title="speech-extra"> + ... + </span> + <PROS PITCH="-10"> + <mn>2</mn> + </PROS> + <span class="end-script" title="speech-extra"> + ... + </span> + </mrow> +</msub> +<mi>x</mi> +\end{verbatim} + + +%%%%%%%%%%%%%%%%%% +\section{Fractions (Stage 1)} +%%%%%%%%%%%%%%%%%% + +%%%%%%%%%%%%% +\subsection{Outline} +%%%%%%%%%%%%% + + + +\<span frac elements\><<< +<script element="mfrac" > + <set name="mfrac" > + `<open xslt script`> + `<frac templates`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="mfrac" /> +</script> +>>> + +\<frac templates\><<< +<xsl:template match="mfrac" > + <xsl:copy> + <xsl:choose> + `<word fracs`> + `<prepend continued fractions`> + `<tail continued fractions`> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + + +%%%%%%%%%%%%% +\subsection{Word Fractions} +%%%%%%%%%%%%% + +Example: `\verb+1 \ove 2+' int `one half' + +\<word fracs\><<< +<xsl:when test=" + (string-length( + normalize-space(child::mrow[ @class = 'mrow-numerator' ][1]) + ) = 1) + and + (string-length( + normalize-space(child::mrow[ @class = 'mrow-enumerator' ][1]) + ) = 1) +"> + `<a := numerator; b := enumerator`> + <xsl:choose> + <xsl:when test=" + (translate($a,'123456789','') != '') + or + (translate($b,'123456789','') != '') + " > + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:when> + <xsl:when test=" $a < $b "> + <xsl:attribute name="class"> + <xsl:text>word-frac</xsl:text> + </xsl:attribute> + `<word numerator`> + `<word enumerator`> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:otherwise> + </xsl:choose> +</xsl:when> +>>> + + +\<a := numerator; b := enumerator\><<< +<xsl:variable name="a"> + <xsl:value-of select=" + normalize-space(child::mrow[ @class = 'mrow-numerator' ][1]) + " /> +</xsl:variable> +<xsl:variable name="b"> + <xsl:value-of select=" + normalize-space(child::mrow[ @class = 'mrow-enumerator' ][1]) + " /> +</xsl:variable> +>>> + + +\<word numerator\><<< +<xsl:choose> + <xsl:when test=" $a = 1 "><xsl:text> one </xsl:text></xsl:when> + <xsl:when test=" $a = 2 "><xsl:text> two </xsl:text></xsl:when> + <xsl:when test=" $a = 3 "><xsl:text> three </xsl:text></xsl:when> + <xsl:when test=" $a = 4 "><xsl:text> four </xsl:text></xsl:when> + <xsl:when test=" $a = 5 "><xsl:text> five </xsl:text></xsl:when> + <xsl:when test=" $a = 6 "><xsl:text> six </xsl:text></xsl:when> + <xsl:when test=" $a = 7 "><xsl:text> seven </xsl:text></xsl:when> + <xsl:when test=" $a = 8 "><xsl:text> eight </xsl:text></xsl:when> + <xsl:when test=" $a = 9 "><xsl:text> nine </xsl:text></xsl:when> +</xsl:choose> +>>> + + +\<word enumerator\><<< +<xsl:choose> + <xsl:when test=" $b = 2 "><xsl:text> half</xsl:text></xsl:when> + <xsl:when test=" $b = 3 "><xsl:text> third</xsl:text></xsl:when> + <xsl:when test=" $b = 4 "><xsl:text> fourth</xsl:text></xsl:when> + <xsl:when test=" $b = 5 "><xsl:text> fifth</xsl:text></xsl:when> + <xsl:when test=" $b = 6 "><xsl:text> sixth</xsl:text></xsl:when> + <xsl:when test=" $b = 7 "><xsl:text> seventh</xsl:text></xsl:when> + <xsl:when test=" $b = 8 "><xsl:text> eighth</xsl:text></xsl:when> + <xsl:when test=" $b = 9 "><xsl:text> nineth</xsl:text></xsl:when> +</xsl:choose> +<xsl:if test=" $a > 1 "><xsl:text>s</xsl:text></xsl:if> +<xsl:text> </xsl:text> +>>> + + + +%%%%%%%%%%%%% +\subsection{Mixed Fractions} +%%%%%%%%%%%%% + +Examples: `\verb+2{3\over 4}+' +into `2 and three forth', +and `\verb+10{25\over 39}+' into `10 and 25 over 39'. + +\<mixed fractions\><<< +<xsl:template match="mfrac[ + ( + (translate( + concat( + mrow[ (@class = 'mrow-numerator')], + mrow[ (@class = 'mrow-enumerator')] + ) ,'0123456789','') = '') + and + not(descendant::*/descendant::* + /descendant::mn-group-s) + or + (@class = 'word-frac') + ) + and + preceding-sibling::*[1] + / self::mn-group-s[ child::*[ + (position() = last()) + and + self::mn + ] ] + ]" > + <xsl:text> and </xsl:text> + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:copy> +</xsl:template> +>>> + + + + +%%%%%%%%%%%%% +\subsection{Continued Fractions Conditions (Rule 69)} +%%%%%%%%%%%%% + + + +\begin{verbatim} + 1 +1 + --------------------------------------- + 1 + 2 + --------------------------------------- + 1 + 2 + --------------------------------------- + 2 + ... +\end{verbatim} + + +The fractions are processed recusrively from inside out. The `tail' +is the one to discover the inner most part of a continued fraction +(i.e., the bottom rows). Higher levels add to the nucleous built +already under them. + +In Stage 1 the members of the continued fractions are marked as +such. In the second stage they being are procesed. + + +The minimum conditions here are three un-interrupted levels of +fractions. + +\begin{verbatim} +<mfrac> + <mrow class="mrow-enumerator"> + <mn>1</mn> + <mo class="MathClass-bin">...</mo> + <mfrac> + <span class="begin-end" ...>begin fraction</span> + <mrow class="mrow-numerator"> ... </mrow> + <span class="begin-end" ...>over</span> + <mrow class="mrow-enumerator">...</mrow> + <span class="begin-end" ...>end fraction</span> + </mfrac> +\end{verbatim} + +\<a,b := top 2 pre op values\><<< +<xsl:variable name="a"> + <xsl:apply-templates select=" + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[2] + " mode="enum-op" /> +</xsl:variable> +<xsl:variable name="b"> + <xsl:apply-templates select=" + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[2] + " mode="enum-op" /> +</xsl:variable> +<xsl:variable name="c"> + <xsl:value-of select=" + normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-enumerator' ] ) + " /> +</xsl:variable> +>>> + +\<frac templates\><<< +<xsl:template match="*" mode="enum-op"> + <xsl:if test="preceding-sibling::*" > + <xsl:apply-templates select=" preceding-sibling::*[1] " /> + </xsl:if> + <xsl:value-of select="." /> +</xsl:template> +>>> + + + + + +%%%%%%%%%%%%% +\subsection{Nucleous of Continued Fractions} +%%%%%%%%%%%%% + +We are looking for the three most internal (bottom) fractions that +belong to a continued fraction. + + +\<tail continued fractions\><<< +<xsl:when test=" `%check numeral numerator`% + (translate( + normalize-space( + child::mrow[ @class = 'mrow-numerator' ]), + '0123456789','')= '') + and `<check equality of numerators`> + and `<check ops before two top fracs`> +"> + `<a,b := top 2 pre op values`> + <xsl:choose> + <xsl:when test=" + ( translate($a,'0123456789 ','') = '') + and (normalize-space($a)=normalize-space($b)) + and starts-with( $c, normalize-space( $a )) + and starts-with( + normalize-space( + substring-after( $c, normalize-space( $a )) ) + , + normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[1] ) + ) + " > + <xsl:attribute name="class"> + <xsl:value-of select=" 'continued-mfrac' " /> + </xsl:attribute> + <xsl:apply-templates select="*|text()|comment()" /> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:otherwise> + </xsl:choose> +</xsl:when> +>>> + + + + + +\<check equality of numerators\><<< +( normalize-space( + child::mrow[ @class = 'mrow-numerator' ]) + and + normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-numerator' ]) +) +and +( normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-numerator' ]) + and + normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-numerator' ]) +) +>>> + + + +\<check ops before two top fracs\><<< +( child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[1][@class = 'MathClass-bin'] +) +and +( normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[1] ) + = + normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::mrow[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[1] ) +) +>>> + + + + +%%%%%%%%%%%%% +\subsection{Prepend Existing Continued Fractions} +%%%%%%%%%%%%% + + +\<prepend continued fractions\><<< +<xsl:when test=" + self::mfrac + and + child::mrow[ @class = 'mrow-enumerator' ] + / child::mfrac[ @class = 'continued-mfrac' ] + and + ( normalize-space( + child::mrow[ @class = 'mrow-numerator' ] + ) + = + normalize-space( + child::mrow[ @class = 'mrow-enumerator' ] + / child::mfrac[ @class = 'continued-mfrac' ] + / child::mrow[ @class = 'mrow-numerator' ] + ) + ) + and `<check equality of op with cont frac`> +" > + `<a,b := cont top 2 pre op values`> + <xsl:choose> + <xsl:when test=" + normalize-space($a)=normalize-space($b) + " > + <xsl:attribute name="class"> + <xsl:value-of select=" 'continued-mfrac' " /> + </xsl:attribute> + <xsl:apply-templates select="*|text()|comment()" /> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:otherwise> + </xsl:choose> +</xsl:when> +>>> + + + +\<check equality of op with cont frac\><<< +( + normalize-space( + child::span[ @class = 'mrow-enumerator' ] / + child::mfrac / + preceding-sibling::*[1] ) + = + normalize-space( + child::span[ @class = 'mrow-enumerator' ] / + child::mfrac / + child::span[ @class = 'mrow-enumerator' ] / + child::span[ @class = 'continued-mfrac' ] / + preceding-sibling::*[1] ) +) +>>> + + +\<a,b := cont top 2 pre op values\><<< +<xsl:variable name="a"> + <xsl:apply-templates select=" + child::span[ @class = 'mrow-enumerator' ] / + child::span[ @class = 'mcontinued-mfrac' ] / + preceding-sibling::*[2] + " mode="enum-op" /> +</xsl:variable> +<xsl:variable name="b"> + <xsl:apply-templates select=" + child::span[ @class = 'mrow-enumerator' ] / + child::span[ @class = 'mcontinued-mfrac' ] / + child::span[ @class = 'mrow-enumerator' ] / + child::span[ + self::mfrac or (@class = 'mcontinued-mfrac') + ] / + preceding-sibling::*[2] + " mode="enum-op" /> +</xsl:variable> +>>> + + + + +%%%%%%%%%%%%%%%%%% +\section{Fractions (Stage 2)} +%%%%%%%%%%%%%%%%%% + +%%%%%%%%%%%%% +\subsection{Outline} +%%%%%%%%%%%%% + + +\<set levels for hyper complex fracs\><<< +<dom name="." xml="." method="fracLevel" class="tex4ht.HtJsml" /> +`<remove xml declaration`> +>>> + + + +\<static void fracLevel(dom)\><<< +public static void fracLevel(Node d) { + dom = (Document) d; + setFracLevel(dom.getFirstChild(), 0); +} +private static int setFracLevel(Node node, int cont) { + int level = 0; + if (node.hasChildNodes()) { + String ndName = node.getNodeName(); + int prevCont = cont; + String clValue = null; + if (ndName.equals("mfrac")) { + `<clValue := class of mfrac`> + `<cont := distance from mfrac(continued-frac)`> + } + `<level += inherited from children`> + `<return 0 if barier`> + if (ndName.equals("mfrac")) { + `<return 0 if mfrac barier`> + if( cont > 0 ){ + if ( prevCont == 0 ){ + `<set start continued fracs mark`> + } + `<remove end of non-tail continued frac`> + level = 0; + } else if ( prevCont > 0 ){ + `<set end continued fracs mark`> + level = 0; + } else + if( level > 0 ){ + `<set extra levels for frac`> + } + level++; + } } + return level; +} +>>> + + + +%%%%%%%%%%%%%%%%%% +\subsection{Level Indicators for Nesting (Hyper Complex Fractions)} +%%%%%%%%%%%%%%%%%% + +\begin{verbatim} + ${a\over b}\over c$ + +begin begin fraction + begin fraction a + over b + end fraction +over over c +end end fraction +\end{verbatim} + +\<set extra levels for frac\><<< +for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE) { + Node cls = child.getAttributes() + .getNamedItem("class"); + if (cls != null) { + String clsName = cls.getNodeValue(); + if (clsName.equals("begin-end")) { + insertLevelPrefix(child, level); +} } } } +>>> + +\<HtJsml utility members\><<< +private static void insertLevelPrefix(Node node, int level){ + if( level == 0 ){ return; } + if (node.getNodeType() == Node.ELEMENT_NODE) { + if( node.getNodeName().equals( "level" ) ){ + `<insert level prefixes`> + } else { + NodeList children = node.getChildNodes(); + for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + insertLevelPrefix(child, level); +} } } } +>>> + + + + +\<insert level prefixes\><<< +Node attr = node.getAttributes().getNamedItem("prefix"); +if( attr != null ){ + String prefix = attr.getNodeValue(); + String s = ""; + for(int j=0; j<level; j++){ + s += prefix + " "; + } + ((org.w3c.dom.Element) node).setAttribute( "depth", ""+level); + Node child = node.getFirstChild(); + if( child != null ){ + node.insertBefore( dom.createTextNode(s), child ); +} } +>>> + + + +\<level += inherited from children\><<< +NodeList children = node.getChildNodes(); +int max = 0; +for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE) { + int d = setFracLevel(child, + `<continued level counter`>); + if (d > max) { max = d; } +} } +level += max; +>>> + + +%%%%%%%%%%%%% +\subsection{Level Terminators: Scripts, Word Fracs} +%%%%%%%%%%%%% + + +\<return 0 if barier\><<< +if( ndName.equals("msub") + || ndName.equals("msup") + || ndName.equals("msubsup") +) { + return 0; +} +>>> + + +\<return 0 if mfrac barier\><<< +if( (clValue != null) && clValue.equals("word-frac") +) { + return 0; +} +>>> + + + + + + + + + + +%%%%%%%%%%%%% +\subsection{Bookeeping for Continued Fractions} +%%%%%%%%%%%%% + +\<continued level counter\><<< +cont +>>> + + +In the first phase, the mfrac elements in a group carry +attributes as in + +\begin{verbatim} + <mfrac class="continued-mfrac"> +\end{verbatim} + + +with the exception of the bottom (internal) most leveles. +The `cont' parameter is for determining whether the parent and the +grandparent are frac elements marked as continued. + + + +\<clValue := class of mfrac\><<< +if (node.hasAttributes()) { + Node cl = node.getAttributes().getNamedItem("class"); + if (cl != null) { clValue = cl.getNodeValue(); } +} +>>> + +\<cont := distance from mfrac(continued-frac)\><<< +if( (clValue != null) + && clValue.equals("continued-mfrac") ) { + cont = 2; +} else { cont--; } +>>> + + + +%%%%%%%%%%%%% +\subsection{Modifications for Continued Fractions} +%%%%%%%%%%%%% + +\<remove end of non-tail continued frac\><<< +Node child = node.getLastChild(); +if (child.getNodeType() == Node.ELEMENT_NODE) { + Node cls = child.getAttributes() .getNamedItem("class"); + if (cls != null) { + String clsName = cls.getNodeValue(); + if ( clsName.equals("begin-end")) { + node.removeChild( child ); +} } } +>>> + +\<set end continued fracs mark\><<< +Node child = node.getLastChild(); +if (child.getNodeType() == Node.ELEMENT_NODE) { + Node cls = child.getAttributes() .getNamedItem("class"); + if (cls != null) { + String clsName = cls.getNodeValue(); + if ( clsName.equals("begin-end")) { + setContinuedNote(child); +} } } +>>> + +\<set start continued fracs mark\><<< +Node child = node.getFirstChild(); +if (child.getNodeType() == Node.ELEMENT_NODE) { + Node cls = child.getAttributes() .getNamedItem("class"); + if (cls != null) { + String clsName = cls.getNodeValue(); + if ( clsName.equals("begin-end")) { + setContinuedNote(child); +} } } +>>> + + +\<HtJsml utility members\><<< +private static void setContinuedNote(Node node){ + if (node.getNodeType() == Node.ELEMENT_NODE) { + if( node.getNodeName().equals( "level" ) ){ + `<fix end continued note`> + } else { + NodeList children = node.getChildNodes(); + for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + setContinuedNote(child); +} } } } +>>> + +\<fix end continued note\><<< +Node attr = node.getAttributes().getNamedItem("continued"); +if (attr != null) { + node = node.getFirstChild(); + if( node != null ){ + ((org.w3c.dom.Text) node).setData( attr.getNodeValue() ); +} } +>>> + + + + +%%%%%%%%%%%%% +\section{Set Levels on Roots} +%%%%%%%%%%%%% + +\<set levels for roots\><<< +<dom name="." xml="." method="rootLevel" class="tex4ht.HtJsml" /> +`<remove xml declaration`> +>>> + +\<static void rootLevel(dom)\><<< +public static void rootLevel(Node d) { + dom = (Document) d; + setRootLevel(d.getFirstChild()); +} +private static int setRootLevel( Node node ){ + int level = 0; +// String clName = null; + if (node.hasChildNodes()) { + `<count root levels inherited from children`> + String ndName = node.getNodeName(); + `<block for roots`> + if( ndName.equals("msqrt") || ndName.equals("mroot") ){ + `<set extra levels for roots`> + level++; + } } + return level; +} +>>> + + +\<count root levels inherited from children\><<< +NodeList children = node.getChildNodes(); +int max = 0; +for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE) { + int d = setRootLevel(child); + if( d > max ){ max = d; } +} } +level += max; +>>> + + +\<block for roots\><<< +if( ndName.equals("msub") || ndName.equals("msup") || + ndName.equals("msubsup") +) { + return 0; +} +>>> + + + + +\<set extra levels for roots\><<< +for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + if (child.getNodeType() == Node.ELEMENT_NODE) { + Node cls = child.getAttributes() + .getNamedItem("class"); + if (cls != null) { + String clsName = cls.getNodeValue(); + if( clsName.equals("begin-root") + || clsName.equals("mid-root") + || clsName.equals("end-root") + ){ + insertLevelPrefix(child, level); +} } } } +>>> + + + + +%%%%%%%%%%%%% +\section{Modifiers} +%%%%%%%%%%%%% + + + +%%%%%%%%%%%%%%%%%% +\subsection{Over and Under Limit Scripts} +%%%%%%%%%%%%%%%%%% + + +\<over and under scripts\><<< +<script element="msub::limits-msub-msup" > + <set name="smash" > + `<open xslt script`> + `<smash over and under scripts`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="smash" /> +</script> +>>> + +\<over and under scripts\><<< +<script element="msup::limits-msub-msup" > + <set name="smash" > + `<open xslt script`> + `<smash over and under scripts`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="smash" /> +</script> +>>> + +\<over and under scripts\><<< +<script element="msubsup::limits-msub-msup" > + <set name="smash" > + `<open xslt script`> + `<smash over and under scripts`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="smash" /> +</script> +>>> + + + + + + + +\<smash over and under scripts\><<< +<xsl:template match="*[ + (@class = 'limits-msub-msup') + and + child::*[ (position() = 1) + and (@class = 'limits-mrow-base') + and child::*[ (position() = 1) + and (@class = 'limits-msub-msup') + ] ] +]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select=" + *[1] + / *[1] + / *[ not(@class='limits-mrow-super') ] " /> + <xsl:apply-templates select=" *[ + preceding-sibling::* + and + not(@class='limits-mrow-super') ]" /> + <xsl:apply-templates select=" + *[1] + / *[1] + / *[@class='limits-mrow-super' ] " /> + <xsl:apply-templates select=" *[ + preceding-sibling::* + and + (@class='limits-mrow-super') ]" /> + </xsl:copy> +</xsl:template> +>>> + + +\<compress limit script\><<< +<xsl:template match="span[ @class = 'end-limits-script' ]" > + <xsl:if test=" parent::*[ not(following-sibling::*) ] "> + <xsl:copy> + <xsl:apply-templates select=" @* " /> + <xsl:choose> + <xsl:when test=" + parent::*[ preceding-sibling::mrow[ + @class != 'limits-mrow-base' + ] ] + " > + <BREAK SIZE="small"/> + <xsl:text> end scripts </xsl:text> + <BREAK SIZE="small"/> + </xsl:when> + <xsl:otherwise> + <BREAK SIZE="small"/> + <xsl:text> end script </xsl:text> + <BREAK SIZE="small"/> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> + </xsl:if> +</xsl:template> +>>> + + +\<compress limit script\><<< +<xsl:template match="span[ @class = 'begin-limits-script' ]" > + <xsl:copy> + <xsl:apply-templates select=" @* " /> + <xsl:choose> + <xsl:when test=" + parent::*[ @class = 'limits-mrow-super' ] + " > + <xsl:apply-templates + select=" parent::* + / preceding-sibling::*[1] " + mode = "extra-over" /> + </xsl:when> + <xsl:when test=" + parent::*[ @class = 'limits-mrow-sub' ] + " > + <xsl:apply-templates + select=" parent::* + / preceding-sibling::*[1] " + mode = "extra-under" /> + </xsl:when> + </xsl:choose> + <xsl:apply-templates select="*|text()|comment()" /> + </xsl:copy> +</xsl:template> +>>> + + + +\<compress limit script\><<< +<xsl:template match="*" mode="extra-over" > + <xsl:if test = " self::mrow[ @class = 'limits-mrow-super' ] " > + <xsl:text> over </xsl:text> + <xsl:apply-templates select=" preceding-sibling::*[1] " + mode = "extra-over" /> + </xsl:if> +</xsl:template> +>>> + + +\<compress limit script\><<< +<xsl:template match="*" mode="extra-under" > + <xsl:if test = " self::mrow[ @class = 'limits-mrow-sub' ] " > + <xsl:text> under </xsl:text> + <xsl:apply-templates select=" preceding-sibling::*[1] " + mode = "extra-under" /> + </xsl:if> +</xsl:template> +>>> + + + + +%%%%%%%%%%%%% +\subsection{Short Cuts for Math Underline} +%%%%%%%%%%%%% + + + +\<short cut modifiers\><<< +<script element="munder::munder-underline" > + <set name="munder" > + `<open xslt script`> + `<get content template`> + `<under modifier templates`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="munder" /> +</script> +>>> + +\<under modifier templates\><<< +<xsl:template match="munder[ + (@class = 'munder-underline') + and + child::mrow[ + (@class = 'mo-0332') + and + descendant::mi + ] +]" > + <xsl:variable name="content"> + <xsl:apply-templates select="*" mode="content" /> + </xsl:variable> + <xsl:choose> + <xsl:when test=" + string-length( normalize-space( $content )) = 1 + " > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates + select=" *[ @class != 'begin-end' ] " /> + <span class="begin-end" title="speech-extra" > + <BREAK SIZE="small"/> + <xsl:text> under bar </xsl:text> + <BREAK SIZE="small"/> + </span> + </xsl:copy> + </xsl:when> + <xsl:otherwise> + `<set munder`> + </xsl:otherwise> + </xsl:choose> +</xsl:template> +>>> + + + + +The following code makes to push the munder's under the mover's. + +\<set munder\><<< +<xsl:choose> + <xsl:when test="child::mrow / child::mover"> + <xsl:apply-templates select="child::mrow / child::mover" + mode="under-mover" /> + </xsl:when> + <xsl:otherwise> + <xsl:copy> + <xsl:apply-templates select=" *|@*|text() " /> + </xsl:copy> + </xsl:otherwise> +</xsl:choose> +>>> + +\<under modifier templates\><<< +<xsl:template match="*" mode="under-mover" > + <xsl:choose> + <xsl:when test="self::mover"> + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select="*" mode="under-mover" /> + </xsl:copy> + </xsl:when> + <xsl:when test="self::mrow[ parent::mover ]"> + <xsl:copy> + <xsl:apply-templates select="@*" /> + `<cont under-mover`> + </xsl:copy> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="." /> + </xsl:otherwise> + </xsl:choose> +</xsl:template> +>>> + +\<cont under-mover\><<< +<xsl:choose> + <xsl:when test="child::mover"> + <xsl:apply-templates select="*" mode="under-mover" /> + </xsl:when> + <xsl:otherwise> + <munder class="munder-underline"> + `<munder prefix`> + <mrow class="mo-0032"> + <xsl:apply-templates select="*" /> + </mrow> + `<munder postfix`> + </munder> + </xsl:otherwise> +</xsl:choose> +>>> + + + +\<munder prefix\><<< +<xsl:apply-templates select=" + ancestor::munder[1] / child::*[following-sibling::mrow] +"/> +>>> + + + +\<munder postfix\><<< +<xsl:apply-templates select=" + ancestor::munder[1] / child::*[preceding-sibling::mrow] +"/> +>>> + + + +\begin{verbatim} +<munder class="munder-underline"> + <span class="begin-end" title="speech-extra" > modified under </span> + <mrow class="mo-0332"> + <mi>x</mi> + </mrow> + <span class="begin-end" title="speech-extra" > with bar </span> +</munder> +\end{verbatim} + + + +%%%%%%%%%%%%% +\subsection{Short Cuts for Math Overline} +%%%%%%%%%%%%% + + +\<short cut modifiers\><<< +<script element="mover::mover-overline" > + <set name="mover" > + `<open xslt script`> + `<get content template`> + `<over modifier templates`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="mover" /> +</script> +>>> + + + + +\<over modifier templates\><<< +<xsl:template match="mover[ + (@class = 'mover-overline') + and + child::mrow[ + (@class = 'mo-00AF') + and + descendant::mi + ] +]" > + <xsl:variable name="content"> + <xsl:apply-templates select="*" mode="content" /> + </xsl:variable> + <xsl:choose> + <xsl:when test=" + string-length( normalize-space( $content )) = 1 + " > + `<set mover short cut`> + </xsl:when> + <xsl:otherwise> + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates + select="*|text()|comment()" /> + </xsl:copy> + </xsl:otherwise> + </xsl:choose> +</xsl:template> +>>> + + +The following code makes to push the mover's under the munder's. + +\<set mover short cut\><<< +<BREAK SIZE="small"/> +<xsl:choose> + <xsl:when test="child::mrow / child::munder"> + <xsl:apply-templates select="child::mrow / child::munder" + mode="under-munder" /> + </xsl:when> + <xsl:otherwise> + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates + select=" *[ @class != 'begin-end' ] " /> + `<mover bar short cut`> + </xsl:copy> + </xsl:otherwise> +</xsl:choose> +>>> + +\<over modifier templates\><<< +<xsl:template match="*" mode="under-munder" > + <xsl:choose> + <xsl:when test="self::munder"> + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:apply-templates select="*" mode="under-munder" /> + </xsl:copy> + </xsl:when> + <xsl:when test="self::mrow[ parent::munder ]"> + <xsl:copy> + <xsl:apply-templates select="@*" /> + `<cont under-munder`> + </xsl:copy> + </xsl:when> + <xsl:otherwise> + <xsl:apply-templates select="." /> + </xsl:otherwise> + </xsl:choose> +</xsl:template> +>>> + +\<cont under-munder\><<< +<xsl:choose> + <xsl:when test="child::munder"> + <xsl:apply-templates select="*" mode="under-munder" /> + </xsl:when> + <xsl:otherwise> + <mover class="mover-overline"> + <mrow class="mo-00AF"> + <xsl:apply-templates select="*" /> + </mrow> + `<mover bar short cut`> + </mover> + </xsl:otherwise> +</xsl:choose> +>>> + + + + + +\<mover bar short cut\><<< +<span class="begin-end" title="speech-extra" > + <BREAK SIZE="small"/> + <xsl:text> over bar </xsl:text> + <BREAK SIZE="small"/> +</span> +>>> + + + + +\begin{verbatim} +<mover class="mover-overline"> + <span class="begin-end" title="speech-extra"> modified above </span> + <mrow class="mo-00AF"> + <span class="mathvariant-bold"> + <span title="speech-extra" class="begin-end"> bold </span> + <mi class="mi"> + <span title="speech-extra" + class="capital-description"> capital </span> + Z + </mi> + </span> + </mrow> + <span class="begin-end" title="speech-extra"> with bar </span> +</mover> +\end{verbatim} + + + + + + + +%%%%%%%%%%%%% +\section{New Theorems} +%%%%%%%%%%%%% + +\<boundaries on theorems\><<< +<script element="div::newtheorem" > + <set name="newtheorem" > + `<open xslt script`> + `<annotate bounderies of theorems`> + `<tags for empty templates`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="newtheorem" /> +</script> +>>> + + +\<annotate bounderies of theorems\><<< +<xsl:template match=" + div[ (@class='newtheorem') + and + descendant::*[ self::p ][1] + / descendant::*[ self::span ][1] + [ @class = 'theorem-head' ] + ] +" > + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" /> + <div class="begin-end" title="speech-extra"> + <BREAK SIZE="small"/> + <xsl:value-of select=" + concat( ' end ', + substring-before(`<new theorem header`>, ' ') + ) " /> + </div> + </xsl:copy> +</xsl:template> +>>> + + +\<new theorem header\><<< +concat( + normalize-space( + string( + descendant::*[ self::p ][1] + / descendant::*[ self::span ][1] + [ @class = 'theorem-head' ] + ) ) + , ' ' +) +>>> + + +%%%%%%%%%%%%%%%%%% +\section{Shared} +%%%%%%%%%%%%%%%%%% + + + +\<open xslt script\><<< +<![CDATA[ + <xsl:stylesheet version="1.0" + xmlns:xsl="http://www.w3.org/1999/XSL/Transform" + > + <xsl:output omit-xml-declaration = "yes" /> +>>> + +\<close xslt script\><<< + <xsl:template match="*|@*|text()|comment()" > + <xsl:copy> + <xsl:apply-templates select="*|@*|text()|comment()" /> + </xsl:copy> + </xsl:template> + </xsl:stylesheet> +]]> +>>> + + +\<get content template\><<< +<xsl:template match="*" mode="content" > + <xsl:choose> + <xsl:when test=" @class = 'char' " > + <xsl:if test="not( child::*[ + (@class = 'ch 2032') or (@class = 'ch 2033') + or (@class = 'ch 2034') + ] )"> + <xsl:text>x</xsl:text> + </xsl:if> + </xsl:when> + <xsl:when test=" not( + (@title = 'speech-extra') or (@class = 'accent-char') + ) " > + <xsl:apply-templates select="*|text()" mode="content" /> + </xsl:when> + </xsl:choose> +</xsl:template> +>>> + + + + + +\marginpar{Can dom be prevented from creating an xml declaration in + the output? The xslt part is there just to remove the undesirable + declaration.} + + +\<remove xml declaration\><<< +<set name="rmXmlDecl" > + `<open xslt script`> + `<close xslt script`> +</set> +<xslt name="." xml="." xsl="rmXmlDecl" /> +>>> + + + + + + + + +\ifdojava +\AtEndDocument{\Needs{% + "pushd \XTPIPES + ; + jar cf tex4ht.jar * + ; + popd + ; + mv \XTPIPES tex4ht.jar \TEXMFTEXivBIN + ; + if [ ! -d \TEXMFTEXivXTPIPES\space]; then exit 1; fi + ; + cp \XTPIPES xtpipes/lib/* + \TEXMFTEXivXTPIPES +"}} +\fi + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\end{document} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + +%%%%%%%%%%%%%%%%%% +\section{Odd Ends} +%%%%%%%%%%%%%%%%%% + +%%%%%%%%%%%%% +\subsection{Font Decorations} +%%%%%%%%%%%%% + +\<bold math\><<< +<script element="span::mathvariant-bold" > + <set name="bold" > + `<open xslt script`> + `<get content template`> + `<math bold templates`> + `<close xslt script`> + </set> + <xslt name="." xml="." xsl="bold" /> +</script> +>>> + + + +\<math bold templates\><<< +<xsl:template match="span[ @class = 'mathvariant-bold' ]" > + <xsl:copy> + <xsl:apply-templates select="@*" /> + <xsl:variable name="content"> + <xsl:apply-templates select="*" mode="content" /> + </xsl:variable> + <xsl:choose> + <xsl:when test=" + string-length( normalize-space( $content )) = 1 + " > + <span class="begin-end" title="speech-extra" > + <xsl:text> bold </xsl:text> + </span> + <xsl:apply-templates select="*|text()|comment()" /> + </xsl:when> + <xsl:otherwise> + <span class="begin-end" title="speech-extra" > + <xsl:text> begin bold </xsl:text> + </span> + <xsl:apply-templates select="*|text()|comment()" /> + <span class="begin-end" title="speech-extra" > + <xsl:text> end bold </xsl:text> + </span> + </xsl:otherwise> + </xsl:choose> + </xsl:copy> +</xsl:template> +>>> + +%%%%%%%%%%%%%%%%%% +\section{Empty Elements} +%%%%%%%%%%%%%%%%%% + + + +%%%%%%%%%%%%%%%%%% +\section{Prose} +%%%%%%%%%%%%%%%%%% |