src/mathed/math_mathmlstream.C

   1
   2 #ifdef __GNUG__
   3 #pragma implementation
   4 #endif
   5
   6 #include <config.h>
   7
   8 #include "math_mathmlstream.h"
   9 #include "math_inset.h"
  10 #include "math_extern.h"
  11 #include "debug.h"
  12 #include "support/lyxalgo.h"
  13 #include "support/LOstream.h"
  14
  15
  16 using std::ostream;
  17 using std::strlen;
  18
  19 namespace {
  20
  21         bool isAlpha(char c)
  22         {
  23                 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
  24         }
  25
  26 }
  27
  28 WriteStream::WriteStream(ostream & os, bool fragile, bool latex)
  29         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
  30           pendingspace_(false), line_(0)
  31 {}
  32
  33
  34 WriteStream::WriteStream(ostream & os)
  35         : os_(os), fragile_(false), firstitem_(false), latex_(false),
  36           pendingspace_(false), line_(0)
  37 {}
  38
  39
  40 WriteStream::~WriteStream()
  41 {
  42         if (pendingspace_)
  43                 os_ << ' ';
  44 }
  45
  46
  47 void WriteStream::addlines(unsigned int n)
  48 {
  49         line_ += n;
  50 }
  51
  52
  53 void WriteStream::pendingSpace(bool how)
  54 {
  55         pendingspace_ = how;
  56 }
  57
  58
  59 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
  60 {
  61         at->write(ws);
  62         return ws;
  63 }
  64
  65
  66 WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
  67 {
  68         write(ar, ws);
  69         return ws;
  70 }
  71
  72
  73 WriteStream & operator<<(WriteStream & ws, char const * s)
  74 {
  75         ws.os() << s;
  76         ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
  77         return ws;
  78 }
  79
  80
  81 WriteStream & operator<<(WriteStream & ws, char c)
  82 {
  83         if (ws.pendingSpace()) {
  84                 if (isAlpha(c))
  85                         ws.os() << ' ';
  86                 ws.pendingSpace(false);
  87         }
  88         ws.os() << c;
  89         if (c == '\n')
  90                 ws.addlines(1);
  91         return ws;
  92 }
  93
  94
  95 WriteStream & operator<<(WriteStream & ws, int i)
  96 {
  97         ws.os() << i;
  98         return ws;
  99 }
 100
 101
 102 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 103 {
 104         ws.os() << i;
 105         return ws;
 106 }
 107
 108
 109 //////////////////////////////////////////////////////////////////////
 110
 111
 112 MathMLStream::MathMLStream(ostream & os)
 113         : os_(os), tab_(0), line_(0), lastchar_(0)
 114 {}
 115
 116
 117 MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
 118 {
 119         at->mathmlize(ms);
 120         return ms;
 121 }
 122
 123
 124 MathMLStream & operator<<(MathMLStream & ms, MathArray const & ar)
 125 {
 126         mathmlize(ar, ms);
 127         return ms;
 128 }
 129
 130
 131 MathMLStream & operator<<(MathMLStream & ms, char const * s)
 132 {
 133         ms.os() << s;
 134         return ms;
 135 }
 136
 137
 138 MathMLStream & operator<<(MathMLStream & ms, char c)
 139 {
 140         ms.os() << c;
 141         return ms;
 142 }
 143
 144
 145 MathMLStream & operator<<(MathMLStream & ms, MTag const & t)
 146 {
 147         ++ms.tab();
 148         ms.cr();
 149         ms.os() << '<' << t.tag_ << '>';
 150         return ms;
 151 }
 152
 153
 154 MathMLStream & operator<<(MathMLStream & ms, ETag const & t)
 155 {
 156         ms.cr();
 157         if (ms.tab() > 0)
 158                 --ms.tab();
 159         ms.os() << "</" << t.tag_ << '>';
 160         return ms;
 161 }
 162
 163
 164 void MathMLStream::cr()
 165 {
 166         os() << '\n';
 167         for (int i = 0; i < tab(); ++i)
 168                 os() << ' ';
 169 }
 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 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 215 {
 216         at->mathematicize(ms);
 217         return ms;
 218 }
 219
 220
 221 MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 222 {
 223         mathematicize(ar, ms);
 224         return ms;
 225 }
 226
 227
 228 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 229 {
 230         ms.os() << s;
 231         return ms;
 232 }
 233
 234
 235 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 236 {
 237         ms.os() << c;
 238         return ms;
 239 }
 240
 241
 242 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 243 {
 244         ms.os() << i;
 245         return ms;
 246 }
 247
 248
 249
 250 //////////////////////////////////////////////////////////////////////
 251
 252
 253 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 254 {
 255         at->octavize(ns);
 256         return ns;
 257 }
 258
 259
 260 OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
 261 {
 262         octavize(ar, ns);
 263         return ns;
 264 }
 265
 266
 267 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 268 {
 269         ns.os() << s;
 270         return ns;
 271 }
 272
 273
 274 OctaveStream & operator<<(OctaveStream & ns, char c)
 275 {
 276         ns.os() << c;
 277         return ns;
 278 }
 279
 280
 281 OctaveStream & operator<<(OctaveStream & ns, int i)
 282 {
 283         ns.os() << i;
 284         return ns;
 285 }
 286
 287
 288 //////////////////////////////////////////////////////////////////////
 289
 290
 291 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 292 {
 293         at->normalize(ns);
 294         return ns;
 295 }
 296
 297
 298 NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 299 {
 300         normalize(ar, ns);
 301         return ns;
 302 }
 303
 304
 305 NormalStream & operator<<(NormalStream & ns, char const * s)
 306 {
 307         ns.os() << s;
 308         return ns;
 309 }
 310
 311
 312 NormalStream & operator<<(NormalStream & ns, char c)
 313 {
 314         ns.os() << c;
 315         return ns;
 316 }
 317
 318
 319 NormalStream & operator<<(NormalStream & ns, int i)
 320 {
 321         ns.os() << i;
 322         return ns;
 323 }
 324
 325
 326
 327 //////////////////////////////////////////////////////////////////////
 328