src/mathed/math_mathmlstream.C

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