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