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