src/common/txtstrm.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        txtstrm.cpp
   3 // Purpose:     Text stream classes
   4 // Author:      Guilhem Lavaux
   5 // Modified by:
   6 // Created:     28/06/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Guilhem Lavaux
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "txtstrm.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20   #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_STREAMS
  24
  25 #include "wx/txtstrm.h"
  26 #include <ctype.h>
  27
  28
  29 // ----------------------------------------------------------------------------
  30 // constants
  31 // ----------------------------------------------------------------------------
  32
  33 // Unix: "\n"
  34 // Dos:  "\r\n"
  35 // Mac:  "\r"
  36
  37 // ----------------------------------------------------------------------------
  38 // wxTextInputStream
  39 // ----------------------------------------------------------------------------
  40
  41 wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep)
  42   : m_input(s), m_separators(sep)
  43 {
  44 }
  45
  46 wxTextInputStream::~wxTextInputStream()
  47 {
  48 }
  49
  50 wxChar wxTextInputStream::NextNonSeparators()
  51 {
  52     wxChar c = (wxChar) 0;
  53     for (;;)
  54     {
  55         if (!m_input) return (wxChar) 0;
  56         c = m_input.GetC();
  57
  58         if (c != wxT('\n') &&
  59             c != wxT('\r') &&
  60             !m_separators.Contains(c))
  61           return c;
  62     }
  63
  64 }
  65
  66 inline bool wxTextInputStream::EatEOL(const wxChar &c)
  67 {
  68   if (c == wxT('\n')) return TRUE; // eat on UNIX
  69
  70   if (c == wxT('\r')) // eat on both Mac and DOS
  71     {
  72       if (!m_input) return TRUE;
  73       wxChar c2 = m_input.GetC();
  74
  75       if (c2 != wxT('\n'))  m_input.Ungetch( c2 ); // Don't eat on Mac
  76       return TRUE;
  77     }
  78
  79   return FALSE;
  80 }
  81
  82 void wxTextInputStream::SkipIfEndOfLine( wxChar c )
  83 {
  84     if (EatEOL(c)) return;
  85     else m_input.Ungetch( c );  // no line terminator
  86 }
  87
  88 wxUint32 wxTextInputStream::Read32()
  89 {
  90     /* I only implemented a simple integer parser */
  91     int sign;
  92     wxInt32 i;
  93
  94     if (!m_input) return 0;
  95     int c = NextNonSeparators();
  96     if (c==(wxChar)0) return 0;
  97
  98     i = 0;
  99     if (! (c == wxT('-') || c == wxT('+') || isdigit(c)) )
 100     {
 101         m_input.Ungetch(c);
 102         return 0;
 103     }
 104
 105     if (c == wxT('-'))
 106     {
 107         sign = -1;
 108         c = m_input.GetC();
 109     } else
 110     if (c == wxT('+'))
 111     {
 112         sign = 1;
 113         c = m_input.GetC();
 114     } else
 115     {
 116         sign = 1;
 117     }
 118
 119     while (isdigit(c))
 120     {
 121         i = i*10 + (c - (int)wxT('0'));
 122         c = m_input.GetC();
 123     }
 124
 125     SkipIfEndOfLine( c );
 126
 127     i *= sign;
 128
 129     return (wxUint32)i;
 130 }
 131
 132 wxUint16 wxTextInputStream::Read16()
 133 {
 134     return (wxUint16)Read32();
 135 }
 136
 137 wxUint8 wxTextInputStream::Read8()
 138 {
 139     return (wxUint8)Read32();
 140 }
 141
 142 double wxTextInputStream::ReadDouble()
 143 {
 144     /* I only implemented a simple float parser */
 145     double f;
 146     int sign;
 147
 148     if (!m_input) return 0;
 149     int c = NextNonSeparators();
 150     if (c==(wxChar)0) return 0;
 151
 152     f = 0.0;
 153     if (! (c == wxT('.') || c == wxT('-') || c == wxT('+') || isdigit(c)) )
 154     {
 155         m_input.Ungetch(c);
 156         return 0.0;
 157     }
 158
 159     if (c == wxT('-'))
 160     {
 161         sign = -1;
 162         c = m_input.GetC();
 163     } else
 164     if (c == wxT('+'))
 165     {
 166         sign = 1;
 167         c = m_input.GetC();
 168     }
 169     else
 170     {
 171         sign = 1;
 172     }
 173
 174     while (isdigit(c))
 175     {
 176         f = f*10 + (c - wxT('0'));
 177         c = m_input.GetC();
 178     }
 179
 180     if (c == wxT('.'))
 181     {
 182         double f_multiplicator = (double) 0.1;
 183
 184         c = m_input.GetC();
 185
 186         while (isdigit(c))
 187         {
 188             f += (c-wxT('0'))*f_multiplicator;
 189             f_multiplicator /= 10;
 190             c = m_input.GetC();
 191         }
 192
 193         if (c == wxT('e'))
 194         {
 195             double f_multiplicator = 0.0;
 196             int i, e;
 197
 198             c = m_input.GetC();
 199
 200             switch (c)
 201             {
 202                 case wxT('-'): f_multiplicator = 0.1;  break;
 203                 case wxT('+'): f_multiplicator = 10.0; break;
 204             }
 205
 206             e = Read8();  // why only max 256 ?
 207
 208             for (i=0;i<e;i++)
 209                 f *= f_multiplicator;
 210         }
 211         else
 212             SkipIfEndOfLine( c );
 213     }
 214     else
 215     {
 216         m_input.Ungetch(c);
 217     }
 218
 219     f *= sign;
 220
 221     return f;
 222 }
 223
 224 wxString wxTextInputStream::ReadString()
 225 {
 226   return ReadLine();
 227 }
 228
 229 wxString wxTextInputStream::ReadLine()
 230 {
 231     wxChar c;
 232     wxString line;
 233
 234     for (;;)
 235     {
 236         if (!m_input) break;
 237         c = m_input.GetC();
 238
 239         if (EatEOL(c)) break;
 240
 241         line += c;
 242     }
 243
 244     return line;
 245 }
 246
 247 wxString wxTextInputStream::ReadWord()
 248 {
 249     if (!m_input) return "";
 250
 251     wxString word;
 252     wxChar c=NextNonSeparators();
 253     if (c==(wxChar)0) return "";
 254
 255     for (;;)
 256     {
 257         if (m_separators.Contains(c)) break;
 258
 259         if (EatEOL(c)) break;
 260
 261         word += c;
 262
 263         if (!m_input) break;
 264         c = m_input.GetC();
 265     }
 266
 267     return word;
 268 }
 269
 270 wxTextInputStream& wxTextInputStream::operator>>(wxString& word)
 271 {
 272   word = ReadWord();
 273   return *this;
 274 }
 275
 276 wxTextInputStream& wxTextInputStream::operator>>(wxChar& c)
 277 {
 278     if (!m_input)
 279     {
 280         c = (wxChar) 0;
 281         return *this;
 282     }
 283
 284     c = m_input.GetC();
 285
 286     if (EatEOL(c)) c=wxT('\n');
 287     return *this;
 288 }
 289
 290 wxTextInputStream& wxTextInputStream::operator>>(wxInt16& i)
 291 {
 292     i = (wxInt16)Read16();
 293     return *this;
 294 }
 295
 296 wxTextInputStream& wxTextInputStream::operator>>(wxInt32& i)
 297 {
 298     i = (wxInt32)Read32();
 299     return *this;
 300 }
 301
 302 wxTextInputStream& wxTextInputStream::operator>>(wxUint16& i)
 303 {
 304     i = Read16();
 305     return *this;
 306 }
 307
 308 wxTextInputStream& wxTextInputStream::operator>>(wxUint32& i)
 309 {
 310     i = Read32();
 311     return *this;
 312 }
 313
 314 wxTextInputStream& wxTextInputStream::operator>>(double& i)
 315 {
 316     i = ReadDouble();
 317     return *this;
 318 }
 319
 320 wxTextInputStream& wxTextInputStream::operator>>(float& f)
 321 {
 322     f = (float)ReadDouble();
 323     return *this;
 324 }
 325
 326 wxTextOutputStream::wxTextOutputStream(wxOutputStream& s)
 327   : m_output(s)
 328 {
 329 }
 330
 331 wxTextOutputStream::~wxTextOutputStream()
 332 {
 333 }
 334
 335 void wxTextOutputStream::Write32(wxUint32 i)
 336 {
 337     wxString str;
 338     str.Printf(wxT("%u"), i);
 339
 340     WriteString(str);
 341 }
 342
 343 void wxTextOutputStream::Write16(wxUint16 i)
 344 {
 345     wxString str;
 346     str.Printf(wxT("%u"), i);
 347
 348     WriteString(str);
 349 }
 350
 351 void wxTextOutputStream::Write8(wxUint8 i)
 352 {
 353     wxString str;
 354     str.Printf(wxT("%u"), i);
 355
 356     WriteString(str);
 357 }
 358
 359 void wxTextOutputStream::WriteDouble(double d)
 360 {
 361     wxString str;
 362
 363     str.Printf(wxT("%f"), d);
 364     WriteString(str);
 365 }
 366
 367 void wxTextOutputStream::WriteString(const wxString& string)
 368 {
 369     for (size_t i = 0; i < string.Len(); i++)
 370     {
 371         wxChar c = string[i];
 372         if (c == wxT('\n'))
 373         {
 374 #if   defined(__WINDOWS__)
 375             c = wxT('\r');
 376             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 377             c = wxT('\n');
 378             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 379 #elif defined(__UNIX__)
 380             c = wxT('\n');
 381             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 382 #elif defined(__WXMAC__)
 383             c = wxT('\r');
 384             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 385 #elif   defined(__OS2__)
 386             c = wxT('\r');
 387             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 388             c = wxT('\n');
 389             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 390 #else
 391             #error  "wxTextOutputStream: unsupported platform."
 392 #endif
 393         }
 394         else
 395         {
 396             m_output.Write( (const void*)(&c), sizeof(wxChar) );
 397         }
 398    }
 399 }
 400
 401 wxTextOutputStream& wxTextOutputStream::operator<<(const wxChar *string)
 402 {
 403     WriteString( wxString(string) );
 404     return *this;
 405 }
 406
 407 wxTextOutputStream& wxTextOutputStream::operator<<(const wxString& string)
 408 {
 409     WriteString( string );
 410     return *this;
 411 }
 412
 413 wxTextOutputStream& wxTextOutputStream::operator<<(wxChar c)
 414 {
 415     WriteString( wxString(c) );
 416     return *this;
 417 }
 418
 419 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt16 c)
 420 {
 421     Write16( (wxUint16)c );
 422     return *this;
 423 }
 424
 425 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt32 c)
 426 {
 427     Write32( (wxUint32)c );
 428     return *this;
 429 }
 430
 431 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint16 c)
 432 {
 433     Write16(c);
 434     return *this;
 435 }
 436
 437 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint32 c)
 438 {
 439     Write32(c);
 440     return *this;
 441 }
 442
 443 wxTextOutputStream &wxTextOutputStream::operator<<(double f)
 444 {
 445     WriteDouble(f);
 446     return *this;
 447 }
 448
 449 wxTextOutputStream& wxTextOutputStream::operator<<(float f)
 450 {
 451     WriteDouble((double)f);
 452     return *this;
 453 }
 454
 455 wxTextOutputStream &endl( wxTextOutputStream &stream )
 456 {
 457     return stream << wxT('\n');
 458 }
 459
 460 #endif
 461   // wxUSE_STREAMS