rename commandtags.h to lfuns.h and renumber/cleanup. Rebuild the tree !

[lyx.git] / src / mathed / math_mathmlstream.C

diff --git a/src/mathed/math_mathmlstream.C b/src/mathed/math_mathmlstream.C
index bb87b1d232f94cc210851fdca2cd9e9371406ea2..8a226ac17f1f550153e4ac44a84e41facebe4353 100644 (file)
--- a/src/mathed/math_mathmlstream.C
+++ b/src/mathed/math_mathmlstream.C
@@ -1,3 +1,4 @@
+
 #include <config.h>
 
 #include "math_mathmlstream.h"
@@ -5,9 +6,108 @@
 #include "math_extern.h"
 #include "debug.h"
 #include "support/lyxalgo.h"
+#include "support/LOstream.h"
 
 
 using std::ostream;
+using std::strlen;
+
+namespace {
+
+       bool isAlpha(char c)
+       {
+               return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
+       }
+
+}
+
+WriteStream::WriteStream(ostream & os, bool fragile, bool latex)
+       : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
+         pendingspace_(false), line_(0)
+{}
+
+
+WriteStream::WriteStream(ostream & os)
+       : os_(os), fragile_(false), firstitem_(false), latex_(false),
+         pendingspace_(false), line_(0)
+{}
+
+
+WriteStream::~WriteStream()
+{
+       if (pendingspace_)
+               os_ << ' ';
+}
+
+
+void WriteStream::addlines(unsigned int n)
+{
+       line_ += n;
+}
+
+
+void WriteStream::pendingSpace(bool how)
+{
+       pendingspace_ = how;
+}
+
+
+WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
+{
+       at->write(ws);
+       return ws;
+}
+
+
+WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
+{
+       write(ar, ws);
+       return ws;
+}
+
+
+WriteStream & operator<<(WriteStream & ws, char const * s)
+{
+       if (ws.pendingSpace() && strlen(s) > 0) {
+               if (isAlpha(s[0]))
+                       ws.os() << ' ';
+               ws.pendingSpace(false);
+       }
+       ws.os() << s;
+       ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
+       return ws;
+}
+
+
+WriteStream & operator<<(WriteStream & ws, char c)
+{
+       if (ws.pendingSpace()) {
+               if (isAlpha(c))
+                       ws.os() << ' ';
+               ws.pendingSpace(false);
+       }
+       ws.os() << c;
+       if (c == '\n')
+               ws.addlines(1);
+       return ws;
+}
+
+
+WriteStream & operator<<(WriteStream & ws, int i)
+{
+       ws.os() << i;
+       return ws;
+}
+
+
+WriteStream & operator<<(WriteStream & ws, unsigned int i)
+{
+       ws.os() << i;
+       return ws;
+}
+
+
+//////////////////////////////////////////////////////////////////////
 
 
 MathMLStream::MathMLStream(ostream & os)
@@ -15,12 +115,9 @@ MathMLStream::MathMLStream(ostream & os)
 {}
 
 
-MathMLStream & operator<<(MathMLStream & ms, MathInset const * p)
+MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
 {
-       if (p)
-               p->mathmlize(ms);
-       else
-               lyxerr << "operator<<(MathMLStream, NULL) called\n";
+       at->mathmlize(ms);
        return ms;
 }
 
@@ -73,23 +170,19 @@ void MathMLStream::cr()
 }
 
 
-
 //////////////////////////////////////////////////////////////////////
 
 
-MapleStream & operator<<(MapleStream & ms, MathInset const * p)
+MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 {
-       if (p)
-               p->maplize(ms);
-       else
-               lyxerr << "operator<<(MapleStream, NULL) called\n";
+       at->maple(ms);
        return ms;
 }
 
 
 MapleStream & operator<<(MapleStream & ms, MathArray const & ar)
 {
-       maplize(ar, ms);
+       maple(ar, ms);
        return ms;
 }
 
@@ -118,68 +211,76 @@ MapleStream & operator<<(MapleStream & ms, int i)
 //////////////////////////////////////////////////////////////////////
 
 
-OctaveStream & operator<<(OctaveStream & ns, MathInset const * p)
+MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 {
-       if (p)
-               p->octavize(ns);
-       else
-               lyxerr << "operator<<(OctaveStream, NULL) called\n";
-       return ns;
+       at->maxima(ms);
+       return ms;
 }
 
 
-OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
+MaximaStream & operator<<(MaximaStream & ms, MathArray const & ar)
 {
-       octavize(ar, ns);
-       return ns;
+       maxima(ar, ms);
+       return ms;
 }
 
 
