src/mathed/MathStream.C

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