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