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