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