src/common/txtstrm.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/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 licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16   #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_STREAMS
  20
  21 #include "wx/txtstrm.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/crt.h"
  25 #endif
  26
  27 #include <ctype.h>
  28
  29 // ----------------------------------------------------------------------------
  30 // wxTextInputStream
  31 // ----------------------------------------------------------------------------
  32
  33 #if wxUSE_UNICODE
  34 wxTextInputStream::wxTextInputStream(wxInputStream &s,
  35                                      const wxString &sep,
  36                                      const wxMBConv& conv)
  37   : m_input(s), m_separators(sep), m_conv(conv.Clone())
  38 {
  39     memset((void*)m_lastBytes, 0, 10);
  40 }
  41 #else
  42 wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep)
  43   : m_input(s), m_separators(sep)
  44 {
  45     memset((void*)m_lastBytes, 0, 10);
  46 }
  47 #endif
  48
  49 wxTextInputStream::~wxTextInputStream()
  50 {
  51 #if wxUSE_UNICODE
  52     delete m_conv;
  53 #endif // wxUSE_UNICODE
  54 }
  55
  56 void wxTextInputStream::UngetLast()
  57 {
  58     size_t byteCount = 0;
  59     while(m_lastBytes[byteCount]) // pseudo ANSI strlen (even for Unicode!)
  60         byteCount++;
  61     m_input.Ungetch(m_lastBytes, byteCount);
  62     memset((void*)m_lastBytes, 0, 10);
  63 }
  64
  65 wxChar wxTextInputStream::NextChar()
  66 {
  67 #if wxUSE_UNICODE
  68     wxChar wbuf[2];
  69     memset((void*)m_lastBytes, 0, 10);
  70     for(size_t inlen = 0; inlen < 9; inlen++)
  71     {
  72         // actually read the next character
  73         m_lastBytes[inlen] = m_input.GetC();
  74
  75         if(m_input.LastRead() <= 0)
  76             return wxEOT;
  77
  78         switch ( m_conv->ToWChar(wbuf, WXSIZEOF(wbuf), m_lastBytes, inlen + 1) )
  79         {
  80             case 0:
  81                 // this is a bug in converter object as it should either fail
  82                 // or decode non-empty string to something non-empty
  83                 wxFAIL_MSG("ToWChar() can't return 0 for non-empty input");
  84                 break;
  85
  86             case wxCONV_FAILED:
  87                 // the buffer probably doesn't contain enough bytes to decode
  88                 // as a complete character, try with more bytes
  89                 break;
  90
  91             default:
  92                 // if we couldn't decode a single character during the last
  93                 // loop iteration we shouldn't be able to decode 2 or more of
  94                 // them with an extra single byte, something fishy is going on
  95                 wxFAIL_MSG("unexpected decoding result");
  96                 // fall through nevertheless and return at least something
  97
  98             case 1:
  99                 // we finally decoded a character
 100                 return wbuf[0];
 101         }
 102     }
 103
 104     // there should be no encoding which requires more than nine bytes for one
 105     // character so something must be wrong with our conversion but we have no
 106     // way to signal it from here
 107     return wxEOT;
 108 #else
 109     m_lastBytes[0] = m_input.GetC();
 110
 111     if(m_input.LastRead() <= 0)
 112         return wxEOT;
 113
 114     return m_lastBytes[0];
 115 #endif
 116
 117 }
 118
 119 wxChar wxTextInputStream::NextNonSeparators()
 120 {
 121     for (;;)
 122     {
 123         wxChar c = NextChar();
 124         if (c == wxEOT) return (wxChar) 0;
 125
 126         if (c != wxT('\n') &&
 127             c != wxT('\r') &&
 128             m_separators.Find(c) < 0)
 129           return c;
 130     }
 131
 132 }
 133
 134 bool wxTextInputStream::EatEOL(const wxChar &c)
 135 {
 136     if (c == wxT('\n')) return true; // eat on UNIX
 137
 138     if (c == wxT('\r')) // eat on both Mac and DOS
 139     {
 140         wxChar c2 = NextChar();
 141         if(c2 == wxEOT) return true; // end of stream reached, had enough :-)
 142
 143         if (c2 != wxT('\n')) UngetLast(); // Don't eat on Mac
 144         return true;
 145     }
 146
 147     return false;
 148 }
 149
 150 wxUint32 wxTextInputStream::Read32(int base)
 151 {
 152     wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
 153     if(!m_input) return 0;
 154
 155     wxString word = ReadWord();
 156     if(word.empty())
 157         return 0;
 158     return wxStrtoul(word.c_str(), 0, base);
 159 }
 160
 161 wxUint16 wxTextInputStream::Read16(int base)
 162 {
 163     return (wxUint16)Read32(base);
 164 }
 165
 166 wxUint8 wxTextInputStream::Read8(int base)
 167 {
 168     return (wxUint8)Read32(base);
 169 }
 170
 171 wxInt32 wxTextInputStream::Read32S(int base)
 172 {
 173     wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
 174     if(!m_input) return 0;
 175
 176     wxString word = ReadWord();
 177     if(word.empty())
 178         return 0;
 179     return wxStrtol(word.c_str(), 0, base);
 180 }
 181
 182 wxInt16 wxTextInputStream::Read16S(int base)
 183 {
 184     return (wxInt16)Read32S(base);
 185 }
 186
 187 wxInt8 wxTextInputStream::Read8S(int base)
 188 {
 189     return (wxInt8)Read32S(base);
 190 }
 191
 192 double wxTextInputStream::ReadDouble()
 193 {
 194     if(!m_input) return 0;
 195     wxString word = ReadWord();
 196     if(word.empty())
 197         return 0;
 198     return wxStrtod(word.c_str(), 0);
 199 }
 200
 201 #if WXWIN_COMPATIBILITY_2_6
 202
 203 wxString wxTextInputStream::ReadString()
 204 {
 205     return ReadLine();
 206 }
 207
 208 #endif // WXWIN_COMPATIBILITY_2_6
 209
 210 wxString wxTextInputStream::ReadLine()
 211 {
 212     wxString line;
 213
 214     while ( !m_input.Eof() )
 215     {
 216         wxChar c = NextChar();
 217         if(c == wxEOT)
 218             break;
 219
 220         if (EatEOL(c))
 221             break;
 222
 223         line += c;
 224     }
 225
 226     return line;
 227 }
 228
 229 wxString wxTextInputStream::ReadWord()
 230 {
 231     wxString word;
 232
 233     if ( !m_input )
 234         return word;
 235
 236     wxChar c = NextNonSeparators();
 237     if ( !c )
 238         return word;
 239
 240     word += c;
 241
 242     while ( !m_input.Eof() )
 243     {
 244         c = NextChar();
 245         if(c == wxEOT)
 246             break;
 247
 248         if (m_separators.Find(c) >= 0)
 249             break;
 250
 251         if (EatEOL(c))
 252             break;
 253
 254         word += c;
 255     }
 256
 257     return word;
 258 }
 259
 260 wxTextInputStream& wxTextInputStream::operator>>(wxString& word)
 261 {
 262     word = ReadWord();
 263     return *this;
 264 }
 265
 266 wxTextInputStream& wxTextInputStream::operator>>(char& c)
 267 {
 268     c = m_input.GetC();
 269     if(m_input.LastRead() <= 0) c = 0;
 270
 271     if (EatEOL(c))
 272         c = '\n';
 273
 274     return *this;
 275 }
 276
 277 #if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE
 278
 279 wxTextInputStream& wxTextInputStream::operator>>(wchar_t& wc)
 280 {
 281     wc = GetChar();
 282
 283     return *this;
 284 }
 285
 286 #endif // wxUSE_UNICODE
 287
 288 wxTextInputStream& wxTextInputStream::operator>>(wxInt16& i)
 289 {
 290     i = (wxInt16)Read16();
 291     return *this;
 292 }
 293
 294 wxTextInputStream& wxTextInputStream::operator>>(wxInt32& i)
 295 {
 296     i = (wxInt32)Read32();
 297     return *this;
 298 }
 299
 300 wxTextInputStream& wxTextInputStream::operator>>(wxUint16& i)
 301 {
 302     i = Read16();
 303     return *this;
 304 }
 305
 306 wxTextInputStream& wxTextInputStream::operator>>(wxUint32& i)
 307 {
 308     i = Read32();
 309     return *this;
 310 }
 311
 312 wxTextInputStream& wxTextInputStream::operator>>(double& i)
 313 {
 314     i = ReadDouble();
 315     return *this;
 316 }
 317
 318 wxTextInputStream& wxTextInputStream::operator>>(float& f)
 319 {
 320     f = (float)ReadDouble();
 321     return *this;
 322 }
 323
 324
 325
 326 #if wxUSE_UNICODE
 327 wxTextOutputStream::wxTextOutputStream(wxOutputStream& s,
 328                                        wxEOL mode,
 329                                        const wxMBConv& conv)
 330   : m_output(s), m_conv(conv.Clone())
 331 #else
 332 wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode)
 333   : m_output(s)
 334 #endif
 335 {
 336     m_mode = mode;
 337     if (m_mode == wxEOL_NATIVE)
 338     {
 339 #if defined(__WXMSW__) || defined(__WXPM__)
 340         m_mode = wxEOL_DOS;
 341 #else
 342         m_mode = wxEOL_UNIX;
 343 #endif
 344     }
 345 }
 346
 347 wxTextOutputStream::~wxTextOutputStream()
 348 {
 349 #if wxUSE_UNICODE
 350     delete m_conv;
 351 #endif // wxUSE_UNICODE
 352 }
 353
 354 void wxTextOutputStream::SetMode(wxEOL mode)
 355 {
 356     m_mode = mode;
 357     if (m_mode == wxEOL_NATIVE)
 358     {
 359 #if defined(__WXMSW__) || defined(__WXPM__)
 360         m_mode = wxEOL_DOS;
 361 #else
 362         m_mode = wxEOL_UNIX;
 363 #endif
 364     }
 365 }
 366
 367 void wxTextOutputStream::Write32(wxUint32 i)
 368 {
 369     wxString str;
 370     str.Printf(wxT("%u"), i);
 371
 372     WriteString(str);
 373 }
 374
 375 void wxTextOutputStream::Write16(wxUint16 i)
 376 {
 377     wxString str;
 378     str.Printf(wxT("%u"), (unsigned)i);
 379
 380     WriteString(str);
 381 }
 382
 383 void wxTextOutputStream::Write8(wxUint8 i)
 384 {
 385     wxString str;
 386     str.Printf(wxT("%u"), (unsigned)i);
 387
 388     WriteString(str);
 389 }
 390
 391 void wxTextOutputStream::WriteDouble(double d)
 392 {
 393     wxString str;
 394
 395     str.Printf(wxT("%f"), d);
 396     WriteString(str);
 397 }
 398
 399 void wxTextOutputStream::WriteString(const wxString& string)
 400 {
 401     size_t len = string.length();
 402
 403     wxString out;
 404     out.reserve(len);
 405
 406     for ( size_t i = 0; i < len; i++ )
 407     {
 408         const wxChar c = string[i];
 409         if ( c == wxT('\n') )
 410         {
 411             switch ( m_mode )
 412             {
 413                 case wxEOL_DOS:
 414                     out << wxT("\r\n");
 415                     continue;
 416
 417                 case wxEOL_MAC:
 418                     out << wxT('\r');
 419                     continue;
 420
 421                 default:
 422                     wxFAIL_MSG( wxT("unknown EOL mode in wxTextOutputStream") );
 423                     // fall through
 424
 425                 case wxEOL_UNIX:
 426                     // don't treat '\n' specially
 427                     ;
 428             }
 429         }
 430
 431         out << c;
 432     }
 433
 434 #if wxUSE_UNICODE
 435     // FIXME-UTF8: use wxCharBufferWithLength if/when we have it
 436     wxCharBuffer buffer = m_conv->cWC2MB(out.wc_str(), out.length(), &len);
 437     m_output.Write(buffer, len);
 438 #else
 439     m_output.Write(out.c_str(), out.length() );
 440 #endif
 441 }
 442
 443 wxTextOutputStream& wxTextOutputStream::PutChar(wxChar c)
 444 {
 445 #if wxUSE_UNICODE
 446     WriteString( wxString(&c, *m_conv, 1) );
 447 #else
 448     WriteString( wxString(&c, wxConvLocal, 1) );
 449 #endif
 450     return *this;
 451 }
 452
 453 void wxTextOutputStream::Flush()
 454 {
 455 #if wxUSE_UNICODE
 456     const size_t len = m_conv->FromWChar(NULL, 0, L"", 1);
 457     if ( len > m_conv->GetMBNulLen() )
 458     {
 459         wxCharBuffer buf(len);
 460         m_conv->FromWChar(buf.data(), len, L"", 1);
 461         m_output.Write(buf, len - m_conv->GetMBNulLen());
 462     }
 463 #endif // wxUSE_UNICODE
 464 }
 465
 466 wxTextOutputStream& wxTextOutputStream::operator<<(const wxString& string)
 467 {
 468     WriteString( string );
 469     return *this;
 470 }
 471
 472 wxTextOutputStream& wxTextOutputStream::operator<<(char c)
 473 {
 474     WriteString( wxString::FromAscii(c) );
 475
 476     return *this;
 477 }
 478
 479 #if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE
 480
 481 wxTextOutputStream& wxTextOutputStream::operator<<(wchar_t wc)
 482 {
 483     WriteString( wxString(&wc, *m_conv, 1) );
 484
 485     return *this;
 486 }
 487
 488 #endif // wxUSE_UNICODE
 489
 490 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt16 c)
 491 {
 492     wxString str;
 493     str.Printf(wxT("%d"), (signed int)c);
 494     WriteString(str);
 495
 496     return *this;
 497 }
 498
 499 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt32 c)
 500 {
 501     wxString str;
 502     str.Printf(wxT("%ld"), (signed long)c);
 503     WriteString(str);
 504
 505     return *this;
 506 }
 507
 508 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint16 c)
 509 {
 510     wxString str;
 511     str.Printf(wxT("%u"), (unsigned int)c);
 512     WriteString(str);
 513
 514     return *this;
 515 }
 516
 517 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint32 c)
 518 {
 519     wxString str;
 520     str.Printf(wxT("%lu"), (unsigned long)c);
 521     WriteString(str);
 522
 523     return *this;
 524 }
 525
 526 wxTextOutputStream &wxTextOutputStream::operator<<(double f)
 527 {
 528     WriteDouble(f);
 529     return *this;
 530 }
 531
 532 wxTextOutputStream& wxTextOutputStream::operator<<(float f)
 533 {
 534     WriteDouble((double)f);
 535     return *this;
 536 }
 537
 538 wxTextOutputStream &endl( wxTextOutputStream &stream )
 539 {
 540     return stream.PutChar(wxT('\n'));
 541 }
 542
 543 #endif
 544   // wxUSE_STREAMS