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