1/*
2**********************************************************************
3*   Copyright (C) 2001-2010, International Business Machines
4*   Corporation and others.  All Rights Reserved.
5**********************************************************************
6*  FILE NAME : ustream.cpp
7*
8*   Modification History:
9*
10*   Date        Name        Description
11*   06/25/2001  grhoten     Move iostream from unistr.h to here
12******************************************************************************
13*/
14
15
16#include "unicode/utypes.h"
17#include "unicode/uobject.h"
18#include "unicode/ustream.h"
19#include "unicode/ucnv.h"
20#include "unicode/uchar.h"
21#include "ustr_cnv.h"
22#include "cmemory.h"
23#include <string.h>
24
25// console IO
26
27#if U_IOSTREAM_SOURCE >= 198506
28
29#if U_IOSTREAM_SOURCE >= 199711
30#define STD_NAMESPACE std::
31#else
32#define STD_NAMESPACE
33#endif
34
35#define STD_OSTREAM STD_NAMESPACE ostream
36#define STD_ISTREAM STD_NAMESPACE istream
37
38U_NAMESPACE_BEGIN
39
40U_IO_API STD_OSTREAM & U_EXPORT2
41operator<<(STD_OSTREAM& stream, const UnicodeString& str)
42{
43    if(str.length() > 0) {
44        char buffer[200];
45        UConverter *converter;
46        UErrorCode errorCode = U_ZERO_ERROR;
47
48        // use the default converter to convert chunks of text
49        converter = u_getDefaultConverter(&errorCode);
50        if(U_SUCCESS(errorCode)) {
51            const UChar *us = str.getBuffer();
52            const UChar *uLimit = us + str.length();
53            char *s, *sLimit = buffer + (sizeof(buffer) - 1);
54            do {
55                errorCode = U_ZERO_ERROR;
56                s = buffer;
57                ucnv_fromUnicode(converter, &s, sLimit, &us, uLimit, 0, FALSE, &errorCode);
58                *s = 0;
59
60                // write this chunk
61                if(s > buffer) {
62                    stream << buffer;
63                }
64            } while(errorCode == U_BUFFER_OVERFLOW_ERROR);
65            u_releaseDefaultConverter(converter);
66        }
67    }
68
69/*    stream.flush();*/
70    return stream;
71}
72
73U_IO_API STD_ISTREAM & U_EXPORT2
74operator>>(STD_ISTREAM& stream, UnicodeString& str)
75{
76    // This is like ICU status checking.
77    if (stream.fail()) {
78        return stream;
79    }
80
81    /* ipfx should eat whitespace when ios::skipws is set */
82    UChar uBuffer[16];
83    char buffer[16];
84    int32_t idx = 0;
85    UConverter *converter;
86    UErrorCode errorCode = U_ZERO_ERROR;
87
88    // use the default converter to convert chunks of text
89    converter = u_getDefaultConverter(&errorCode);
90    if(U_SUCCESS(errorCode)) {
91        UChar *us = uBuffer;
92        const UChar *uLimit = uBuffer + sizeof(uBuffer)/sizeof(*uBuffer);
93        const char *s, *sLimit;
94        char ch;
95        UChar ch32;
96        UBool initialWhitespace = TRUE;
97        UBool continueReading = TRUE;
98
99        /* We need to consume one byte at a time to see what is considered whitespace. */
100        while (continueReading) {
101            ch = stream.get();
102            if (stream.eof()) {
103                // The EOF is only set after the get() of an unavailable byte.
104                if (!initialWhitespace) {
105                    stream.clear(stream.eofbit);
106                }
107                continueReading = FALSE;
108            }
109            sLimit = &ch + (int)continueReading;
110            us = uBuffer;
111            s = &ch;
112            errorCode = U_ZERO_ERROR;
113            /*
114            Since we aren't guaranteed to see the state before this call,
115            this code won't work on stateful encodings like ISO-2022 or an EBCDIC stateful encoding.
116            We flush on the last byte to ensure that we output truncated multibyte characters.
117            */
118            ucnv_toUnicode(converter, &us, uLimit, &s, sLimit, 0, !continueReading, &errorCode);
119            if(U_FAILURE(errorCode)) {
120                /* Something really bad happened. setstate() isn't always an available API */
121                stream.clear(stream.failbit);
122                goto STOP_READING;
123            }
124            /* Was the character consumed? */
125            if (us != uBuffer) {
126                /* Reminder: ibm-1390 & JISX0213 can output 2 Unicode code points */
127                int32_t uBuffSize = us-uBuffer;
128                int32_t uBuffIdx = 0;
129                while (uBuffIdx < uBuffSize) {
130                    U16_NEXT(uBuffer, uBuffIdx, uBuffSize, ch32);
131                    if (u_isWhitespace(ch32)) {
132                        if (!initialWhitespace) {
133                            buffer[idx++] = ch;
134                            while (idx > 0) {
135                                stream.putback(buffer[--idx]);
136                            }
137                            goto STOP_READING;
138                        }
139                        /* else skip intialWhitespace */
140                    }
141                    else {
142                        if (initialWhitespace) {
143                            /*
144                            When initialWhitespace is TRUE, we haven't appended any
145                            character yet.  This is where we truncate the string,
146                            to avoid modifying the string before we know if we can
147                            actually read from the stream.
148                            */
149                            str.truncate(0);
150                            initialWhitespace = FALSE;
151                        }
152                        str.append(ch32);
153                    }
154                }
155                idx = 0;
156            }
157            else {
158                buffer[idx++] = ch;
159            }
160        }
161STOP_READING:
162        u_releaseDefaultConverter(converter);
163    }
164
165/*    stream.flush();*/
166    return stream;
167}
168
169U_NAMESPACE_END
170
171#endif
172
173