Fix html export of \ne (second part of bug #9372)

The fix consists of two parts: The needed infrastructure to assign HTML
entities to global math macros, and the actual fix for \ne and \neq.

lib/symbols

@@ -1124,8 +1124,8 @@ pod                lyxblacktext  0   0 func     x     amsmath
 # pre-defined macros
 #
 
-\def\neq{\not=}
+\def\neq{\not=}                                                 mathrel ≠
-\def\ne{\not=}
+\def\ne{\not=}                                                  mathrel ≠
 \def\notin{\not\in}
 \def\slash{/}
 

src/mathed/InsetMathNest.cpp

@@ -1030,7 +1030,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_REGEXP_MODE: {
 		InsetMath * im = cur.inset().asInsetMath();
 		if (im) {
-			InsetMathHull * i = im->asHullInset();		
+			InsetMathHull * i = im->asHullInset();
 			if (i && i->getType() == hullRegexp) {
 				cur.message(_("Already in regular expression mode"));
 				break;
@@ -1093,7 +1093,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 			&& name != "Bmatrix" && name != "vmatrix"
 			&& name != "Vmatrix" && name != "matrix")
 			name = from_ascii("matrix");
-		
+
 		cur.niceInsert(
 			MathAtom(new InsetMathAMSArray(buffer_, name, m, n)));
 		break;
@@ -1280,7 +1280,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		if (createInsetMath_fromDialogStr(cmd.argument(), ar)) {
 			cur.recordUndoSelection();
 			cur.insert(ar);
-			cur.forceBufferUpdate();			
+			cur.forceBufferUpdate();
 		} else
 			cur.undispatched();
 		break;
@@ -1456,7 +1456,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_CAPTION_INSERT:
 		flag.setEnabled(false);
 		break;
-	
+
 	case LFUN_SPACE_INSERT: {
 		docstring const & name = cmd.argument();
 		if (name == "visible")
@@ -1636,9 +1636,8 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		}
 
 		// do not finish macro for known * commands
-		MathWordList const & mwl = mathedWordList();
 		bool star_macro = c == '*'
-			&& (mwl.find(name.substr(1) + "*") != mwl.end()
+			&& (in_word_set(name.substr(1) + '*')
 			    || cur.buffer()->getMacro(name.substr(1) + "*", cur, true));
 		if (isAlphaASCII(c) || star_macro) {
 			cur.activeMacro()->setName(name + docstring(1, c));
@@ -1731,7 +1730,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		cur.autocorrect() = false;
 		cur.message(_("Autocorrect Off ('!' to enter)"));
 		return true;
-	} 
+	}
 	if (lyxrc.autocorrection_math && c == '!' && !cur.autocorrect()) {
 		cur.autocorrect() = true;
 		cur.message(_("Autocorrect On (<space> to exit)"));
@@ -2197,8 +2196,11 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	MathWordList::const_iterator it2;
 	//lyxerr << "Globals completion commands: ";
 	for (it2 = words.begin(); it2 != words.end(); ++it2) {
-		globals.push_back("\\" + (*it2).first);
+		if (it2->second.inset != "macro") {
-		//lyxerr << "\\" + (*it2).first << " ";
+			// macros are already read from MacroTable::globalMacros()
+			globals.push_back('\\' + it2->first);
+			//lyxerr << '\\' + it2->first << ' ';
+		}
 	}
 	//lyxerr << std::endl;
 	sort(globals.begin(), globals.end());

src/mathed/InsetMathSymbol.cpp

@@ -186,22 +186,13 @@ void InsetMathSymbol::mathematica(MathematicaStream & os) const
 }
 
 
-// FIXME This will likely need some work.
-char const * MathMLtype(docstring const & s)
-{
-	if (s == "mathord")
-		return "mi";
-	return "mo";
-}
-
-
 void InsetMathSymbol::mathmlize(MathStream & os) const
 {
-	// FIXME We may need to do more interesting things 
+	// FIXME We may need to do more interesting things
 	// with MathMLtype.
-	char const * type = MathMLtype(sym_->extra);
+	char const * type = sym_->MathMLtype();
 	os << '<' << type << "> ";
-	if (sym_->xmlname == "x") 
+	if (sym_->xmlname == "x")
 		// unknown so far
 		os << name();
 	else
@@ -212,15 +203,15 @@ void InsetMathSymbol::mathmlize(MathStream & os) const
 
 void InsetMathSymbol::htmlize(HtmlStream & os, bool spacing) const
 {
-	// FIXME We may need to do more interesting things 
+	// FIXME We may need to do more interesting things
 	// with MathMLtype.
-	char const * type = MathMLtype(sym_->extra);
+	char const * type = sym_->MathMLtype();
 	bool op = (std::string(type) == "mo");
-	
+
-	if (sym_->xmlname == "x") 
+	if (sym_->xmlname == "x")
 		// unknown so far
 		os << ' ' << name() << ' ';
-	else if (op && spacing) 
+	else if (op && spacing)
 		os << ' ' << sym_->xmlname << ' ';
 	else
 		os << sym_->xmlname;

src/mathed/MacroTable.cpp

@@ -14,6 +14,7 @@
 #include "MacroTable.h"
 #include "MathMacroTemplate.h"
 #include "MathMacroArgument.h"
+#include "MathParser.h"
 #include "MathStream.h"
 #include "MathSupport.h"
 #include "InsetMathNest.h"
@@ -41,13 +42,13 @@ namespace lyx {
 /////////////////////////////////////////////////////////////////////
 
 MacroData::MacroData(Buffer * buf)
-	: buffer_(buf), queried_(true), numargs_(0), optionals_(0), lockCount_(0),
+	: buffer_(buf), queried_(true), numargs_(0), sym_(0), optionals_(0),
-	  redefinition_(false), type_(MacroTypeNewcommand)
+	  lockCount_(0), redefinition_(false), type_(MacroTypeNewcommand)
 {}
 
 
 MacroData::MacroData(Buffer * buf, DocIterator const & pos)
-	: buffer_(buf), pos_(pos), queried_(false), numargs_(0),
+	: buffer_(buf), pos_(pos), queried_(false), numargs_(0), sym_(0),
 	  optionals_(0), lockCount_(0), redefinition_(false),
 	  type_(MacroTypeNewcommand)
 {
@@ -55,8 +56,8 @@ MacroData::MacroData(Buffer * buf, DocIterator const & pos)
 
 
 MacroData::MacroData(Buffer * buf, MathMacroTemplate const & macro)
-	: buffer_(buf), queried_(false), numargs_(0), optionals_(0), lockCount_(0),
+	: buffer_(buf), queried_(false), numargs_(0), sym_(0), optionals_(0),
-	  redefinition_(false), type_(MacroTypeNewcommand)
+	  lockCount_(0), redefinition_(false), type_(MacroTypeNewcommand)
 {
 	queryData(macro);
 }
@@ -110,6 +111,14 @@ vector<docstring> const & MacroData::defaults() const
 }
 
 
+string const MacroData::requires() const
+{
+	if (sym_)
+		return to_utf8(sym_->requires);
+	return string();
+}
+
+
 void MacroData::unlock() const
 {
 	--lockCount_;
@@ -210,12 +219,11 @@ MacroTable::insert(docstring const & name, MacroData const & data)
 
 
 MacroTable::iterator
-MacroTable::insert(Buffer * buf, docstring const & def, string const & requires)
+MacroTable::insert(Buffer * buf, docstring const & def)
 {
 	//lyxerr << "MacroTable::insert, def: " << to_utf8(def) << endl;
 	MathMacroTemplate mac(buf, def);
 	MacroData data(buf, mac);
-	data.requires() = requires;
 	return insert(mac.name(), data);
 }
 

src/mathed/MacroTable.h

@@ -27,6 +27,7 @@ class Buffer;
 class MathData;
 class MathMacroTemplate;
 class Paragraph;
+class latexkeys;
 
 enum MacroType {
 	MacroTypeNewcommand,
@@ -59,9 +60,9 @@ public:
 	///
 	std::vector<docstring> const & defaults() const;
 	///
-	std::string const & requires() const { return requires_; }
+	std::string const requires() const;
 	///
-	std::string & requires() { return requires_; }
+	void setSymbol(latexkeys const * sym) { sym_ = sym; }
 
 	/// lock while being drawn to avoid recursions
 	int lock() const { return ++lockCount_; }
@@ -86,7 +87,7 @@ public:
 		return definition_ == x.definition_
 			&& numargs_ == x.numargs_
 			&& display_ == x.display_
-			&& requires_ == x.requires_
+			&& sym_ == x.sym_
 			&& optionals_ == x.optionals_
 			&& defaults_ == x.defaults_;
 	}
@@ -118,7 +119,7 @@ private:
 	///
 	mutable docstring display_;
 	///
-	std::string requires_;
+	latexkeys const * sym_;
 	///
 	mutable size_t optionals_;
 	///
@@ -149,7 +150,7 @@ class MacroTable : public std::map<docstring, MacroData>
 {
 public:
 	/// Parse full "\\def..." or "\\newcommand..." or ...
-	iterator insert(Buffer * buf, docstring const & definition, std::string const &);
+	iterator insert(Buffer * buf, docstring const & definition);
 	/// Insert pre-digested macro definition
 	iterator insert(docstring const & name, MacroData const & data);
 	///

src/mathed/MathFactory.cpp

@@ -175,18 +175,50 @@ void initSymbols()
 		// special case of pre-defined macros
 		if (line.size() > 8 && line.substr(0, 5) == "\\def\\") {
 			//lyxerr << "macro definition: '" << line << '\'' << endl;
+			// syntax: Either
+			// \def\macroname{definition}
+			// or
+			// \def\macroname{definition} requires
+			// or
+			// \def\macroname{definition} extra xmlname requires
 			istringstream is(line);
 			string macro;
 			string requires;
+			string extra;
+			string xmlname;
 			is >> macro >> requires;
+			if ((is >> xmlname)) {
+				extra = requires;
+				if (!(is >> requires))
+					requires = "";
+			} else
+				xmlname = "";
 			MacroTable::iterator it = MacroTable::globalMacros().insert(
-					0, from_utf8(macro), requires);
+					0, from_utf8(macro));
+			if (!extra.empty() || !xmlname.empty() || !requires.empty()) {
+				MathWordList::iterator wit = theMathWordList.find(it->first);
+				if (wit != theMathWordList.end())
+					LYXERR(Debug::MATHED, "readSymbols: inset "
+						<< to_utf8(it->first) << " already exists.");
+				else {
+					latexkeys tmp;
+					tmp.inset = from_ascii("macro");
+					tmp.name = it->first;
+					tmp.extra = from_utf8(extra);
+					tmp.xmlname = from_utf8(xmlname);
+					tmp.requires = from_utf8(requires);
+					theMathWordList[it->first] = tmp;
+					wit = theMathWordList.find(it->first);
+					it->second.setSymbol(&(wit->second));
+				}
+			}
 			// If you change the following output, please adjust
 			// development/tools/generate_symbols_images.py.
 			LYXERR(Debug::MATHED, "read symbol '" << to_utf8(it->first)
 				<< "  inset: macro"
 				<< "  draw: 0"
-				<< "  extra: "
+				<< "  extra: " << extra
+				<< "  xml: " << xmlname
 				<< "  requires: " << requires << '\'');
 			continue;
 		}
@@ -270,6 +302,7 @@ void initSymbols()
 			<< "  inset: " << to_utf8(tmp.inset)
 			<< "  draw: " << int(tmp.draw.empty() ? 0 : tmp.draw[0])
 			<< "  extra: " << to_utf8(tmp.extra)
+			<< "  xml: " << to_utf8(tmp.xmlname)
 			<< "  requires: " << to_utf8(tmp.requires) << '\'');
 	}
 	docstring tmp = from_ascii("cmm");
@@ -354,7 +387,11 @@ int ensureMode(WriteStream & os, InsetMath::mode_type mode,
 latexkeys const * in_word_set(docstring const & str)
 {
 	MathWordList::iterator it = theMathWordList.find(str);
-	return it != theMathWordList.end() ? &(it->second) : 0;
+	if (it == theMathWordList.end())
+		return 0;
+	if (it->second.inset == "macro")
+		return 0;
+	return &(it->second);
 }
 
 

src/mathed/MathMacro.cpp

@@ -52,11 +52,11 @@ namespace lyx {
 class ArgumentProxy : public InsetMath {
 public:
 	///
-	ArgumentProxy(MathMacro & mathMacro, size_t idx) 
+	ArgumentProxy(MathMacro & mathMacro, size_t idx)
 		: mathMacro_(mathMacro), idx_(idx) {}
 	///
-	ArgumentProxy(MathMacro & mathMacro, size_t idx, docstring const & def) 
+	ArgumentProxy(MathMacro & mathMacro, size_t idx, docstring const & def)
-		: mathMacro_(mathMacro), idx_(idx) 
+		: mathMacro_(mathMacro), idx_(idx)
 	{
 			asArray(def, def_);
 	}
@@ -81,13 +81,13 @@ public:
 	///
 	void draw(PainterInfo & pi, int x, int y) const {
 		if (mathMacro_.editMetrics(pi.base.bv)) {
-			// The only way a ArgumentProxy can appear is in a cell of the 
+			// The only way a ArgumentProxy can appear is in a cell of the
-			// MathMacro. Moreover the cells are only drawn in the DISPLAY_FOLDED 
+			// MathMacro. Moreover the cells are only drawn in the DISPLAY_FOLDED
-			// mode and then, if the macro is edited the monochrome 
+			// mode and then, if the macro is edited the monochrome
 			// mode is entered by the MathMacro before calling the cells' draw
 			// method. Then eventually this code is reached and the proxy leaves
-			// monochrome mode temporarely. Hence, if it is not in monochrome 
+			// monochrome mode temporarely. Hence, if it is not in monochrome
-			// here (and the assert triggers in pain.leaveMonochromeMode()) 
+			// here (and the assert triggers in pain.leaveMonochromeMode())
 			// it's a bug.
 			pi.pain.leaveMonochromeMode();
 			mathMacro_.cell(idx_).draw(pi, x, y);
@@ -102,17 +102,17 @@ public:
 	size_t idx() const { return idx_; }
 	///
 	int kerning(BufferView const * bv) const
-	{ 
+	{
 		if (mathMacro_.editMetrics(bv)
 		    || !mathMacro_.cell(idx_).empty())
-			return mathMacro_.cell(idx_).kerning(bv); 
+			return mathMacro_.cell(idx_).kerning(bv);
 		else
 			return def_.kerning(bv);
 	}
 
 private:
 	///
-	Inset * clone() const 
+	Inset * clone() const
 	{
 		return new ArgumentProxy(*this);
 	}
@@ -215,7 +215,7 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const
 		dim.asc = max(bsdim.ascent(), dim.ascent());
 		dim.des = max(bsdim.descent(), dim.descent());
 		metricsMarkers(dim);
-	} else if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_LIST 
+	} else if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_LIST
 		   && editing_[mi.base.bv]) {
 		// Macro will be edited in a old-style list mode here:
 
@@ -223,7 +223,7 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const
 		Dimension fontDim;
 		FontInfo labelFont = sane_font;
 		math_font_max_dim(labelFont, fontDim.asc, fontDim.des);
-		
+
 		// get dimension of components of list view
 		Dimension nameDim;
 		nameDim.wid = mathed_string_width(mi.base.font, from_ascii("Macro \\") + name() + ": ");
@@ -234,22 +234,22 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const
 		argDim.wid = mathed_string_width(labelFont, from_ascii("#9: "));
 		argDim.asc = fontDim.asc;
 		argDim.des = fontDim.des;
-		
+
 		Dimension defDim;
 		definition_.metrics(mi, defDim);
-		
+
 		// add them up
 		dim.wid = nameDim.wid + defDim.wid;
 		dim.asc = max(nameDim.asc, defDim.asc);
 		dim.des = max(nameDim.des, defDim.des);
-		
+
 		for (idx_type i = 0; i < nargs(); ++i) {
 			Dimension cdim;
 			cell(i).metrics(mi, cdim);
 			dim.des += max(argDim.height(), cdim.height()) + 1;
 			dim.wid = max(dim.wid, argDim.wid + cdim.wid);
 		}
-		
+
 		// make space for box and markers, 2 pixels
 		dim.asc += 1;
 		dim.des += 1;
@@ -273,7 +273,7 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const
 		macro_->unlock();
 
 		// calculate dimension with label while editing
-		if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_INLINE_BOX 
+		if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_INLINE_BOX
 		    && editing_[mi.base.bv]) {
 			FontInfo font = mi.base.font;
 			augmentFont(font, from_ascii("lyxtex"));
@@ -288,7 +288,6 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const
 			dim.asc += 1 + namedim.height() + 1;
 			dim.des += 2;
 		}
-	 
 	}
 }
 
@@ -301,10 +300,10 @@ int MathMacro::kerning(BufferView const * bv) const {
 }
 
 
-void MathMacro::updateMacro(MacroContext const & mc) 
+void MathMacro::updateMacro(MacroContext const & mc)
 {
 	if (validName()) {
-		macro_ = mc.get(name());    
+		macro_ = mc.get(name());
 		if (macro_ && macroBackup_ != *macro_) {
 			macroBackup_ = *macro_;
 			needsUpdate_ = true;
@@ -350,22 +349,22 @@ void MathMacro::updateRepresentation(Cursor * cur, MacroContext const & mc,
 
 	// update requires
 	requires_ = macro_->requires();
-	
+
 	if (!needsUpdate_
 		// non-normal mode? We are done!
 		|| (displayMode_ != DISPLAY_NORMAL))
 		return;
 
 	needsUpdate_ = false;
-	
+
 	// get default values of macro
 	vector<docstring> const & defaults = macro_->defaults();
-	
+
 	// create MathMacroArgumentValue objects pointing to the cells of the macro
 	vector<MathData> values(nargs());
 	for (size_t i = 0; i < nargs(); ++i) {
 		ArgumentProxy * proxy;
-		if (i < defaults.size()) 
+		if (i < defaults.size())
 			proxy = new ArgumentProxy(*this, i, defaults[i]);
 		else
 			proxy = new ArgumentProxy(*this, i);
@@ -395,7 +394,7 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const
 	int expx = x;
 	int expy = y;
 
-	if (displayMode_ == DISPLAY_INIT || displayMode_ == DISPLAY_INTERACTIVE_INIT) {		
+	if (displayMode_ == DISPLAY_INIT || displayMode_ == DISPLAY_INTERACTIVE_INIT) {
 		FontSetChanger dummy(pi.base, "lyxtex");
 		pi.pain.text(x, y, from_ascii("\\") + name(), pi.base.font);
 	} else if (displayMode_ == DISPLAY_UNFOLDED) {
@@ -407,17 +406,17 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const
 	} else if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_LIST
 		   && editing_[pi.base.bv]) {
 		// Macro will be edited in a old-style list mode here:
-		
+
 		CoordCache const & coords = pi.base.bv->coordCache();
 		FontInfo const & labelFont = sane_font;
-		
+
 		// markers and box needs two pixels
 		x += 2;
-		
+
 		// get maximal font height
 		Dimension fontDim;
 		math_font_max_dim(pi.base.font, fontDim.asc, fontDim.des);
-		
+
 		// draw label
 		docstring label = from_ascii("Macro \\") + name() + from_ascii(": ");
 		pi.pain.text(x, y, label, labelFont);
@@ -427,38 +426,38 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const
 		definition_.draw(pi, x, y);
 		Dimension const & defDim = coords.getArrays().dim(&definition_);
 		y += max(fontDim.des, defDim.des);
-				
+
 		// draw parameters
 		docstring str = from_ascii("#9");
 		int strw1 = mathed_string_width(labelFont, from_ascii("#9"));
 		int strw2 = mathed_string_width(labelFont, from_ascii(": "));
-		
+
 		for (idx_type i = 0; i < nargs(); ++i) {
 			// position of label
 			Dimension const & cdim = coords.getArrays().dim(&cell(i));
 			x = expx + 2;
 			y += max(fontDim.asc, cdim.asc) + 1;
-			
+
 			// draw label
 			str[1] = '1' + i;
 			pi.pain.text(x, y, str, labelFont);
 			x += strw1;
 			pi.pain.text(x, y, from_ascii(":"), labelFont);
 			x += strw2;
-			
+
 			// draw paramter
 			cell(i).draw(pi, x, y);
-			
+
 			// next line
 			y += max(fontDim.des, cdim.des);
 		}
-		
+
-		pi.pain.rectangle(expx + 1, expy - dim.asc + 1, dim.wid - 3, 
+		pi.pain.rectangle(expx + 1, expy - dim.asc + 1, dim.wid - 3,
 				  dim.height() - 2, Color_mathmacroframe);
 		drawMarkers2(pi, expx, expy);
 	} else {
 		bool drawBox = lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_INLINE_BOX;
-		
+
 		// warm up cells
 		for (size_t i = 0; i < nargs(); ++i)
 			cell(i).setXY(*pi.base.bv, x, y);
@@ -483,7 +482,7 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const
 			pi.pain.leaveMonochromeMode();
 
 			if (drawBox)
-				pi.pain.rectangle(x, y - dim.asc, dim.wid, 
+				pi.pain.rectangle(x, y - dim.asc, dim.wid,
 						  dim.height(), Color_mathmacroframe);
 		} else
 			expanded_.cell(0).draw(pi, expx, expy);
@@ -508,7 +507,7 @@ void MathMacro::drawSelection(PainterInfo & pi, int x, int y) const
 
 void MathMacro::setDisplayMode(MathMacro::DisplayMode mode, int appetite)
 {
-	if (displayMode_ != mode) {		
+	if (displayMode_ != mode) {
 		// transfer name if changing from or to DISPLAY_UNFOLDED
 		if (mode == DISPLAY_UNFOLDED) {
 			cells_.resize(1);
@@ -521,7 +520,7 @@ void MathMacro::setDisplayMode(MathMacro::DisplayMode mode, int appetite)
 		displayMode_ = mode;
 		needsUpdate_ = true;
 	}
-	
+
 	// the interactive init mode is non-greedy by default
 	if (appetite == -1)
 		appetite_ = (mode == DISPLAY_INTERACTIVE_INIT) ? 0 : 9;
@@ -556,7 +555,7 @@ bool MathMacro::validName() const
 	for (size_t i = 0; i<n.size(); ++i) {
 		if (!(n[i] >= 'a' && n[i] <= 'z')
 		    && !(n[i] >= 'A' && n[i] <= 'Z')
-		    && n[i] != '*') 
+		    && n[i] != '*')
 			return false;
 	}
 
@@ -571,7 +570,7 @@ void MathMacro::validate(LaTeXFeatures & features) const
 
 	if (name() == "binom")
 		features.require("binom");
-	
+
 	// validate the cells and the definition
 	if (displayMode() == DISPLAY_NORMAL) {
 		definition_.validate(features);
@@ -592,7 +591,7 @@ Inset * MathMacro::editXY(Cursor & cur, int x, int y)
 	// We may have 0 arguments, but InsetMathNest requires at least one.
 	if (nargs() > 0) {
 		cur.screenUpdateFlags(Update::SinglePar);
-		return InsetMathNest::editXY(cur, x, y);		
+		return InsetMathNest::editXY(cur, x, y);
 	} else
 		return this;
 }
@@ -661,14 +660,14 @@ void MathMacro::attachArguments(vector<MathData> const & args, size_t arity, int
 }
 
 
-bool MathMacro::idxFirst(Cursor & cur) const 
+bool MathMacro::idxFirst(Cursor & cur) const
 {
 	cur.screenUpdateFlags(Update::SinglePar);
 	return InsetMathNest::idxFirst(cur);
 }
 
 
-bool MathMacro::idxLast(Cursor & cur) const 
+bool MathMacro::idxLast(Cursor & cur) const
 {
 	cur.screenUpdateFlags(Update::SinglePar);
 	return InsetMathNest::idxLast(cur);
@@ -745,10 +744,10 @@ void MathMacro::write(WriteStream & os) const
 	// Always protect macros in a fragile environment
 	if (os.fragile())
 		os << "\\protect";
-	
+
 	os << "\\" << name();
 	bool first = true;
-	
+
 	// Optional arguments:
 	// First find last non-empty optional argument
 	idx_type emptyOptFrom = 0;
@@ -757,19 +756,19 @@ void MathMacro::write(WriteStream & os) const
 		if (!cell(i).empty())
 			emptyOptFrom = i + 1;
 	}
-	
+
 	// print out optionals
 	for (i=0; i < cells_.size() && i < emptyOptFrom; ++i) {
 		first = false;
 		os << "[" << cell(i) << "]";
 	}
-	
+
 	// skip the tailing empty optionals
 	i = optionals_;
-	
+
 	// Print remaining arguments
 	for (; i < cells_.size(); ++i) {
-		if (cell(i).size() == 1 
+		if (cell(i).size() == 1
 			&& cell(i)[0].nucleus()->asCharInset()
 			&& isASCII(cell(i)[0].nucleus()->asCharInset()->getChar())) {
 			if (first)
@@ -794,6 +793,17 @@ void MathMacro::maple(MapleStream & os) const
 
 void MathMacro::mathmlize(MathStream & os) const
 {
+	MathWordList const & words = mathedWordList();
+	MathWordList::const_iterator it = words.find(name());
+	if (it != words.end()) {
+		docstring const xmlname = it->second.xmlname;
+		if (!xmlname.empty()) {
+			char const * type = it->second.MathMLtype();
+			os << '<' << type << "> " << xmlname << " /<"
+			   << type << '>';
+			return;
+		}
+	}
 	MathData const & data = expanded_.cell(0);
 	if (data.empty()) {
 		// this means that we do not recognize the macro
@@ -805,6 +815,15 @@ void MathMacro::mathmlize(MathStream & os) const
 
 void MathMacro::htmlize(HtmlStream & os) const
 {
+	MathWordList const & words = mathedWordList();
+	MathWordList::const_iterator it = words.find(name());
+	if (it != words.end()) {
+		docstring const xmlname = it->second.xmlname;
+		if (!xmlname.empty()) {
+			os << ' ' << xmlname << ' ';
+			return;
+		}
+	}
 	MathData const & data = expanded_.cell(0);
 	if (data.empty()) {
 		// this means that we do not recognize the macro
@@ -872,7 +891,7 @@ bool MathMacro::automaticPopupCompletion() const
 }
 
 
-CompletionList const * 
+CompletionList const *
 MathMacro::createCompletionList(Cursor const & cur) const
 {
 	if (displayMode() != DISPLAY_UNFOLDED)
@@ -889,7 +908,7 @@ docstring MathMacro::completionPrefix(Cursor const & cur) const
 
 	if (!completionSupported(cur))
 		return docstring();
-	
+
 	return "\\" + name();
 }
 
@@ -908,14 +927,14 @@ bool MathMacro::insertCompletion(Cursor & cur, docstring const & s,
 	asArray(newName, cell(0));
 	cur.bv().cursor().pos() = name().size();
 	cur.screenUpdateFlags(Update::SinglePar);
-	
+
 	// finish macro
 	if (finished) {
 		cur.bv().cursor().pop();
 		++cur.bv().cursor().pos();
 		cur.screenUpdateFlags(Update::SinglePar);
 	}
-	
+
 	return true;
 }
 
@@ -925,14 +944,14 @@ void MathMacro::completionPosAndDim(Cursor const & cur, int & x, int & y,
 {
 	if (displayMode() != DISPLAY_UNFOLDED)
 		InsetMathNest::completionPosAndDim(cur, x, y, dim);
-	
+
 	// get inset dimensions
 	dim = cur.bv().coordCache().insets().dim(this);
 	// FIXME: these 3 are no accurate, but should depend on the font.
 	// Now the popup jumps down if you enter a char with descent > 0.
 	dim.des += 3;
 	dim.asc += 3;
-	
+
 	// and position
 	Point xy
 	= cur.bv().coordCache().insets().xy(this);

src/mathed/MathParser.cpp

@@ -1066,10 +1066,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 			 t.cs() == "def") {
 			if (t.cs() == "global")
 				getToken();
-			
+
 			// get name
 			docstring name = getToken().cs();
-			
+
 			// read parameters
 			int nargs = 0;
 			docstring pars;
@@ -1078,17 +1078,17 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 				++nargs;
 			}
 			nargs /= 2;
-			
+
 			// read definition
 			MathData def;
 			parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE);
-			
+
 			// is a version for display attached?
 			skipSpaces();
 			MathData display;
 			if (nextToken().cat() == catBegin)
 				parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
-			
+
 			cell->push_back(MathAtom(new MathMacroTemplate(buf,
 				name, nargs, 0, MacroTypeDef,
 				vector<MathData>(), def, display)));
@@ -1096,7 +1096,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 			if (buf && (mode_ & Parse::TRACKMACRO))
 				buf->usermacros.insert(name);
 		}
-		
+
 		else if (t.cs() == "newcommand" ||
 			 t.cs() == "renewcommand" ||
 			 t.cs() == "newlyxcommand") {
@@ -1110,13 +1110,13 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 				error("'}' in \\newcommand expected");
 				return success_;
 			}
-				
+
 			// get arity
 			docstring const arg = getArg('[', ']');
 			int nargs = 0;
 			if (!arg.empty())
 				nargs = convert<int>(arg);
-				
+
 			// optional argument given?
 			skipSpaces();
 			int optionals = 0;
@@ -1127,16 +1127,16 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 				parse(optionalValues[optionals], FLAG_BRACK_LAST, mode);
 				++optionals;
 			}
-			
+
 			MathData def;
 			parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE);
-			
+
 			// is a version for display attached?
 			skipSpaces();
 			MathData display;
 			if (nextToken().cat() == catBegin)
 				parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
-			
+
 			cell->push_back(MathAtom(new MathMacroTemplate(buf,
 				name, nargs, optionals, MacroTypeNewcommand,
 				optionalValues, def, display)));
@@ -1144,7 +1144,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 			if (buf && (mode_ & Parse::TRACKMACRO))
 				buf->usermacros.insert(name);
 		}
-		
+
 		else if (t.cs() == "newcommandx" ||
 			 t.cs() == "renewcommandx") {
 			// \newcommandx{\foo}[2][usedefault, addprefix=\global,1=default]{#1,#2}
@@ -1159,7 +1159,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 				}
 			} else
 				name = getToken().cs();
-				
+
 			// get arity
 			docstring const arg = getArg('[', ']');
 			if (arg.empty()) {
@@ -1167,14 +1167,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 				return success_;
 			}
 			int nargs = convert<int>(arg);
-			
+
 			// get options
 			int optionals = 0;
 			vector<MathData> optionalValues;
 			if (nextToken().character() == '[') {
 				// skip '['
 				getToken();
-					
+
 				// handle 'opt=value' options, separated by ','.
 				skipSpaces();
 				while (nextToken().character() != ']' && good()) {
@@ -1187,14 +1187,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 							      "for given optional parameter.");
 							return success_;
 						}
-						
+
 						// skip '='
 						if (getToken().character() != '=') {
 							error("'=' and optional parameter value "
 							      "expected for \\newcommandx");
 							return success_;
 						}
-						
+
 						// get value
 						int optNum = max(size_t(n), optionalValues.size());
 						optionalValues.resize(optNum);
@@ -1209,12 +1209,12 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 					} else if (nextToken().cat() == catLetter) {
 						// we in fact ignore every non-optional
 						// parameter
-						
+
 						// get option name
 						docstring opt;
 						while (nextToken().cat() == catLetter)
 							opt += getChar();
-					
+
 						// value?
 						skipSpaces();
 						MathData value;
@@ -1222,14 +1222,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 							getToken();
 							while (nextToken().character() != ']'
 								&& nextToken().character() != ',')
-								parse(value, FLAG_ITEM, 
+								parse(value, FLAG_ITEM,
 								      InsetMath::UNDECIDED_MODE);
 						}
 					} else {
 						error("option for \\newcommandx expected");
 						return success_;
 					}
-					
+
 					// skip komma
 					skipSpaces();
 					if (nextToken().character() == ',') {
@@ -1241,7 +1241,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 						return success_;
 					}
 				}
-				
+
 				// skip ']'
 				if (!good())
 					return success_;
@@ -1481,7 +1481,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 		else if (t.cs() == "cfrac") {
 			// allowed formats are \cfrac[pos]{num}{denom}
 			docstring const arg = getArg('[', ']');
-			//lyxerr << "got so far: '" << arg << "'" << endl;				
+			//lyxerr << "got so far: '" << arg << "'" << endl;
 				if (arg == "l")
 					cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::CFRACLEFT)));
 				else if (arg == "r")
@@ -1593,13 +1593,13 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 
 		else if (t.cs() == "begin") {
 			docstring const name = getArg('{', '}');
-			
+
 			if (name.empty()) {
 				success_ = false;
 				error("found invalid environment");
 				return success_;
 			}
-			
+
 			environments_.push_back(name);
 
 			if (name == "array" || name == "subarray") {
@@ -2155,6 +2155,15 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 } // anonymous namespace
 
 
+// FIXME This will likely need some work.
+char const * latexkeys::MathMLtype() const
+{
+	if (extra == "mathord")
+		return "mi";
+	return "mo";
+}
+
+
 bool mathed_parse_cell(MathData & ar, docstring const & str, Parse::flags f)
 {
 	return Parser(str, f, ar.buffer()).parse(ar, 0, f & Parse::TEXTMODE ?

src/mathed/MathParser.h

@@ -30,6 +30,8 @@ class Lexer;
 ///
 class latexkeys {
 public:
+	///
+	char const * MathMLtype() const;
 	/// name of the macro or primitive
 	docstring name;
 	/// name of a inset that handles that macro