mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-16 07:55:41 +00:00
e8f480e7c2
This is a long standing issue, present since the new math macros inception in version 1.6. It manifests as a display issue when a macro with optional arguments appears in the optional argument of another macro. In this case the display is messed up and it is difficult, if not impossible, changing the arguments as they do not appear on screen as related to a specific macro instance. It also manifests as latex errors when compiling, even if the latex output is formally correct, due to limitations of the xargs package used to output the macros. Most probably, both aspects have the same root cause, as simply enclosing in braces the macro and its parameters solves both issues. However, when reloading a document, lyx strips the outer braces enclosing a macro argument, thus frustrating this possible workaround. This commit solves the display issue by correctly accounting for macros with optional arguments nested in the argument of another macro, and circumvents the xargs package limitations causing errors by enclosing in braces the macros with optional arguments appearing in the argument of an outer macro when they are output. This means that when loading an old document with such macros and saving it again, the macro representation is updated and will have these additional braces. However, as such braces are stripped by lyx on loading, there is no risk that they accumulate. See also this thread: http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg197828.html
723 lines
11 KiB
C++
723 lines
11 KiB
C++
/**
|
|
* \file MathStream.cpp
|
|
* This file is part of LyX, the document processor.
|
|
* Licence details can be found in the file COPYING.
|
|
*
|
|
* \author André Pönitz
|
|
*
|
|
* Full author contact details are available in file CREDITS.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "MathStream.h"
|
|
|
|
#include "MathFactory.h"
|
|
#include "MathData.h"
|
|
#include "MathExtern.h"
|
|
|
|
#include "TexRow.h"
|
|
|
|
#include "support/docstring.h"
|
|
#include "support/RefChanger.h"
|
|
#include "support/textutils.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
#include <ostream>
|
|
|
|
using namespace std;
|
|
|
|
namespace lyx {
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
|
|
{
|
|
at->normalize(ns);
|
|
return ns;
|
|
}
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, MathData const & ar)
|
|
{
|
|
normalize(ar, ns);
|
|
return ns;
|
|
}
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, docstring const & s)
|
|
{
|
|
ns.os() << s;
|
|
return ns;
|
|
}
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, const string & s)
|
|
{
|
|
ns.os() << from_utf8(s);
|
|
return ns;
|
|
}
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, char const * s)
|
|
{
|
|
ns.os() << s;
|
|
return ns;
|
|
}
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, char c)
|
|
{
|
|
ns.os() << c;
|
|
return ns;
|
|
}
|
|
|
|
|
|
NormalStream & operator<<(NormalStream & ns, int i)
|
|
{
|
|
ns.os() << i;
|
|
return ns;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, docstring const & s)
|
|
{
|
|
// Skip leading '\n' if we had already output a newline char
|
|
size_t const first =
|
|
(s.length() > 0 && (s[0] != '\n' || ws.canBreakLine())) ? 0 : 1;
|
|
|
|
// Check whether there's something to output
|
|
if (s.length() <= first)
|
|
return ws;
|
|
|
|
if (ws.pendingBrace()) {
|
|
ws.os() << '}';
|
|
ws.pendingBrace(false);
|
|
ws.pendingSpace(false);
|
|
ws.textMode(true);
|
|
} else if (ws.pendingSpace()) {
|
|
if (isAlphaASCII(s[first]))
|
|
ws.os() << ' ';
|
|
else if (s[first] == ' ' && ws.textMode())
|
|
ws.os() << '\\';
|
|
ws.pendingSpace(false);
|
|
}
|
|
ws.os() << s.substr(first);
|
|
int lf = 0;
|
|
char_type lastchar = 0;
|
|
docstring::const_iterator dit = s.begin() + first;
|
|
docstring::const_iterator end = s.end();
|
|
for (; dit != end; ++dit) {
|
|
lastchar = *dit;
|
|
if (lastchar == '\n')
|
|
++lf;
|
|
}
|
|
ws.addlines(lf);
|
|
ws.canBreakLine(lastchar != '\n');
|
|
return ws;
|
|
}
|
|
|
|
|
|
WriteStream::WriteStream(otexrowstream & os, bool fragile, bool latex,
|
|
OutputType output, Encoding const * encoding)
|
|
: os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
|
|
output_(output), insidemacro_(false), pendingspace_(false),
|
|
pendingbrace_(false), textmode_(false), locked_(0), ascii_(0),
|
|
canbreakline_(true), mathsout_(false), ulemcmd_(NONE), line_(0),
|
|
encoding_(encoding), row_entry_(TexRow::row_none)
|
|
{}
|
|
|
|
|
|
WriteStream::~WriteStream()
|
|
{
|
|
if (pendingbrace_)
|
|
os_ << '}';
|
|
else if (pendingspace_)
|
|
os_ << ' ';
|
|
}
|
|
|
|
|
|
void WriteStream::addlines(unsigned int n)
|
|
{
|
|
line_ += n;
|
|
}
|
|
|
|
|
|
void WriteStream::pendingSpace(bool how)
|
|
{
|
|
pendingspace_ = how;
|
|
}
|
|
|
|
|
|
void WriteStream::pendingBrace(bool brace)
|
|
{
|
|
pendingbrace_ = brace;
|
|
}
|
|
|
|
|
|
void WriteStream::textMode(bool textmode)
|
|
{
|
|
textmode_ = textmode;
|
|
}
|
|
|
|
|
|
void WriteStream::lockedMode(bool locked)
|
|
{
|
|
locked_ = locked;
|
|
}
|
|
|
|
|
|
void WriteStream::asciiOnly(bool ascii)
|
|
{
|
|
ascii_ = ascii;
|
|
}
|
|
|
|
|
|
Changer WriteStream::changeRowEntry(TexRow::RowEntry entry)
|
|
{
|
|
return make_change(row_entry_, entry);
|
|
}
|
|
|
|
|
|
bool WriteStream::startOuterRow()
|
|
{
|
|
if (TexRow::isNone(row_entry_))
|
|
return false;
|
|
return texrow().start(row_entry_);
|
|
}
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
|
|
{
|
|
at->write(ws);
|
|
return ws;
|
|
}
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, MathData const & ar)
|
|
{
|
|
write(ar, ws);
|
|
return ws;
|
|
}
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, char const * s)
|
|
{
|
|
ws << from_utf8(s);
|
|
return ws;
|
|
}
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, char c)
|
|
{
|
|
if (c == '\n' && !ws.canBreakLine())
|
|
return ws;
|
|
|
|
if (ws.pendingBrace()) {
|
|
ws.os() << '}';
|
|
ws.pendingBrace(false);
|
|
ws.pendingSpace(false);
|
|
ws.textMode(true);
|
|
} else if (ws.pendingSpace()) {
|
|
if (isAlphaASCII(c))
|
|
ws.os() << ' ';
|
|
else if (c == ' ' && ws.textMode())
|
|
ws.os() << '\\';
|
|
ws.pendingSpace(false);
|
|
}
|
|
ws.os() << c;
|
|
if (c == '\n')
|
|
ws.addlines(1);
|
|
ws.canBreakLine(c != '\n');
|
|
return ws;
|
|
}
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, int i)
|
|
{
|
|
if (ws.pendingBrace()) {
|
|
ws.os() << '}';
|
|
ws.pendingBrace(false);
|
|
ws.textMode(true);
|
|
}
|
|
ws.os() << i;
|
|
ws.canBreakLine(true);
|
|
return ws;
|
|
}
|
|
|
|
|
|
WriteStream & operator<<(WriteStream & ws, unsigned int i)
|
|
{
|
|
if (ws.pendingBrace()) {
|
|
ws.os() << '}';
|
|
ws.pendingBrace(false);
|
|
ws.textMode(true);
|
|
}
|
|
ws.os() << i;
|
|
ws.canBreakLine(true);
|
|
return ws;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
MathStream::MathStream(odocstream & os)
|
|
: os_(os), tab_(0), line_(0), in_text_(false)
|
|
{}
|
|
|
|
|
|
void MathStream::cr()
|
|
{
|
|
os() << '\n';
|
|
for (int i = 0; i < tab(); ++i)
|
|
os() << ' ';
|
|
}
|
|
|
|
|
|
void MathStream::defer(docstring const & s)
|
|
{
|
|
deferred_ << s;
|
|
}
|
|
|
|
|
|
void MathStream::defer(string const & s)
|
|
{
|
|
deferred_ << from_utf8(s);
|
|
}
|
|
|
|
|
|
docstring MathStream::deferred() const
|
|
{
|
|
return deferred_.str();
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, MathAtom const & at)
|
|
{
|
|
at->mathmlize(ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, MathData const & ar)
|
|
{
|
|
mathmlize(ar, ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, char const * s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, char c)
|
|
{
|
|
ms.os() << c;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, char_type c)
|
|
{
|
|
ms.os().put(c);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, MTag const & t)
|
|
{
|
|
++ms.tab();
|
|
ms.cr();
|
|
ms.os() << '<' << from_ascii(t.tag_);
|
|
if (!t.attr_.empty())
|
|
ms.os() << " " << from_ascii(t.attr_);
|
|
ms << '>';
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, ETag const & t)
|
|
{
|
|
ms.cr();
|
|
if (ms.tab() > 0)
|
|
--ms.tab();
|
|
ms.os() << "</" << from_ascii(t.tag_) << '>';
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathStream & operator<<(MathStream & ms, docstring const & s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
HtmlStream::HtmlStream(odocstream & os)
|
|
: os_(os), tab_(0), line_(0), in_text_(false)
|
|
{}
|
|
|
|
|
|
void HtmlStream::defer(docstring const & s)
|
|
{
|
|
deferred_ << s;
|
|
}
|
|
|
|
|
|
void HtmlStream::defer(string const & s)
|
|
{
|
|
deferred_ << from_utf8(s);
|
|
}
|
|
|
|
|
|
docstring HtmlStream::deferred() const
|
|
{
|
|
return deferred_.str();
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, MathAtom const & at)
|
|
{
|
|
at->htmlize(ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, MathData const & ar)
|
|
{
|
|
htmlize(ar, ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, char const * s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, char c)
|
|
{
|
|
ms.os() << c;
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, char_type c)
|
|
{
|
|
ms.os().put(c);
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, MTag const & t)
|
|
{
|
|
ms.os() << '<' << from_ascii(t.tag_);
|
|
if (!t.attr_.empty())
|
|
ms.os() << " " << from_ascii(t.attr_);
|
|
ms << '>';
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, ETag const & t)
|
|
{
|
|
ms.os() << "</" << from_ascii(t.tag_) << '>';
|
|
return ms;
|
|
}
|
|
|
|
|
|
HtmlStream & operator<<(HtmlStream & ms, docstring const & s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
SetMode::SetMode(MathStream & os, bool text)
|
|
: os_(os)
|
|
{
|
|
was_text_ = os_.inText();
|
|
os_.setTextMode(text);
|
|
}
|
|
|
|
|
|
SetMode::~SetMode()
|
|
{
|
|
os_.setTextMode(was_text_);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
SetHTMLMode::SetHTMLMode(HtmlStream & os, bool text)
|
|
: os_(os)
|
|
{
|
|
was_text_ = os_.inText();
|
|
os_.setTextMode(text);
|
|
}
|
|
|
|
|
|
SetHTMLMode::~SetHTMLMode()
|
|
{
|
|
os_.setTextMode(was_text_);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
|
|
{
|
|
at->maple(ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, MathData const & ar)
|
|
{
|
|
maple(ar, ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, char const * s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, char c)
|
|
{
|
|
ms.os() << c;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, int i)
|
|
{
|
|
ms.os() << i;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, char_type c)
|
|
{
|
|
ms.os().put(c);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MapleStream & operator<<(MapleStream & ms, docstring const & s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
|
|
{
|
|
at->maxima(ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, MathData const & ar)
|
|
{
|
|
maxima(ar, ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, char const * s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, char c)
|
|
{
|
|
ms.os() << c;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, int i)
|
|
{
|
|
ms.os() << i;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, docstring const & s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MaximaStream & operator<<(MaximaStream & ms, char_type c)
|
|
{
|
|
ms.os().put(c);
|
|
return ms;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
|
|
{
|
|
at->mathematica(ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, MathData const & ar)
|
|
{
|
|
mathematica(ar, ms);
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, char c)
|
|
{
|
|
ms.os() << c;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, int i)
|
|
{
|
|
ms.os() << i;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, docstring const & s)
|
|
{
|
|
ms.os() << s;
|
|
return ms;
|
|
}
|
|
|
|
|
|
MathematicaStream & operator<<(MathematicaStream & ms, char_type c)
|
|
{
|
|
ms.os().put(c);
|
|
return ms;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
|
|
{
|
|
at->octave(ns);
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, MathData const & ar)
|
|
{
|
|
octave(ar, ns);
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, char const * s)
|
|
{
|
|
ns.os() << s;
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, char c)
|
|
{
|
|
ns.os() << c;
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, int i)
|
|
{
|
|
ns.os() << i;
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, docstring const & s)
|
|
{
|
|
ns.os() << s;
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & ns, char_type c)
|
|
{
|
|
ns.os().put(c);
|
|
return ns;
|
|
}
|
|
|
|
|
|
OctaveStream & operator<<(OctaveStream & os, string const & s)
|
|
{
|
|
os.os() << from_utf8(s);
|
|
return os;
|
|
}
|
|
|
|
|
|
docstring convertDelimToXMLEscape(docstring const & name)
|
|
{
|
|
if (name.size() == 1) {
|
|
char_type const c = name[0];
|
|
if (c == '<')
|
|
return from_ascii("<");
|
|
else if (c == '>')
|
|
return from_ascii(">");
|
|
else
|
|
return name;
|
|
}
|
|
MathWordList const & words = mathedWordList();
|
|
MathWordList::const_iterator it = words.find(name);
|
|
if (it != words.end()) {
|
|
docstring const escape = it->second.xmlname;
|
|
return escape;
|
|
}
|
|
LYXERR0("Unable to find `" << name <<"' in the mathWordList.");
|
|
return name;
|
|
}
|
|
|
|
} // namespace lyx
|