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         if (ws.pendingSpace() && strlen(s) > 0) {
  76                 if (isAlpha(s[0]))
  77                         ws.os() << ' ';
  78                 ws.pendingSpace(false);
  79         }
  80         ws.os() << s;
  81         ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
  82         return ws;
  83 }
  84
  85
  86 WriteStream & operator<<(WriteStream & ws, char c)
  87 {
  88         if (ws.pendingSpace()) {
  89                 if (isAlpha(c))
  90                         ws.os() << ' ';
  91                 ws.pendingSpace(false);
  92         }
  93         ws.os() << c;
  94         if (c == '\n')
  95                 ws.addlines(1);
  96         return ws;
  97 }
  98
  99
 100 WriteStream & operator<<(WriteStream & ws, int i)
 101 {
 102         ws.os() << i;
 103         return ws;
 104 }
 105
 106
 107 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 108 {
 109         ws.os() << i;
 110         return ws;
 111 }
 112
 113
 114 //////////////////////////////////////////////////////////////////////
 115
 116
 117 MathMLStream::MathMLStream(ostream & os)
 118         : os_(os), tab_(0), line_(0), lastchar_(0)
 119 {}
 120
 121
 122 MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
 123 {
 124         at->mathmlize(ms);
 125         return ms;
 126 }
 127
 128
 129 MathMLStream & operator<<(MathMLStream & ms, MathArray const & ar)
 130 {
 131         mathmlize(ar, ms);
 132         return ms;
 133 }
 134
 135
 136 MathMLStream & operator<<(MathMLStream & ms, char const * s)
 137 {
 138         ms.os() << s;
 139         return ms;
 140 }
 141
 142
 143 MathMLStream & operator<<(MathMLStream & ms, char c)
 144 {
 145         ms.os() << c;
 146         return ms;
 147 }
 148
 149
 150 MathMLStream & operator<<(MathMLStream & ms, MTag const & t)
 151 {
 152         ++ms.tab();
 153         ms.cr();
 154         ms.os() << '<' << t.tag_ << '>';
 155         return ms;
 156 }
 157
 158
 159 MathMLStream & operator<<(MathMLStream & ms, ETag const & t)
 160 {
 161         ms.cr();
 162         if (ms.tab() > 0)
 163                 --ms.tab();
 164         ms.os() << "</" << t.tag_ << '>';
 165         return ms;
 166 }
 167
 168
 169 void MathMLStream::cr()
 170 {
 171         os() << '\n';
 172         for (int i = 0; i < tab(); ++i)
 173                 os() << ' ';
 174 }
 175
 176
 177 //////////////////////////////////////////////////////////////////////
 178
 179
 180 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 181 {
 182         at->maplize(ms);
 183         return ms;
 184 }
 185
 186
 187 MapleStream & operator<<(MapleStream & ms, MathArray const & ar)
 188 {
 189         maplize(ar, ms);
 190         return ms;
 191 }
 192
 193
 194 MapleStream & operator<<(MapleStream & ms, char const * s)
 195 {
 196         ms.os() << s;
 197         return ms;
 198 }
 199
 200
 201 MapleStream & operator<<(MapleStream & ms, char c)
 202 {
 203         ms.os() << c;
 204         return ms;
 205 }
 206
 207
 208 MapleStream & operator<<(MapleStream & ms, int i)
 209 {
 210         ms.os() << i;
 211         return ms;
 212 }
 213
 214
 215 //////////////////////////////////////////////////////////////////////
 216
 217
 218 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 219 {
 220         at->maximize(ms);
 221         return ms;
 222 }
 223
 224
 225 MaximaStream & operator<<(MaximaStream & ms, MathArray const & ar)
 226 {
 227         maximize(ar, ms);
 228         return ms;
 229 }
 230
 231
 232 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 233 {
 234         ms.os() << s;
 235         return ms;
 236 }
 237
 238
 239 MaximaStream & operator<<(MaximaStream & ms, char c)
 240 {
 241         ms.os() << c;
 242         return ms;
 243 }
 244
 245
 246 MaximaStream & operator<<(MaximaStream & ms, int i)
 247 {
 248         ms.os() << i;
 249         return ms;
 250 }
 251
 252
 253 //////////////////////////////////////////////////////////////////////
 254
 255
 256 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 257 {
 258         at->mathematicize(ms);
 259         return ms;
 260 }
 261
 262
 263 MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 264 {
 265         mathematicize(ar, ms);
 266         return ms;
 267 }
 268
 269
 270 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 271 {
 272         ms.os() << s;
 273         return ms;
 274 }
 275
 276
 277 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 278 {
 279         ms.os() << c;
 280         return ms;
 281 }
 282
 283
 284 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 285 {
 286         ms.os() << i;
 287         return ms;
 288 }
 289
 290
 291
 292 //////////////////////////////////////////////////////////////////////
 293
 294
 295 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 296 {
 297         at->octavize(ns);
 298         return ns;
 299 }
 300
 301
 302 OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
 303 {
 304         octavize(ar, ns);
 305         return ns;
 306 }
 307
 308
 309 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 310 {
 311         ns.os() << s;
 312         return ns;
 313 }
 314
 315
 316 OctaveStream & operator<<(OctaveStream & ns, char c)
 317 {
 318         ns.os() << c;
 319         return ns;
 320 }
 321
 322
 323 OctaveStream & operator<<(OctaveStream & ns, int i)
 324 {
 325         ns.os() << i;
 326         return ns;
 327 }
 328
 329
 330 //////////////////////////////////////////////////////////////////////
 331
 332
 333 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 334 {
 335         at->normalize(ns);
 336         return ns;
 337 }
 338
 339
 340 NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 341 {
 342         normalize(ar, ns);
 343         return ns;
 344 }
 345
 346
 347 NormalStream & operator<<(NormalStream & ns, char const * s)
 348 {
 349         ns.os() << s;
 350         return ns;
 351 }
 352
 353
 354 NormalStream & operator<<(NormalStream & ns, char c)
 355 {
 356         ns.os() << c;
 357         return ns;
 358 }
 359
 360
 361 NormalStream & operator<<(NormalStream & ns, int i)
 362 {
 363         ns.os() << i;
 364         return ns;
 365 }
 366
 367
 368
 369 //////////////////////////////////////////////////////////////////////
 370