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