src/mathed/math_mathmlstream.C

   1
   2 #include <config.h>
   3
   4 #include "math_mathmlstream.h"
   5 #include "math_inset.h"
   6 #include "math_extern.h"
   7 #include "debug.h"
   8 #include "support/lyxalgo.h"
   9 #include "support/LOstream.h"
  10
  11
  12 using std::ostream;
  13 using std::strlen;
  14
  15 namespace {
  16
  17         bool isAlpha(char c)
  18         {
  19                 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
  20         }
  21
  22 }
  23
  24 WriteStream::WriteStream(ostream & os, bool fragile, bool latex)
  25         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
  26           pendingspace_(false), line_(0)
  27 {}
  28
  29
  30 WriteStream::WriteStream(ostream & os)
  31         : os_(os), fragile_(false), firstitem_(false), latex_(false),
  32           pendingspace_(false), line_(0)
  33 {}
  34
  35
  36 WriteStream::~WriteStream()
  37 {
  38         if (pendingspace_)
  39                 os_ << ' ';
  40 }
  41
  42
  43 void WriteStream::addlines(unsigned int n)
  44 {
  45         line_ += n;
  46 }
  47
  48
  49 void WriteStream::pendingSpace(bool how)
  50 {
  51         pendingspace_ = how;
  52 }
  53
  54
  55 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
  56 {
  57         at->write(ws);
  58         return ws;
  59 }
  60
  61
  62 WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
  63 {
  64         write(ar, ws);
  65         return ws;
  66 }
  67
  68
  69 WriteStream & operator<<(WriteStream & ws, char const * s)
  70 {
  71         if (ws.pendingSpace() && strlen(s) > 0) {
  72                 if (isAlpha(s[0]))
  73                         ws.os() << ' ';
  74                 ws.pendingSpace(false);
  75         }
  76         ws.os() << s;
  77         ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
  78         return ws;
  79 }
  80
  81
  82 WriteStream & operator<<(WriteStream & ws, char c)
  83 {
  84         if (ws.pendingSpace()) {
  85                 if (isAlpha(c))
  86                         ws.os() << ' ';
  87                 ws.pendingSpace(false);
  88         }
  89         ws.os() << c;
  90         if (c == '\n')
  91                 ws.addlines(1);
  92         return ws;
  93 }
  94
  95
  96 WriteStream & operator<<(WriteStream & ws, int i)
  97 {
  98         ws.os() << i;
  99         return ws;
 100 }
 101
 102
 103 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 104 {
 105         ws.os() << i;
 106         return ws;
 107 }
 108
 109
 110 //////////////////////////////////////////////////////////////////////
 111
 112
 113 MathMLStream::MathMLStream(ostream & os)
 114         : os_(os), tab_(0), line_(0), lastchar_(0)
 115 {}
 116
 117
 118 MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
 119 {
 120         at->mathmlize(ms);
 121         return ms;
 122 }
 123
 124
 125 MathMLStream & operator<<(MathMLStream & ms, MathArray const & ar)
 126 {
 127         mathmlize(ar, ms);
 128         return ms;
 129 }
 130
 131
 132 MathMLStream & operator<<(MathMLStream & ms, char const * s)
 133 {
 134         ms.os() << s;
 135         return ms;
 136 }
 137
 138
 139 MathMLStream & operator<<(MathMLStream & ms, char c)
 140 {
 141         ms.os() << c;
 142         return ms;
 143 }
 144
 145
 146 MathMLStream & operator<<(MathMLStream & ms, MTag const & t)
 147 {
 148         ++ms.tab();
 149         ms.cr();
 150         ms.os() << '<' << t.tag_ << '>';
 151         return ms;
 152 }
 153
 154
 155 MathMLStream & operator<<(MathMLStream & ms, ETag const & t)
 156 {
 157         ms.cr();
 158         if (ms.tab() > 0)
 159                 --ms.tab();
 160         ms.os() << "</" << t.tag_ << '>';
 161         return ms;
 162 }
 163
 164
 165 void MathMLStream::cr()
 166 {
 167         os() << '\n';
 168         for (int i = 0; i < tab(); ++i)
 169                 os() << ' ';
 170 }
 171
 172
 173 //////////////////////////////////////////////////////////////////////
 174
 175
 176 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 177 {
 178         at->maplize(ms);
 179         return ms;
 180 }
 181
 182
 183 MapleStream & operator<<(MapleStream & ms, MathArray const & ar)
 184 {
 185         maplize(ar, ms);
 186         return ms;
 187 }
 188
 189
 190 MapleStream & operator<<(MapleStream & ms, char const * s)
 191 {
 192         ms.os() << s;
 193         return ms;
 194 }
 195
 196
 197 MapleStream & operator<<(MapleStream & ms, char c)
 198 {
 199         ms.os() << c;
 200         return ms;
 201 }
 202
 203
 204 MapleStream & operator<<(MapleStream & ms, int i)
 205 {
 206         ms.os() << i;
 207         return ms;
 208 }
 209
 210
 211 //////////////////////////////////////////////////////////////////////
 212
 213
 214 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 215 {
 216         at->maximize(ms);
 217         return ms;
 218 }
 219
 220
 221 MaximaStream & operator<<(MaximaStream & ms, MathArray const & ar)
 222 {
 223         maximize(ar, ms);
 224         return ms;
 225 }
 226
 227
 228 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 229 {
 230         ms.os() << s;
 231         return ms;
 232 }
 233
 234
 235 MaximaStream & operator<<(MaximaStream & ms, char c)
 236 {
 237         ms.os() << c;
 238         return ms;
 239 }
 240
 241
 242 MaximaStream & operator<<(MaximaStream & ms, int i)
 243 {
 244         ms.os() << i;
 245         return ms;
 246 }
 247
 248
 249 //////////////////////////////////////////////////////////////////////
 250
 251
 252 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 253 {
 254         at->mathematicize(ms);
 255         return ms;
 256 }
 257
 258
 259 MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 260 {
 261         mathematicize(ar, ms);
 262         return ms;
 263 }
 264
 265
 266 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 267 {
 268         ms.os() << s;
 269         return ms;
 270 }
 271
 272
 273 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 274 {
 275         ms.os() << c;
 276         return ms;
 277 }
 278
 279
 280 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 281 {
 282         ms.os() << i;
 283         return ms;
 284 }
 285
 286
 287
 288 //////////////////////////////////////////////////////////////////////
 289
 290
 291 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 292 {
 293         at->octavize(ns);
 294         return ns;
 295 }
 296
 297
 298 OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
 299 {
 300         octavize(ar, ns);
 301         return ns;
 302 }
 303
 304
 305 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 306 {
 307         ns.os() << s;
 308         return ns;
 309 }
 310
 311
 312 OctaveStream & operator<<(OctaveStream & ns, char c)
 313 {
 314         ns.os() << c;
 315         return ns;
 316 }
 317
 318
 319 OctaveStream & operator<<(OctaveStream & ns, int i)
 320 {
 321         ns.os() << i;
 322         return ns;
 323 }
 324
 325
 326 //////////////////////////////////////////////////////////////////////
 327
 328
 329 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 330 {
 331         at->normalize(ns);
 332         return ns;
 333 }
 334
 335
 336 NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 337 {
 338         normalize(ar, ns);
 339         return ns;
 340 }
 341
 342
 343 NormalStream & operator<<(NormalStream & ns, char const * s)
 344 {
 345         ns.os() << s;
 346         return ns;
 347 }
 348
 349
 350 NormalStream & operator<<(NormalStream & ns, char c)
 351 {
 352         ns.os() << c;
 353         return ns;
 354 }
 355
 356
 357 NormalStream & operator<<(NormalStream & ns, int i)
 358 {
 359         ns.os() << i;
 360         return ns;
 361 }
 362
 363
 364
 365 //////////////////////////////////////////////////////////////////////