src/mathed/MathStream.C

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