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