src/mathed/math_mathmlstream.C

   1 #include <config.h>
   2
   3 #include "math_mathmlstream.h"
   4 #include "math_inset.h"
   5 #include "math_extern.h"
   6 #include "debug.h"
   7 #include "support/lyxalgo.h"
   8 #include "support/LOstream.h"
   9
  10
  11 using std::ostream;
  12 using std::strlen;
  13
  14
  15 WriteStream::WriteStream(ostream & os, bool fragile, bool latex)
  16         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
  17           pendingspace_(false), line_(0)
  18 {}
  19
  20
  21 WriteStream::WriteStream(ostream & os)
  22         : os_(os), fragile_(false), firstitem_(false), latex_(false),
  23           pendingspace_(false), line_(0)
  24 {}
  25
  26
  27 WriteStream::~WriteStream()
  28 {
  29         if (pendingspace_)
  30                 os_ << ' ';
  31 }
  32
  33
  34 void WriteStream::addlines(unsigned int n)
  35 {
  36         line_ += n;
  37 }
  38
  39
  40 void WriteStream::pendingSpace(bool how)
  41 {
  42         pendingspace_ = how;
  43 }
  44
  45
  46 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
  47 {
  48         at->write(ws);
  49         return ws;
  50 }
  51
  52
  53 WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
  54 {
  55         write(ar, ws);
  56         return ws;
  57 }
  58
  59
  60 WriteStream & operator<<(WriteStream & ws, char const * s)
  61 {
  62         ws.os() << s;
  63         ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
  64         return ws;
  65 }
  66
  67
  68 WriteStream & operator<<(WriteStream & ws, char c)
  69 {
  70         if (ws.pendingSpace()) {
  71                 if (isalpha(c))
  72                         ws.os() << ' ';
  73                 ws.pendingSpace(false);
  74         }
  75         ws.os() << c;
  76         if (c == '\n')
  77                 ws.addlines(1);
  78         return ws;
  79 }
  80
  81
  82 WriteStream & operator<<(WriteStream & ws, int i)
  83 {
  84         ws.os() << i;
  85         return ws;
  86 }
  87
  88
  89 WriteStream & operator<<(WriteStream & ws, unsigned int i)
  90 {
  91         ws.os() << i;
  92         return ws;
  93 }
  94
  95
  96 //////////////////////////////////////////////////////////////////////
  97
  98
  99 MathMLStream::MathMLStream(ostream & os)
 100         : os_(os), tab_(0), line_(0), lastchar_(0)
 101 {}
 102
 103
 104 MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
 105 {
 106         at->mathmlize(ms);
 107         return ms;
 108 }
 109
 110
 111 MathMLStream & operator<<(MathMLStream & ms, MathArray const & ar)
 112 {
 113         mathmlize(ar, ms);
 114         return ms;
 115 }
 116
 117
 118 MathMLStream & operator<<(MathMLStream & ms, char const * s)
 119 {
 120         ms.os() << s;
 121         return ms;
 122 }
 123
 124
 125 MathMLStream & operator<<(MathMLStream & ms, char c)
 126 {
 127         ms.os() << c;
 128         return ms;
 129 }
 130
 131
 132 MathMLStream & operator<<(MathMLStream & ms, MTag const & t)
 133 {
 134         ++ms.tab();
 135         ms.cr();
 136         ms.os() << '<' << t.tag_ << '>';
 137         return ms;
 138 }
 139
 140
 141 MathMLStream & operator<<(MathMLStream & ms, ETag const & t)
 142 {
 143         ms.cr();
 144         if (ms.tab() > 0)
 145                 --ms.tab();
 146         ms.os() << "</" << t.tag_ << '>';
 147         return ms;
 148 }
 149
 150
 151 void MathMLStream::cr()
 152 {
 153         os() << '\n';
 154         for (int i = 0; i < tab(); ++i)
 155                 os() << ' ';
 156 }
 157
 158
 159
 160 //////////////////////////////////////////////////////////////////////
 161
 162
 163 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 164 {
 165         at->maplize(ms);
 166         return ms;
 167 }
 168
 169
 170 MapleStream & operator<<(MapleStream & ms, MathArray const & ar)
 171 {
 172         maplize(ar, ms);
 173         return ms;
 174 }
 175
 176
 177 MapleStream & operator<<(MapleStream & ms, char const * s)
 178 {
 179         ms.os() << s;
 180         return ms;
 181 }
 182
 183
 184 MapleStream & operator<<(MapleStream & ms, char c)
 185 {
 186         ms.os() << c;
 187         return ms;
 188 }
 189
 190
 191 MapleStream & operator<<(MapleStream & ms, int i)
 192 {
 193         ms.os() << i;
 194         return ms;
 195 }
 196
 197
 198 //////////////////////////////////////////////////////////////////////
 199
 200
 201 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 202 {
 203         at->mathematicize(ms);
 204         return ms;
 205 }
 206
 207
 208 MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 209 {
 210         mathematicize(ar, ms);
 211         return ms;
 212 }
 213
 214
 215 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 216 {
 217         ms.os() << s;
 218         return ms;
 219 }
 220
 221
 222 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 223 {
 224         ms.os() << c;
 225         return ms;
 226 }
 227
 228
 229 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 230 {
 231         ms.os() << i;
 232         return ms;
 233 }
 234
 235
 236
 237 //////////////////////////////////////////////////////////////////////
 238
 239
 240 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 241 {
 242         at->octavize(ns);
 243         return ns;
 244 }
 245
 246
 247 OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
 248 {
 249         octavize(ar, ns);
 250         return ns;
 251 }
 252
 253
 254 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 255 {
 256         ns.os() << s;
 257         return ns;
 258 }
 259
 260
 261 OctaveStream & operator<<(OctaveStream & ns, char c)
 262 {
 263         ns.os() << c;
 264         return ns;
 265 }
 266
 267
 268 OctaveStream & operator<<(OctaveStream & ns, int i)
 269 {
 270         ns.os() << i;
 271         return ns;
 272 }
 273
 274
 275 //////////////////////////////////////////////////////////////////////
 276
 277
 278 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 279 {
 280         at->normalize(ns);
 281         return ns;
 282 }
 283
 284
 285 NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 286 {
 287         normalize(ar, ns);
 288         return ns;
 289 }
 290
 291
 292 NormalStream & operator<<(NormalStream & ns, char const * s)
 293 {
 294         ns.os() << s;
 295         return ns;
 296 }
 297
 298
 299 NormalStream & operator<<(NormalStream & ns, char c)
 300 {
 301         ns.os() << c;
 302         return ns;
 303 }
 304
 305
 306 NormalStream & operator<<(NormalStream & ns, int i)
 307 {
 308         ns.os() << i;
 309         return ns;
 310 }
 311
 312
 313
 314 //////////////////////////////////////////////////////////////////////
 315