src/mathed/math_mathmlstream.C

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