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/docstring.h"
  19 #include "support/RefChanger.h"
  20 #include "support/textutils.h"
  21
  22 #include <algorithm>
  23 #include <cstring>
  24 #include <ostream>
  25
  26 using namespace std;
  27
  28 namespace lyx {
  29
  30
  31 //////////////////////////////////////////////////////////////////////
  32
  33
  34 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
  35 {
  36         at->normalize(ns);
  37         return ns;
  38 }
  39
  40
  41 NormalStream & operator<<(NormalStream & ns, MathData const & ar)
  42 {
  43         normalize(ar, ns);
  44         return ns;
  45 }
  46
  47
  48 NormalStream & operator<<(NormalStream & ns, docstring const & s)
  49 {
  50         ns.os() << s;
  51         return ns;
  52 }
  53
  54
  55 NormalStream & operator<<(NormalStream & ns, const string & s)
  56 {
  57         ns.os() << from_utf8(s);
  58         return ns;
  59 }
  60
  61
  62 NormalStream & operator<<(NormalStream & ns, char const * s)
  63 {
  64         ns.os() << s;
  65         return ns;
  66 }
  67
  68
  69 NormalStream & operator<<(NormalStream & ns, char c)
  70 {
  71         ns.os() << c;
  72         return ns;
  73 }
  74
  75
  76 NormalStream & operator<<(NormalStream & ns, int i)
  77 {
  78         ns.os() << i;
  79         return ns;
  80 }
  81
  82
  83
  84 /////////////////////////////////////////////////////////////////
  85
  86
  87 WriteStream & operator<<(WriteStream & ws, docstring const & s)
  88 {
  89         // Skip leading '\n' if we had already output a newline char
  90         size_t const first =
  91                 (s.length() > 0 && (s[0] != '\n' || ws.canBreakLine())) ? 0 : 1;
  92
  93         // Check whether there's something to output
  94         if (s.length() <= first)
  95                 return ws;
  96
  97         if (ws.pendingBrace()) {
  98                 ws.os() << '}';
  99                 ws.pendingBrace(false);
 100                 ws.pendingSpace(false);
 101                 ws.textMode(true);
 102         } else if (ws.pendingSpace()) {
 103                 if (isAlphaASCII(s[first]))
 104                         ws.os() << ' ';
 105                 else if (s[first] == ' ' && ws.textMode())
 106                         ws.os() << '\\';
 107                 ws.pendingSpace(false);
 108         }
 109         ws.os() << s.substr(first);
 110         int lf = 0;
 111         char_type lastchar = 0;
 112         docstring::const_iterator dit = s.begin() + first;
 113         docstring::const_iterator end = s.end();
 114         for (; dit != end; ++dit) {
 115                 lastchar = *dit;
 116                 if (lastchar == '\n')
 117                         ++lf;
 118         }
 119         ws.addlines(lf);
 120         ws.canBreakLine(lastchar != '\n');
 121         return ws;
 122 }
 123
 124
 125 WriteStream::WriteStream(otexrowstream & os, bool fragile, bool latex,
 126                                                  OutputType output, Encoding const * encoding)
 127         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
 128           output_(output), pendingspace_(false), pendingbrace_(false),
 129           textmode_(false), locked_(0), ascii_(0), canbreakline_(true),
 130           line_(0), encoding_(encoding), row_entry_(TexRow::row_none)
 131 {}
 132
 133
 134 WriteStream::~WriteStream()
 135 {
 136         if (pendingbrace_)
 137                 os_ << '}';
 138         else if (pendingspace_)
 139                 os_ << ' ';
 140 }
 141
 142
 143 void WriteStream::addlines(unsigned int n)
 144 {
 145         line_ += n;
 146 }
 147
 148
 149 void WriteStream::pendingSpace(bool how)
 150 {
 151         pendingspace_ = how;
 152 }
 153
 154
 155 void WriteStream::pendingBrace(bool brace)
 156 {
 157         pendingbrace_ = brace;
 158 }
 159
 160
 161 void WriteStream::textMode(bool textmode)
 162 {
 163         textmode_ = textmode;
 164 }
 165
 166
 167 void WriteStream::lockedMode(bool locked)
 168 {
 169         locked_ = locked;
 170 }
 171
 172
 173 void WriteStream::asciiOnly(bool ascii)
 174 {
 175         ascii_ = ascii;
 176 }
 177
 178
 179 Changer WriteStream::changeRowEntry(TexRow::RowEntry entry)
 180 {
 181         return make_change(row_entry_, entry);
 182 }
 183
 184
 185 bool WriteStream::startOuterRow()
 186 {
 187         if (TexRow::isNone(row_entry_))
 188                 return false;
 189         return texrow().start(row_entry_);
 190 }
 191
 192
 193 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
 194 {
 195         at->write(ws);
 196         return ws;
 197 }
 198
 199
 200 WriteStream & operator<<(WriteStream & ws, MathData const & ar)
 201 {
 202         write(ar, ws);
 203         return ws;
 204 }
 205
 206
 207 WriteStream & operator<<(WriteStream & ws, char const * s)
 208 {
 209         ws << from_utf8(s);
 210         return ws;
 211 }
 212
 213
 214 WriteStream & operator<<(WriteStream & ws, char c)
 215 {
 216         if (c == '\n' && !ws.canBreakLine())
 217                 return ws;
 218
 219         if (ws.pendingBrace()) {
 220                 ws.os() << '}';
 221                 ws.pendingBrace(false);
 222                 ws.pendingSpace(false);
 223                 ws.textMode(true);
 224         } else if (ws.pendingSpace()) {
 225                 if (isAlphaASCII(c))
 226                         ws.os() << ' ';
 227                 else if (c == ' ' && ws.textMode())
 228                         ws.os() << '\\';
 229                 ws.pendingSpace(false);
 230         }
 231         ws.os() << c;
 232         if (c == '\n')
 233                 ws.addlines(1);
 234         ws.canBreakLine(c != '\n');
 235         return ws;
 236 }
 237
 238
 239 WriteStream & operator<<(WriteStream & ws, int i)
 240 {
 241         if (ws.pendingBrace()) {
 242                 ws.os() << '}';
 243                 ws.pendingBrace(false);
 244                 ws.textMode(true);
 245         }
 246         ws.os() << i;
 247         ws.canBreakLine(true);
 248         return ws;
 249 }
 250
 251
 252 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 253 {
 254         if (ws.pendingBrace()) {
 255                 ws.os() << '}';
 256                 ws.pendingBrace(false);
 257                 ws.textMode(true);
 258         }
 259         ws.os() << i;
 260         ws.canBreakLine(true);
 261         return ws;
 262 }
 263
 264
 265 //////////////////////////////////////////////////////////////////////
 266
 267
 268 MathStream::MathStream(odocstream & os)
 269         : os_(os), tab_(0), line_(0), in_text_(false)
 270 {}
 271
 272
 273 void MathStream::cr()
 274 {
 275         os() << '\n';
 276         for (int i = 0; i < tab(); ++i)
 277                 os() << ' ';
 278 }
 279
 280
 281 void MathStream::defer(docstring const & s)
 282 {
 283         deferred_ << s;
 284 }
 285
 286
 287 void MathStream::defer(string const & s)
 288 {
 289         deferred_ << from_utf8(s);
 290 }
 291
 292
 293 docstring MathStream::deferred() const
 294 {
 295         return deferred_.str();
 296 }
 297
 298
 299 MathStream & operator<<(MathStream & ms, MathAtom const & at)
 300 {
 301         at->mathmlize(ms);
 302         return ms;
 303 }
 304
 305
 306 MathStream & operator<<(MathStream & ms, MathData const & ar)
 307 {
 308         mathmlize(ar, ms);
 309         return ms;
 310 }
 311
 312
 313 MathStream & operator<<(MathStream & ms, char const * s)
 314 {
 315         ms.os() << s;
 316         return ms;
 317 }
 318
 319
 320 MathStream & operator<<(MathStream & ms, char c)
 321 {
 322         ms.os() << c;
 323         return ms;
 324 }
 325
 326
 327 MathStream & operator<<(MathStream & ms, char_type c)
 328 {
 329         ms.os().put(c);
 330         return ms;
 331 }
 332
 333
 334 MathStream & operator<<(MathStream & ms, MTag const & t)
 335 {
 336         ++ms.tab();
 337         ms.cr();
 338         ms.os() << '<' << from_ascii(t.tag_);
 339         if (!t.attr_.empty())
 340                 ms.os() << " " << from_ascii(t.attr_);
 341         ms << '>';
 342         return ms;
 343 }
 344
 345
 346 MathStream & operator<<(MathStream & ms, ETag const & t)
 347 {
 348         ms.cr();
 349         if (ms.tab() > 0)
 350                 --ms.tab();
 351         ms.os() << "</" << from_ascii(t.tag_) << '>';
 352         return ms;
 353 }
 354
 355
 356 MathStream & operator<<(MathStream & ms, docstring const & s)
 357 {
 358         ms.os() << s;
 359         return ms;
 360 }
 361
 362
 363 //////////////////////////////////////////////////////////////////////
 364
 365
 366 HtmlStream::HtmlStream(odocstream & os)
 367         : os_(os), tab_(0), line_(0), in_text_(false)
 368 {}
 369
 370
 371 void HtmlStream::defer(docstring const & s)
 372 {
 373         deferred_ << s;
 374 }
 375
 376
 377 void HtmlStream::defer(string const & s)
 378 {
 379         deferred_ << from_utf8(s);
 380 }
 381
 382
 383 docstring HtmlStream::deferred() const
 384 {
 385         return deferred_.str();
 386 }
 387
 388
 389 HtmlStream & operator<<(HtmlStream & ms, MathAtom const & at)
 390 {
 391         at->htmlize(ms);
 392         return ms;
 393 }
 394
 395
 396 HtmlStream & operator<<(HtmlStream & ms, MathData const & ar)
 397 {
 398         htmlize(ar, ms);
 399         return ms;
 400 }
 401
 402
 403 HtmlStream & operator<<(HtmlStream & ms, char const * s)
 404 {
 405         ms.os() << s;
 406         return ms;
 407 }
 408
 409
 410 HtmlStream & operator<<(HtmlStream & ms, char c)
 411 {
 412         ms.os() << c;
 413         return ms;
 414 }
 415
 416
 417 HtmlStream & operator<<(HtmlStream & ms, char_type c)
 418 {
 419         ms.os().put(c);
 420         return ms;
 421 }
 422
 423
 424 HtmlStream & operator<<(HtmlStream & ms, MTag const & t)
 425 {
 426         ms.os() << '<' << from_ascii(t.tag_);
 427         if (!t.attr_.empty())
 428                 ms.os() << " " << from_ascii(t.attr_);
 429         ms << '>';
 430         return ms;
 431 }
 432
 433
 434 HtmlStream & operator<<(HtmlStream & ms, ETag const & t)
 435 {
 436         ms.os() << "</" << from_ascii(t.tag_) << '>';
 437         return ms;
 438 }
 439
 440
 441 HtmlStream & operator<<(HtmlStream & ms, docstring const & s)
 442 {
 443         ms.os() << s;
 444         return ms;
 445 }
 446
 447
 448 //////////////////////////////////////////////////////////////////////
 449
 450
 451 SetMode::SetMode(MathStream & os, bool text)
 452         : os_(os)
 453 {
 454         was_text_ = os_.inText();
 455         os_.setTextMode(text);
 456 }
 457
 458
 459 SetMode::~SetMode()
 460 {
 461         os_.setTextMode(was_text_);
 462 }
 463
 464
 465 //////////////////////////////////////////////////////////////////////
 466
 467
 468 SetHTMLMode::SetHTMLMode(HtmlStream & os, bool text)
 469         : os_(os)
 470 {
 471         was_text_ = os_.inText();
 472         os_.setTextMode(text);
 473 }
 474
 475
 476 SetHTMLMode::~SetHTMLMode()
 477 {
 478         os_.setTextMode(was_text_);
 479 }
 480
 481
 482 //////////////////////////////////////////////////////////////////////
 483
 484
 485 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 486 {
 487         at->maple(ms);
 488         return ms;
 489 }
 490
 491
 492 MapleStream & operator<<(MapleStream & ms, MathData const & ar)
 493 {
 494         maple(ar, ms);
 495         return ms;
 496 }
 497
 498
 499 MapleStream & operator<<(MapleStream & ms, char const * s)
 500 {
 501         ms.os() << s;
 502         return ms;
 503 }
 504
 505
 506 MapleStream & operator<<(MapleStream & ms, char c)
 507 {
 508         ms.os() << c;
 509         return ms;
 510 }
 511
 512
 513 MapleStream & operator<<(MapleStream & ms, int i)
 514 {
 515         ms.os() << i;
 516         return ms;
 517 }
 518
 519
 520 MapleStream & operator<<(MapleStream & ms, char_type c)
 521 {
 522         ms.os().put(c);
 523         return ms;
 524 }
 525
 526
 527 MapleStream & operator<<(MapleStream & ms, docstring const & s)
 528 {
 529         ms.os() << s;
 530         return ms;
 531 }
 532
 533
 534 //////////////////////////////////////////////////////////////////////
 535
 536
 537 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 538 {
 539         at->maxima(ms);
 540         return ms;
 541 }
 542
 543
 544 MaximaStream & operator<<(MaximaStream & ms, MathData const & ar)
 545 {
 546         maxima(ar, ms);
 547         return ms;
 548 }
 549
 550
 551 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 552 {
 553         ms.os() << s;
 554         return ms;
 555 }
 556
 557
 558 MaximaStream & operator<<(MaximaStream & ms, char c)
 559 {
 560         ms.os() << c;
 561         return ms;
 562 }
 563
 564
 565 MaximaStream & operator<<(MaximaStream & ms, int i)
 566 {
 567         ms.os() << i;
 568         return ms;
 569 }
 570
 571
 572 MaximaStream & operator<<(MaximaStream & ms, docstring const & s)
 573 {
 574         ms.os() << s;
 575         return ms;
 576 }
 577
 578
 579 MaximaStream & operator<<(MaximaStream & ms, char_type c)
 580 {
 581         ms.os().put(c);
 582         return ms;
 583 }
 584
 585
 586 //////////////////////////////////////////////////////////////////////
 587
 588
 589 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 590 {
 591         at->mathematica(ms);
 592         return ms;
 593 }
 594
 595
 596 MathematicaStream & operator<<(MathematicaStream & ms, MathData const & ar)
 597 {
 598         mathematica(ar, ms);
 599         return ms;
 600 }
 601
 602
 603 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 604 {
 605         ms.os() << s;
 606         return ms;
 607 }
 608
 609
 610 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 611 {
 612         ms.os() << c;
 613         return ms;
 614 }
 615
 616
 617 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 618 {
 619         ms.os() << i;
 620         return ms;
 621 }
 622
 623
 624 MathematicaStream & operator<<(MathematicaStream & ms, docstring const & s)
 625 {
 626         ms.os() << s;
 627         return ms;
 628 }
 629
 630
 631 MathematicaStream & operator<<(MathematicaStream & ms, char_type c)
 632 {
 633         ms.os().put(c);
 634         return ms;
 635 }
 636
 637
 638 //////////////////////////////////////////////////////////////////////
 639
 640
 641 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 642 {
 643         at->octave(ns);
 644         return ns;
 645 }
 646
 647
 648 OctaveStream & operator<<(OctaveStream & ns, MathData const & ar)
 649 {
 650         octave(ar, ns);
 651         return ns;
 652 }
 653
 654
 655 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 656 {
 657         ns.os() << s;
 658         return ns;
 659 }
 660
 661
 662 OctaveStream & operator<<(OctaveStream & ns, char c)
 663 {
 664         ns.os() << c;
 665         return ns;
 666 }
 667
 668
 669 OctaveStream & operator<<(OctaveStream & ns, int i)
 670 {
 671         ns.os() << i;
 672         return ns;
 673 }
 674
 675
 676 OctaveStream & operator<<(OctaveStream & ns, docstring const & s)
 677 {
 678         ns.os() << s;
 679         return ns;
 680 }
 681
 682
 683 OctaveStream & operator<<(OctaveStream & ns, char_type c)
 684 {
 685         ns.os().put(c);
 686         return ns;
 687 }
 688
 689
 690 OctaveStream & operator<<(OctaveStream & os, string const & s)
 691 {
 692         os.os() << from_utf8(s);
 693         return os;
 694 }
 695
 696
 697 } // namespace lyx