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