src/mathed/math_mathmlstream.C

   1 /**
   2  * \file math_mathmlstream.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author André Pönitz
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "math_mathmlstream.h"
  14 #include "math_inset.h"
  15 #include "math_data.h"
  16 #include "math_extern.h"
  17 #include "support/lyxalgo.h"
  18
  19
  20 using std::ostream;
  21 using std::strlen;
  22
  23 namespace {
  24
  25         bool isAlpha(char c)
  26         {
  27                 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
  28         }
  29
  30 }
  31
  32 WriteStream::WriteStream(ostream & os, bool fragile, bool latex)
  33         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
  34           pendingspace_(false), line_(0)
  35 {}
  36
  37
  38 WriteStream::WriteStream(ostream & os)
  39         : os_(os), fragile_(false), firstitem_(false), latex_(false),
  40           pendingspace_(false), line_(0)
  41 {}
  42
  43
  44 WriteStream::~WriteStream()
  45 {
  46         if (pendingspace_)
  47                 os_ << ' ';
  48 }
  49
  50
  51 void WriteStream::addlines(unsigned int n)
  52 {
  53         line_ += n;
  54 }
  55
  56
  57 void WriteStream::pendingSpace(bool how)
  58 {
  59         pendingspace_ = how;
  60 }
  61
  62
  63 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
  64 {
  65         at->write(ws);
  66         return ws;
  67 }
  68
  69
  70 WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
  71 {
  72         write(ar, ws);
  73         return ws;
  74 }
  75
  76
  77 WriteStream & operator<<(WriteStream & ws, char const * s)
  78 {
  79         if (ws.pendingSpace() && strlen(s) > 0) {
  80                 if (isAlpha(s[0]))
  81                         ws.os() << ' ';
  82                 ws.pendingSpace(false);
  83         }
  84         ws.os() << s;
  85         ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
  86         return ws;
  87 }
  88
  89
  90 WriteStream & operator<<(WriteStream & ws, char c)
  91 {
  92         if (ws.pendingSpace()) {
  93                 if (isAlpha(c))
  94                         ws.os() << ' ';
  95                 ws.pendingSpace(false);
  96         }
  97         ws.os() << c;
  98         if (c == '\n')
  99                 ws.addlines(1);
 100         return ws;
 101 }
 102
 103
 104 WriteStream & operator<<(WriteStream & ws, int i)
 105 {
 106         ws.os() << i;
 107         return ws;
 108 }
 109
 110
 111 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 112 {
 113         ws.os() << i;
 114         return ws;
 115 }
 116
 117
 118 //////////////////////////////////////////////////////////////////////
 119
 120
 121 MathMLStream::MathMLStream(ostream & os)
 122         : os_(os), tab_(0), line_(0), lastchar_(0)
 123 {}
 124
 125
 126 MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
 127 {
 128         at->mathmlize(ms);
 129         return ms;
 130 }
 131
 132
 133 MathMLStream & operator<<(MathMLStream & ms, MathArray const & ar)
 134 {
 135         mathmlize(ar, ms);
 136         return ms;
 137 }
 138
 139
 140 MathMLStream & operator<<(MathMLStream & ms, char const * s)
 141 {
 142         ms.os() << s;
 143         return ms;
 144 }
 145
 146
 147 MathMLStream & operator<<(MathMLStream & ms, char c)
 148 {
 149         ms.os() << c;
 150         return ms;
 151 }
 152
 153
 154 MathMLStream & operator<<(MathMLStream & ms, MTag const & t)
 155 {
 156         ++ms.tab();
 157         ms.cr();
 158         ms.os() << '<' << t.tag_ << '>';
 159         return ms;
 160 }
 161
 162
 163 MathMLStream & operator<<(MathMLStream & ms, ETag const & t)
 164 {
 165         ms.cr();
 166         if (ms.tab() > 0)
 167                 --ms.tab();
 168         ms.os() << "</" << t.tag_ << '>';
 169         return ms;
 170 }
 171
 172
 173 void MathMLStream::cr()
 174 {
 175         os() << '\n';
 176         for (int i = 0; i < tab(); ++i)
 177                 os() << ' ';
 178 }
 179
 180
 181 //////////////////////////////////////////////////////////////////////
 182
 183
 184 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 185 {
 186         at->maple(ms);
 187         return ms;
 188 }
 189
 190
 191 MapleStream & operator<<(MapleStream & ms, MathArray const & ar)
 192 {
 193         maple(ar, ms);
 194         return ms;
 195 }
 196
 197
 198 MapleStream & operator<<(MapleStream & ms, char const * s)
 199 {
 200         ms.os() << s;
 201         return ms;
 202 }
 203
 204
 205 MapleStream & operator<<(MapleStream & ms, char c)
 206 {
 207         ms.os() << c;
 208         return ms;
 209 }
 210
 211
 212 MapleStream & operator<<(MapleStream & ms, int i)
 213 {
 214         ms.os() << i;
 215         return ms;
 216 }
 217
 218
 219 //////////////////////////////////////////////////////////////////////
 220
 221
 222 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 223 {
 224         at->maxima(ms);
 225         return ms;
 226 }
 227
 228
 229 MaximaStream & operator<<(MaximaStream & ms, MathArray const & ar)
 230 {
 231         maxima(ar, ms);
 232         return ms;
 233 }
 234
 235
 236 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 237 {
 238         ms.os() << s;
 239         return ms;
 240 }
 241
 242
 243 MaximaStream & operator<<(MaximaStream & ms, char c)
 244 {
 245         ms.os() << c;
 246         return ms;
 247 }
 248
 249
 250 MaximaStream & operator<<(MaximaStream & ms, int i)
 251 {
 252         ms.os() << i;
 253         return ms;
 254 }
 255
 256
 257 //////////////////////////////////////////////////////////////////////
 258
 259
 260 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 261 {
 262         at->mathematica(ms);
 263         return ms;
 264 }
 265
 266
 267 MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 268 {
 269         mathematica(ar, ms);
 270         return ms;
 271 }
 272
 273
 274 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 275 {
 276         ms.os() << s;
 277         return ms;
 278 }
 279
 280
 281 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 282 {
 283         ms.os() << c;
 284         return ms;
 285 }
 286
 287
 288 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 289 {
 290         ms.os() << i;
 291         return ms;
 292 }
 293
 294
 295
 296 //////////////////////////////////////////////////////////////////////
 297
 298
 299 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 300 {
 301         at->octave(ns);
 302         return ns;
 303 }
 304
 305
 306 OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
 307 {
 308         octave(ar, ns);
 309         return ns;
 310 }
 311
 312
 313 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 314 {
 315         ns.os() << s;
 316         return ns;
 317 }
 318
 319
 320 OctaveStream & operator<<(OctaveStream & ns, char c)
 321 {
 322         ns.os() << c;
 323         return ns;
 324 }
 325
 326
 327 OctaveStream & operator<<(OctaveStream & ns, int i)
 328 {
 329         ns.os() << i;
 330         return ns;
 331 }
 332
 333
 334 //////////////////////////////////////////////////////////////////////
 335
 336
 337 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 338 {
 339         at->normalize(ns);
 340         return ns;
 341 }
 342
 343
 344 NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 345 {
 346         normalize(ar, ns);
 347         return ns;
 348 }
 349
 350
 351 NormalStream & operator<<(NormalStream & ns, char const * s)
 352 {
 353         ns.os() << s;
 354         return ns;
 355 }
 356
 357
 358 NormalStream & operator<<(NormalStream & ns, char c)
 359 {
 360         ns.os() << c;
 361         return ns;
 362 }
 363
 364
 365 NormalStream & operator<<(NormalStream & ns, int i)
 366 {
 367         ns.os() << i;
 368         return ns;
 369 }
 370
 371
 372
 373 //////////////////////////////////////////////////////////////////////