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), locked_(0), 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), locked_(0), 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 void WriteStream::lockedMode(bool locked)
 159 {
 160         locked_ = locked;
 161 }
 162
 163
 164 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
 165 {
 166         at->write(ws);
 167         return ws;
 168 }
 169
 170
 171 WriteStream & operator<<(WriteStream & ws, MathData const & ar)
 172 {
 173         write(ar, ws);
 174         return ws;
 175 }
 176
 177
 178 WriteStream & operator<<(WriteStream & ws, char const * s)
 179 {
 180         if (ws.pendingBrace()) {
 181                 ws.os() << '}';
 182                 ws.pendingBrace(false);
 183                 ws.pendingSpace(false);
 184                 ws.textMode(true);
 185         } else if (ws.pendingSpace() && strlen(s) > 0) {
 186                 if (isAlphaASCII(s[0]))
 187                         ws.os() << ' ';
 188                 ws.pendingSpace(false);
 189         }
 190         ws.os() << s;
 191         ws.addlines(int(count(s, s + strlen(s), '\n')));
 192         return ws;
 193 }
 194
 195
 196 WriteStream & operator<<(WriteStream & ws, char c)
 197 {
 198         if (ws.pendingBrace()) {
 199                 ws.os() << '}';
 200                 ws.pendingBrace(false);
 201                 ws.pendingSpace(false);
 202                 ws.textMode(true);
 203         } else if (ws.pendingSpace()) {
 204                 if (isAlphaASCII(c))
 205                         ws.os() << ' ';
 206                 ws.pendingSpace(false);
 207         }
 208         ws.os() << c;
 209         if (c == '\n')
 210                 ws.addlines(1);
 211         return ws;
 212 }
 213
 214
 215 WriteStream & operator<<(WriteStream & ws, int i)
 216 {
 217         if (ws.pendingBrace()) {
 218                 ws.os() << '}';
 219                 ws.pendingBrace(false);
 220                 ws.textMode(true);
 221         }
 222         ws.os() << i;
 223         return ws;
 224 }
 225
 226
 227 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 228 {
 229         if (ws.pendingBrace()) {
 230                 ws.os() << '}';
 231                 ws.pendingBrace(false);
 232                 ws.textMode(true);
 233         }
 234         ws.os() << i;
 235         return ws;
 236 }
 237
 238
 239 //////////////////////////////////////////////////////////////////////
 240
 241
 242 MathStream::MathStream(odocstream & os)
 243         : os_(os), tab_(0), line_(0), lastchar_(0)
 244 {}
 245
 246
 247 MathStream & operator<<(MathStream & ms, MathAtom const & at)
 248 {
 249         at->mathmlize(ms);
 250         return ms;
 251 }
 252
 253
 254 MathStream & operator<<(MathStream & ms, MathData const & ar)
 255 {
 256         mathmlize(ar, ms);
 257         return ms;
 258 }
 259
 260
 261 MathStream & operator<<(MathStream & ms, char const * s)
 262 {
 263         ms.os() << s;
 264         return ms;
 265 }
 266
 267
 268 MathStream & operator<<(MathStream & ms, char c)
 269 {
 270         ms.os() << c;
 271         return ms;
 272 }
 273
 274
 275 MathStream & operator<<(MathStream & ms, MTag const & t)
 276 {
 277         ++ms.tab();
 278         ms.cr();
 279         ms.os() << '<' << from_ascii(t.tag_) << '>';
 280         return ms;
 281 }
 282
 283
 284 MathStream & operator<<(MathStream & ms, ETag const & t)
 285 {
 286         ms.cr();
 287         if (ms.tab() > 0)
 288                 --ms.tab();
 289         ms.os() << "</" << from_ascii(t.tag_) << '>';
 290         return ms;
 291 }
 292
 293
 294 void MathStream::cr()
 295 {
 296         os() << '\n';
 297         for (int i = 0; i < tab(); ++i)
 298                 os() << ' ';
 299 }
 300
 301
 302 MathStream & operator<<(MathStream & ms, docstring const & s)
 303 {
 304         ms.os() << s;
 305         return ms;
 306 }
 307
 308 //////////////////////////////////////////////////////////////////////
 309
 310
 311 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 312 {
 313         at->maple(ms);
 314         return ms;
 315 }
 316
 317
 318 MapleStream & operator<<(MapleStream & ms, MathData const & ar)
 319 {
 320         maple(ar, ms);
 321         return ms;
 322 }
 323
 324
 325 MapleStream & operator<<(MapleStream & ms, char const * s)
 326 {
 327         ms.os() << s;
 328         return ms;
 329 }
 330
 331
 332 MapleStream & operator<<(MapleStream & ms, char c)
 333 {
 334         ms.os() << c;
 335         return ms;
 336 }
 337
 338
 339 MapleStream & operator<<(MapleStream & ms, int i)
 340 {
 341         ms.os() << i;
 342         return ms;
 343 }
 344
 345
 346 MapleStream & operator<<(MapleStream & ms, char_type c)
 347 {
 348         ms.os().put(c);
 349         return ms;
 350 }
 351
 352
 353 MapleStream & operator<<(MapleStream & ms, docstring const & s)
 354 {
 355         ms.os() << s;
 356         return ms;
 357 }
 358
 359
 360 //////////////////////////////////////////////////////////////////////
 361
 362
 363 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 364 {
 365         at->maxima(ms);
 366         return ms;
 367 }
 368
 369
 370 MaximaStream & operator<<(MaximaStream & ms, MathData const & ar)
 371 {
 372         maxima(ar, ms);
 373         return ms;
 374 }
 375
 376
 377 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 378 {
 379         ms.os() << s;
 380         return ms;
 381 }
 382
 383
 384 MaximaStream & operator<<(MaximaStream & ms, char c)
 385 {
 386         ms.os() << c;
 387         return ms;
 388 }
 389
 390
 391 MaximaStream & operator<<(MaximaStream & ms, int i)
 392 {
 393         ms.os() << i;
 394         return ms;
 395 }
 396
 397
 398 MaximaStream & operator<<(MaximaStream & ms, docstring const & s)
 399 {
 400         ms.os() << s;
 401         return ms;
 402 }
 403
 404
 405 MaximaStream & operator<<(MaximaStream & ms, char_type c)
 406 {
 407         ms.os().put(c);
 408         return ms;
 409 }
 410
 411
 412 //////////////////////////////////////////////////////////////////////
 413
 414
 415 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 416 {
 417         at->mathematica(ms);
 418         return ms;
 419 }
 420
 421
 422 MathematicaStream & operator<<(MathematicaStream & ms, MathData const & ar)
 423 {
 424         mathematica(ar, ms);
 425         return ms;
 426 }
 427
 428
 429 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 430 {
 431         ms.os() << s;
 432         return ms;
 433 }
 434
 435
 436 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 437 {
 438         ms.os() << c;
 439         return ms;
 440 }
 441
 442
 443 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 444 {
 445         ms.os() << i;
 446         return ms;
 447 }
 448
 449
 450 MathematicaStream & operator<<(MathematicaStream & ms, docstring const & s)
 451 {
 452         ms.os() << s;
 453         return ms;
 454 }
 455
 456
 457 MathematicaStream & operator<<(MathematicaStream & ms, char_type c)
 458 {
 459         ms.os().put(c);
 460         return ms;
 461 }
 462
 463
 464 //////////////////////////////////////////////////////////////////////
 465
 466
 467 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 468 {
 469         at->octave(ns);
 470         return ns;
 471 }
 472
 473
 474 OctaveStream & operator<<(OctaveStream & ns, MathData const & ar)
 475 {
 476         octave(ar, ns);
 477         return ns;
 478 }
 479
 480
 481 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 482 {
 483         ns.os() << s;
 484         return ns;
 485 }
 486
 487
 488 OctaveStream & operator<<(OctaveStream & ns, char c)
 489 {
 490         ns.os() << c;
 491         return ns;
 492 }
 493
 494
 495 OctaveStream & operator<<(OctaveStream & ns, int i)
 496 {
 497         ns.os() << i;
 498         return ns;
 499 }
 500
 501
 502 OctaveStream & operator<<(OctaveStream & ns, docstring const & s)
 503 {
 504         ns.os() << s;
 505         return ns;
 506 }
 507
 508
 509 OctaveStream & operator<<(OctaveStream & ns, char_type c)
 510 {
 511         ns.os().put(c);
 512         return ns;
 513 }
 514
 515
 516 OctaveStream & operator<<(OctaveStream & os, string const & s)
 517 {
 518         os.os() << from_utf8(s);
 519         return os;
 520 }
 521
 522
 523 } // namespace lyx