src/mathed/MathMLStream.C

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