src/mathed/math_mathmlstream.C

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