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 "InsetMath.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         if (ws.pendingSpace() && s.length() > 0) {
  90                 if (isAlphaASCII(s[0]))
  91                         ws.os() << ' ';
  92                 ws.pendingSpace(false);
  93         }
  94         ws.os() << s;
  95         int lf = 0;
  96         docstring::const_iterator dit = s.begin();
  97         docstring::const_iterator end = s.end();
  98         for (; dit != end; ++dit)
  99                 if ((*dit) == '\n')
 100                         ++lf;
 101         ws.addlines(lf);
 102         return ws;
 103 }
 104
 105
 106 WriteStream::WriteStream(odocstream & os, bool fragile, bool latex, bool dryrun)
 107         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
 108           dryrun_(dryrun), pendingspace_(false), textmode_(false), line_(0)
 109 {}
 110
 111
 112 WriteStream::WriteStream(odocstream & os)
 113         : os_(os), fragile_(false), firstitem_(false), latex_(false),
 114           dryrun_(false), pendingspace_(false), textmode_(false), line_(0)
 115 {}
 116
 117
 118 WriteStream::~WriteStream()
 119 {
 120         if (pendingspace_)
 121                 os_ << ' ';
 122 }
 123
 124
 125 void WriteStream::addlines(unsigned int n)
 126 {
 127         line_ += n;
 128 }
 129
 130
 131 void WriteStream::pendingSpace(bool how)
 132 {
 133         pendingspace_ = how;
 134 }
 135
 136
 137 void WriteStream::textMode(bool textmode)
 138 {
 139         textmode_ = textmode;
 140 }
 141
 142
 143 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
 144 {
 145         at->write(ws);
 146         return ws;
 147 }
 148
 149
 150 WriteStream & operator<<(WriteStream & ws, MathData const & ar)
 151 {
 152         write(ar, ws);
 153         return ws;
 154 }
 155
 156
 157 WriteStream & operator<<(WriteStream & ws, char const * s)
 158 {
 159         if (ws.pendingSpace() && strlen(s) > 0) {
 160                 if (isAlphaASCII(s[0]))
 161                         ws.os() << ' ';
 162                 ws.pendingSpace(false);
 163         }
 164         ws.os() << s;
 165         ws.addlines(int(count(s, s + strlen(s), '\n')));
 166         return ws;
 167 }
 168
 169
 170 WriteStream & operator<<(WriteStream & ws, char c)
 171 {
 172         if (ws.pendingSpace()) {
 173                 if (isAlphaASCII(c))
 174                         ws.os() << ' ';
 175                 ws.pendingSpace(false);
 176         }
 177         ws.os() << c;
 178         if (c == '\n')
 179                 ws.addlines(1);
 180         return ws;
 181 }
 182
 183
 184 WriteStream & operator<<(WriteStream & ws, int i)
 185 {
 186         ws.os() << i;
 187         return ws;
 188 }
 189
 190
 191 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 192 {
 193         ws.os() << i;
 194         return ws;
 195 }
 196
 197
 198 //////////////////////////////////////////////////////////////////////
 199
 200
 201 MathStream::MathStream(odocstream & os)
 202         : os_(os), tab_(0), line_(0), lastchar_(0)
 203 {}
 204
 205
 206 MathStream & operator<<(MathStream & ms, MathAtom const & at)
 207 {
 208         at->mathmlize(ms);
 209         return ms;
 210 }
 211
 212
 213 MathStream & operator<<(MathStream & ms, MathData const & ar)
 214 {
 215         mathmlize(ar, ms);
 216         return ms;
 217 }
 218
 219
 220 MathStream & operator<<(MathStream & ms, char const * s)
 221 {
 222         ms.os() << s;
 223         return ms;
 224 }
 225
 226
 227 MathStream & operator<<(MathStream & ms, char c)
 228 {
 229         ms.os() << c;
 230         return ms;
 231 }
 232
 233
 234 MathStream & operator<<(MathStream & ms, MTag const & t)
 235 {
 236         ++ms.tab();
 237         ms.cr();
 238         ms.os() << '<' << from_ascii(t.tag_) << '>';
 239         return ms;
 240 }
 241
 242
 243 MathStream & operator<<(MathStream & ms, ETag const & t)
 244 {
 245         ms.cr();
 246         if (ms.tab() > 0)
 247                 --ms.tab();
 248         ms.os() << "</" << from_ascii(t.tag_) << '>';
 249         return ms;
 250 }
 251
 252
 253 void MathStream::cr()
 254 {
 255         os() << '\n';
 256         for (int i = 0; i < tab(); ++i)
 257                 os() << ' ';
 258 }
 259
 260
 261 MathStream & operator<<(MathStream & ms, docstring const & s)
 262 {
 263         ms.os() << s;
 264         return ms;
 265 }
 266
 267 //////////////////////////////////////////////////////////////////////
 268
 269
 270 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 271 {
 272         at->maple(ms);
 273         return ms;
 274 }
 275
 276
 277 MapleStream & operator<<(MapleStream & ms, MathData const & ar)
 278 {
 279         maple(ar, ms);
 280         return ms;
 281 }
 282
 283
 284 MapleStream & operator<<(MapleStream & ms, char const * s)
 285 {
 286         ms.os() << s;
 287         return ms;
 288 }
 289
 290
 291 MapleStream & operator<<(MapleStream & ms, char c)
 292 {
 293         ms.os() << c;
 294         return ms;
 295 }
 296
 297
 298 MapleStream & operator<<(MapleStream & ms, int i)
 299 {
 300         ms.os() << i;
 301         return ms;
 302 }
 303
 304
 305 MapleStream & operator<<(MapleStream & ms, char_type c)
 306 {
 307         ms.os().put(c);
 308         return ms;
 309 }
 310
 311
 312 MapleStream & operator<<(MapleStream & ms, docstring const & s)
 313 {
 314         ms.os() << s;
 315         return ms;
 316 }
 317
 318
 319 //////////////////////////////////////////////////////////////////////
 320
 321
 322 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 323 {
 324         at->maxima(ms);
 325         return ms;
 326 }
 327
 328
 329 MaximaStream & operator<<(MaximaStream & ms, MathData const & ar)
 330 {
 331         maxima(ar, ms);
 332         return ms;
 333 }
 334
 335
 336 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 337 {
 338         ms.os() << s;
 339         return ms;
 340 }
 341
 342
 343 MaximaStream & operator<<(MaximaStream & ms, char c)
 344 {
 345         ms.os() << c;
 346         return ms;
 347 }
 348
 349
 350 MaximaStream & operator<<(MaximaStream & ms, int i)
 351 {
 352         ms.os() << i;
 353         return ms;
 354 }
 355
 356
 357 MaximaStream & operator<<(MaximaStream & ms, docstring const & s)
 358 {
 359         ms.os() << s;
 360         return ms;
 361 }
 362
 363
 364 MaximaStream & operator<<(MaximaStream & ms, char_type c)
 365 {
 366         ms.os().put(c);
 367         return ms;
 368 }
 369
 370
 371 //////////////////////////////////////////////////////////////////////
 372
 373
 374 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 375 {
 376         at->mathematica(ms);
 377         return ms;
 378 }
 379
 380
 381 MathematicaStream & operator<<(MathematicaStream & ms, MathData const & ar)
 382 {
 383         mathematica(ar, ms);
 384         return ms;
 385 }
 386
 387
 388 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 389 {
 390         ms.os() << s;
 391         return ms;
 392 }
 393
 394
 395 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 396 {
 397         ms.os() << c;
 398         return ms;
 399 }
 400
 401
 402 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 403 {
 404         ms.os() << i;
 405         return ms;
 406 }
 407
 408
 409 MathematicaStream & operator<<(MathematicaStream & ms, docstring const & s)
 410 {
 411         ms.os() << s;
 412         return ms;
 413 }
 414
 415
 416 MathematicaStream & operator<<(MathematicaStream & ms, char_type c)
 417 {
 418         ms.os().put(c);
 419         return ms;
 420 }
 421
 422
 423 //////////////////////////////////////////////////////////////////////
 424
 425
 426 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 427 {
 428         at->octave(ns);
 429         return ns;
 430 }
 431
 432
 433 OctaveStream & operator<<(OctaveStream & ns, MathData const & ar)
 434 {
 435         octave(ar, ns);
 436         return ns;
 437 }
 438
 439
 440 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 441 {
 442         ns.os() << s;
 443         return ns;
 444 }
 445
 446
 447 OctaveStream & operator<<(OctaveStream & ns, char c)
 448 {
 449         ns.os() << c;
 450         return ns;
 451 }
 452
 453
 454 OctaveStream & operator<<(OctaveStream & ns, int i)
 455 {
 456         ns.os() << i;
 457         return ns;
 458 }
 459
 460
 461 OctaveStream & operator<<(OctaveStream & ns, docstring const & s)
 462 {
 463         ns.os() << s;
 464         return ns;
 465 }
 466
 467
 468 OctaveStream & operator<<(OctaveStream & ns, char_type c)
 469 {
 470         ns.os().put(c);
 471         return ns;
 472 }
 473
 474
 475 OctaveStream & operator<<(OctaveStream & os, string const & s)
 476 {
 477         os.os() << from_utf8(s);
 478         return os;
 479 }
 480
 481
 482 } // namespace lyx