src/mathed/MathStream.cpp

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