]> git.saurik.com Git - wxWidgets.git/blob - src/common/txtstrm.cpp
changed version number
[wxWidgets.git] / 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 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 // VZ: what about using strtol()?? (TODO)
92
93 int sign;
94 wxInt32 i;
95
96 if (!m_input) return 0;
97 int c = NextNonSeparators();
98 if (c==(wxChar)0) return 0;
99
100 i = 0;
101 if (! (c == wxT('-') || c == wxT('+') || isdigit(c)) )
102 {
103 m_input.Ungetch(c);
104 return 0;
105 }
106
107 if (c == wxT('-'))
108 {
109 sign = -1;
110 c = m_input.GetC();
111 } else
112 if (c == wxT('+'))
113 {
114 sign = 1;
115 c = m_input.GetC();
116 } else
117 {
118 sign = 1;
119 }
120
121 while (isdigit(c))
122 {
123 i = i*10 + (c - (int)wxT('0'));
124 c = m_input.GetC();
125 }
126
127 SkipIfEndOfLine( c );
128
129 i *= sign;
130
131 return (wxUint32)i;
132 }
133
134 wxUint16 wxTextInputStream::Read16()
135 {
136 return (wxUint16)Read32();
137 }
138
139 wxUint8 wxTextInputStream::Read8()
140 {
141 return (wxUint8)Read32();
142 }
143
144 double wxTextInputStream::ReadDouble()
145 {
146 /* I only implemented a simple float parser
147 * VZ: what about using strtod()?? (TODO)
148 */
149
150 double f;
151 int theSign;
152
153 if (!m_input)
154 return 0;
155
156 int c = NextNonSeparators();
157 if (c==(wxChar)0) return 0;
158
159 f = 0.0;
160 if (! (c == wxT('.') || c == wxT(',') || c == wxT('-') || c == wxT('+') || isdigit(c)) )
161 {
162 m_input.Ungetch(c);
163 return 0;
164 }
165
166 if (c == wxT('-'))
167 {
168 theSign = -1;
169 c = m_input.GetC();
170 } else
171 if (c == wxT('+'))
172 {
173 theSign = 1;
174 c = m_input.GetC();
175 }
176 else
177 {
178 theSign = 1;
179 }
180
181 while (isdigit(c))
182 {
183 f = f*10 + (c - wxT('0'));
184 c = m_input.GetC();
185 }
186
187 if (c == wxT('.') || c == wxT(','))
188 {
189 double f_multiplicator = (double) 0.1;
190
191 c = m_input.GetC();
192
193 while (isdigit(c))
194 {
195 f += (c-wxT('0'))*f_multiplicator;
196 f_multiplicator /= 10;
197 c = m_input.GetC();
198 }
199
200 if (c == wxT('e'))
201 {
202 double f_multiplicator = 0.0;
203 int i, e;
204
205 c = m_input.GetC();
206
207 switch (c)
208 {
209 case wxT('-'): f_multiplicator = 0.1; break;
210 case wxT('+'): f_multiplicator = 10.0; break;
211 }
212
213 e = Read8(); // why only max 256 ?
214
215 for (i=0;i<e;i++)
216 f *= f_multiplicator;
217 }
218 else
219 SkipIfEndOfLine( c );
220 }
221 else
222 {
223 m_input.Ungetch(c);
224 }
225
226 f *= theSign;
227 return f;
228 }
229
230 wxString wxTextInputStream::ReadString()
231 {
232 return ReadLine();
233 }
234
235 wxString wxTextInputStream::ReadLine()
236 {
237 wxChar c;
238 wxString line;
239
240 while ( !m_input.Eof() )
241 {
242 c = m_input.GetC();
243
244 if ( !m_input )
245 break;
246
247 if (EatEOL(c))
248 break;
249
250 line += c;
251 }
252
253 return line;
254 }
255
256 wxString wxTextInputStream::ReadWord()
257 {
258 wxString word;
259
260 if ( !m_input )
261 return word;
262
263 wxChar c = NextNonSeparators();
264 if ( !c )
265 return word;
266
267 word += c;
268
269 while ( !m_input.Eof() )
270 {
271 c = m_input.GetC();
272
273 if (!m_input)
274 break;
275
276 if (m_separators.Contains(c))
277 break;
278
279 if (EatEOL(c))
280 break;
281
282 word += c;
283 }
284
285 return word;
286 }
287
288 wxTextInputStream& wxTextInputStream::operator>>(wxString& word)
289 {
290 word = ReadWord();
291 return *this;
292 }
293
294 wxTextInputStream& wxTextInputStream::operator>>(char& c)
295 {
296 if (!m_input)
297 {
298 c = 0;
299 return *this;
300 }
301
302 c = m_input.GetC();
303
304 if (EatEOL(c))
305 c = '\n';
306
307 return *this;
308 }
309
310 wxTextInputStream& wxTextInputStream::operator>>(wxInt16& i)
311 {
312 i = (wxInt16)Read16();
313 return *this;
314 }
315
316 wxTextInputStream& wxTextInputStream::operator>>(wxInt32& i)
317 {
318 i = (wxInt32)Read32();
319 return *this;
320 }
321
322 wxTextInputStream& wxTextInputStream::operator>>(wxUint16& i)
323 {
324 i = Read16();
325 return *this;
326 }
327
328 wxTextInputStream& wxTextInputStream::operator>>(wxUint32& i)
329 {
330 i = Read32();
331 return *this;
332 }
333
334 wxTextInputStream& wxTextInputStream::operator>>(double& i)
335 {
336 i = ReadDouble();
337 return *this;
338 }
339
340 wxTextInputStream& wxTextInputStream::operator>>(float& f)
341 {
342 f = (float)ReadDouble();
343 return *this;
344 }
345
346 wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode)
347 : m_output(s)
348 {
349 m_mode = mode;
350 if (m_mode == wxEOL_NATIVE)
351 {
352 #if defined(__WXMSW__) || defined(__WXPM__)
353 m_mode = wxEOL_DOS;
354 #elif defined(__WXMAC__)
355 m_mode = wxEOL_MAC;
356 #else
357 m_mode = wxEOL_UNIX;
358 #endif
359 }
360 }
361
362 wxTextOutputStream::~wxTextOutputStream()
363 {
364 }
365
366 void wxTextOutputStream::SetMode(wxEOL mode)
367 {
368 m_mode = mode;
369 if (m_mode == wxEOL_NATIVE)
370 {
371 #if defined(__WXMSW__) || defined(__WXPM__)
372 m_mode = wxEOL_DOS;
373 #elif defined(__WXMAC__)
374 m_mode = wxEOL_MAC;
375 #else
376 m_mode = wxEOL_UNIX;
377 #endif
378 }
379 }
380
381 void wxTextOutputStream::Write32(wxUint32 i)
382 {
383 wxString str;
384 str.Printf(wxT("%u"), i);
385
386 WriteString(str);
387 }
388
389 void wxTextOutputStream::Write16(wxUint16 i)
390 {
391 wxString str;
392 str.Printf(wxT("%u"), i);
393
394 WriteString(str);
395 }
396
397 void wxTextOutputStream::Write8(wxUint8 i)
398 {
399 wxString str;
400 str.Printf(wxT("%u"), i);
401
402 WriteString(str);
403 }
404
405 void wxTextOutputStream::WriteDouble(double d)
406 {
407 wxString str;
408
409 str.Printf(wxT("%f"), d);
410 WriteString(str);
411 }
412
413 void wxTextOutputStream::WriteString(const wxString& string)
414 {
415 for (size_t i = 0; i < string.Len(); i++)
416 {
417 wxChar c = string[i];
418 if (c == wxT('\n'))
419 {
420 if (m_mode == wxEOL_DOS)
421 {
422 c = wxT('\r');
423 m_output.Write( (const void*)(&c), sizeof(wxChar) );
424 c = wxT('\n');
425 m_output.Write( (const void*)(&c), sizeof(wxChar) );
426 } else
427 if (m_mode == wxEOL_MAC)
428 {
429 c = wxT('\r');
430 m_output.Write( (const void*)(&c), sizeof(wxChar) );
431 } else
432 {
433 c = wxT('\n');
434 m_output.Write( (const void*)(&c), sizeof(wxChar) );
435 }
436 }
437 else
438 {
439 m_output.Write( (const void*)(&c), sizeof(wxChar) );
440 }
441 }
442 }
443
444 wxTextOutputStream& wxTextOutputStream::operator<<(const wxChar *string)
445 {
446 WriteString( wxString(string) );
447 return *this;
448 }
449
450 wxTextOutputStream& wxTextOutputStream::operator<<(const wxString& string)
451 {
452 WriteString( string );
453 return *this;
454 }
455
456 wxTextOutputStream& wxTextOutputStream::operator<<(char c)
457 {
458 // these strange manipulations are needed in Unicode mode
459 char buf[2];
460 buf[0] = c;
461 buf[1] = 0;
462
463 WriteString( wxString(buf) );
464 return *this;
465 }
466
467 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt16 c)
468 {
469 wxString str;
470 str.Printf(wxT("%d"), (signed int)c);
471 WriteString(str);
472
473 return *this;
474 }
475
476 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt32 c)
477 {
478 wxString str;
479 str.Printf(wxT("%ld"), (signed long)c);
480 WriteString(str);
481
482 return *this;
483 }
484
485 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint16 c)
486 {
487 wxString str;
488 str.Printf(wxT("%u"), (unsigned int)c);
489 WriteString(str);
490
491 return *this;
492 }
493
494 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint32 c)
495 {
496 wxString str;
497 str.Printf(wxT("%lu"), (unsigned long)c);
498 WriteString(str);
499
500 return *this;
501 }
502
503 wxTextOutputStream &wxTextOutputStream::operator<<(double f)
504 {
505 WriteDouble(f);
506 return *this;
507 }
508
509 wxTextOutputStream& wxTextOutputStream::operator<<(float f)
510 {
511 WriteDouble((double)f);
512 return *this;
513 }
514
515 wxTextOutputStream &endl( wxTextOutputStream &stream )
516 {
517 return stream << wxT('\n');
518 }
519
520 #endif
521 // wxUSE_STREAMS