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