-OctaveStream & operator<<(OctaveStream & ns, char const * s)
+MaximaStream & operator<<(MaximaStream & ms, char const * s)
 {
-       ns.os() << s;
-       return ns;
+       ms.os() << s;
+       return ms;
 }
 
 
-OctaveStream & operator<<(OctaveStream & ns, char c)
+MaximaStream & operator<<(MaximaStream & ms, char c)
 {
-       ns.os() << c;
-       return ns;
+       ms.os() << c;
+       return ms;
+}
+
+
+MaximaStream & operator<<(MaximaStream & ms, int i)
+{
+       ms.os() << i;
+       return ms;
 }
 
 
 //////////////////////////////////////////////////////////////////////
 
 
-NormalStream & operator<<(NormalStream & ns, MathInset const * p)
+MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 {
-       if (p)
-               p->normalize(ns);
-       else
-               lyxerr << "operator<<(NormalStream, NULL) called\n";
-       return ns;
+       at->mathematica(ms);
+       return ms;
 }
 
 
-NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
+MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 {
-       normalize(ar, ns);
-       return ns;
+       mathematica(ar, ms);
+       return ms;
 }
 
 
-NormalStream & operator<<(NormalStream & ns, char const * s)
+MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 {
-       ns.os() << s;
-       return ns;
+       ms.os() << s;
+       return ms;
 }
 
 
-NormalStream & operator<<(NormalStream & ns, char c)
+MathematicaStream & operator<<(MathematicaStream & ms, char c)
 {
-       ns.os() << c;
-       return ns;
+       ms.os() << c;
+       return ms;
+}
+
+
+MathematicaStream & operator<<(MathematicaStream & ms, int i)
+{
+       ms.os() << i;
+       return ms;
 }
 
 
@@ -187,65 +288,78 @@ NormalStream & operator<<(NormalStream & ns, char c)
 //////////////////////////////////////////////////////////////////////
 
 
-WriteStream::WriteStream(ostream & os, bool fragile)
-       : os_(os), fragile_(fragile), firstitem_(false), line_(0)
-{}
+OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
+{
+       at->octave(ns);
+       return ns;
+}
 
 
-WriteStream::WriteStream(ostream & os)
-       : os_(os), fragile_(false), firstitem_(false), line_(0)
-{}
+OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
+{
+       octave(ar, ns);
+       return ns;
+}
 
 
-void WriteStream::addlines(unsigned int n)
+OctaveStream & operator<<(OctaveStream & ns, char const * s)
 {
-       line_ += n;
+       ns.os() << s;
+       return ns;
+}
+
+
+OctaveStream & operator<<(OctaveStream & ns, char c)
+{
+       ns.os() << c;
+       return ns;
 }
 
 
-WriteStream & operator<<(WriteStream & ws, MathInset const * p)
+OctaveStream & operator<<(OctaveStream & ns, int i)
 {
-       if (p)
-               p->write(ws);
-       else
-               lyxerr << "operator<<(WriteStream, NULL) called\n";
-       return ws;
+       ns.os() << i;
+       return ns;
 }
 
 
-WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
+//////////////////////////////////////////////////////////////////////
+
+
+NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 {
-       write(ar, ws);
-       return ws;
+       at->normalize(ns);
+       return ns;
 }
 
 
-WriteStream & operator<<(WriteStream & ws, char const * s)
+NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 {
-       ws.os() << s;
-       ws.addlines(int(lyx::count(s, s+strlen(s), '\n')));
-       return ws;
+       normalize(ar, ns);
+       return ns;
 }
 
 
-WriteStream & operator<<(WriteStream & ws, char c)
+NormalStream & operator<<(NormalStream & ns, char const * s)
 {
-       ws.os() << c;
-       if (c == '\n')
-               ws.addlines(1);
-       return ws;
+       ns.os() << s;
+       return ns;
 }
 
 
-WriteStream & operator<<(WriteStream & ws, int i)
+NormalStream & operator<<(NormalStream & ns, char c)
 {
-       ws.os() << i;
-       return ws;
+       ns.os() << c;
+       return ns;
 }
 
 
-WriteStream & operator<<(WriteStream & ws, unsigned int i)
+NormalStream & operator<<(NormalStream & ns, int i)
 {
-       ws.os() << i;
-       return ws;
+       ns.os() << i;
+       return ns;
 }
+
+
+
+//////////////////////////////////////////////////////////////////////