OSDN Git Service

Fix for PR libgcj/3426:
[pf3gnuchains/gcc-fork.git] / libjava / gnu / gcj / convert / natIconv.cc
1 // Input_iconv.java -- Java side of iconv() reader.
2
3 /* Copyright (C) 2000, 2001  Free Software Foundation
4
5    This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9 details.  */
10
11 /* Author: Tom Tromey <tromey@redhat.com>.  */
12
13 #include <config.h>
14
15 #include <gcj/cni.h>
16 #include <jvm.h>
17
18 #include <gnu/gcj/convert/Input_iconv.h>
19 #include <gnu/gcj/convert/Output_iconv.h>
20 #include <java/io/CharConversionException.h>
21 #include <java/io/UnsupportedEncodingException.h>
22
23 #include <errno.h>
24
25 #ifdef HAVE_ICONV
26 #include <iconv.h>
27
28 template<typename T>
29 static inline size_t
30 iconv_adapter (size_t (*iconv_f) (iconv_t, T, size_t *, char **, size_t *),
31                iconv_t handle, char **inbuf, size_t *inavail,
32                char **outbuf, size_t *outavail)
33 {
34   return (*iconv_f) (handle, (T) inbuf, inavail, outbuf, outavail);
35 }
36
37 #endif
38
39 void
40 gnu::gcj::convert::Input_iconv::init (jstring encoding)
41 {
42 #ifdef HAVE_ICONV
43   jsize len = _Jv_GetStringUTFLength (encoding);
44   char buffer[len + 1];
45   _Jv_GetStringUTFRegion (encoding, 0, len, buffer);
46   buffer[len] = '\0';
47
48   iconv_t h = iconv_open ("UCS-2", buffer);
49   if (h == (iconv_t) -1)
50     throw new java::io::UnsupportedEncodingException (encoding);
51
52   JvAssert (h != NULL);
53   handle = reinterpret_cast<gnu::gcj::RawData *> (h);
54 #else /* HAVE_ICONV */
55   // If no iconv, just throw an exception.
56   throw new java::io::UnsupportedEncodingException (encoding);
57 #endif /* HAVE_ICONV */
58 }
59
60 void
61 gnu::gcj::convert::Input_iconv::finalize (void)
62 {
63 #ifdef HAVE_ICONV
64   if (handle != NULL)
65     {
66       iconv_close ((iconv_t) handle);
67       handle = NULL;
68     }
69 #endif /* HAVE_ICONV */
70 }
71
72 jint
73 gnu::gcj::convert::Input_iconv::read (jcharArray outbuffer,
74                                       jint outpos, jint count)
75 {
76 #ifdef HAVE_ICONV
77   jbyte *bytes = elements (inbuffer);
78   jchar *out = elements (outbuffer);
79   size_t inavail = inlength - inpos;
80   size_t old_in = inavail;
81   size_t outavail = count * sizeof (jchar);
82   size_t old_out = outavail;
83
84   char *inbuf = (char *) &bytes[inpos];
85   char *outbuf = (char *) &out[outpos];
86
87   size_t r = iconv_adapter (iconv, (iconv_t) handle,
88                             &inbuf, &inavail,
89                             &outbuf, &outavail);
90
91   if (r == (size_t) -1)
92     {
93       // Incomplete character.
94       if (errno == EINVAL)
95         return 0;
96       throw new java::io::CharConversionException ();
97     }
98
99   if (iconv_byte_swap)
100     {
101       size_t max = (old_out - outavail) / sizeof (jchar);
102       for (size_t i = 0; i < max; ++i)
103         {
104           // Byte swap.
105           jchar c = (((out[outpos + i] & 0xff) << 8)
106                      | ((out[outpos + i] >> 8) & 0xff));
107           outbuf[i] = c;
108         }
109     }
110
111   inpos += old_in - inavail;
112   return (old_out - outavail) / sizeof (jchar);
113 #else /* HAVE_ICONV */
114   return -1;
115 #endif /* HAVE_ICONV */
116 }
117
118 void
119 gnu::gcj::convert::Output_iconv::init (jstring encoding)
120 {
121 #ifdef HAVE_ICONV
122   jsize len = _Jv_GetStringUTFLength (encoding);
123   char buffer[len + 1];
124   _Jv_GetStringUTFRegion (encoding, 0, len, buffer);
125   buffer[len] = '\0';
126
127   iconv_t h = iconv_open (buffer, "UCS-2");
128   if (h == (iconv_t) -1)
129     throw new java::io::UnsupportedEncodingException (encoding);
130
131   JvAssert (h != NULL);
132   handle = reinterpret_cast<gnu::gcj::RawData *> (h);
133 #else /* HAVE_ICONV */
134   // If no iconv, just throw an exception.
135   throw new java::io::UnsupportedEncodingException (encoding);
136 #endif /* HAVE_ICONV */
137 }
138
139 void
140 gnu::gcj::convert::Output_iconv::finalize (void)
141 {
142 #ifdef HAVE_ICONV
143   if (handle != NULL)
144     {
145       iconv_close ((iconv_t) handle);
146       handle = NULL;
147     }
148 #endif /* HAVE_ICONV */
149 }
150
151 jint
152 gnu::gcj::convert::Output_iconv::write (jcharArray inbuffer,
153                                         jint inpos, jint inlength)
154 {
155 #ifdef HAVE_ICONV
156   jchar *chars = elements (inbuffer);
157   jbyte *out = elements (buf);
158   jchar *temp_buffer = NULL;
159
160   size_t inavail = inlength * sizeof (jchar);
161   size_t old_in = inavail;
162
163   size_t outavail = buf->length - count;
164   size_t old_out = outavail;
165
166   char *inbuf = (char *) &chars[inpos];
167   char *outbuf = (char *) &out[count];
168
169   if (iconv_byte_swap)
170     {
171       // Ugly performance penalty -- don't use losing systems!
172       temp_buffer = (jchar *) _Jv_Malloc (inlength * sizeof (jchar));
173       for (int i = 0; i < inlength; ++i)
174         {
175           // Byte swap.
176           jchar c = (((chars[inpos + i] & 0xff) << 8)
177                      | ((chars[inpos + i] >> 8) & 0xff));
178           temp_buffer[i] = c;
179         }
180       inbuf = (char *) temp_buffer;
181     }
182
183   // If the conversion fails on the very first character, then we
184   // assume that the character can't be represented in the output
185   // encoding.  There's nothing useful we can do here, so we simply
186   // omit that character.  Note that we can't check `errno' because
187   // glibc 2.1.3 doesn't set it correctly.  We could check it if we
188   // really needed to, but we'd have to disable support for 2.1.3.
189   size_t loop_old_in = old_in;
190   while (1)
191     {
192       size_t r = iconv_adapter (iconv, (iconv_t) handle,
193                                 &inbuf, &inavail,
194                                 &outbuf, &outavail);
195       if (r == -1 && inavail == loop_old_in)
196         {
197           inavail -= 2;
198           if (inavail == 0)
199             break;
200           loop_old_in -= 2;
201           inbuf += 2;
202         }
203       else
204         break;
205     }
206
207   if (temp_buffer != NULL)
208     _Jv_Free (temp_buffer);
209
210   count += old_out - outavail;
211   return (old_in - inavail) / sizeof (jchar);
212 #else /* HAVE_ICONV */
213   return -1;
214 #endif /* HAVE_ICONV */
215 }
216
217 jboolean
218 gnu::gcj::convert::IOConverter::iconv_init (void)
219 {
220   // Some versions of iconv() always return their UCS-2 results in
221   // big-endian order, and they also require UCS-2 inputs to be in
222   // big-endian order.  For instance, glibc 2.1.3 does this.  If the
223   // UTF-8=>UCS-2 iconv converter has this feature, then we assume
224   // that all UCS-2 converters do.  (This might not be the best
225   // heuristic, but is is all we've got.)
226   jboolean result = false;
227 #ifdef HAVE_ICONV
228   iconv_t handle = iconv_open ("UCS-2", "UTF-8");
229   if (handle != (iconv_t) -1)
230     {
231       jchar c;
232       unsigned char in[3];
233       char *inp, *outp;
234       size_t inc, outc, r;
235
236       // This is the UTF-8 encoding of \ufeff.
237       in[0] = 0xef;
238       in[1] = 0xbb;
239       in[2] = 0xbf;
240
241       inp = (char *) in;
242       inc = 3;
243       outp = (char *) &c;
244       outc = 2;
245
246       r = iconv_adapter (iconv, handle, &inp, &inc, &outp, &outc);
247       // Conversion must be complete for us to use the result.
248       if (r != (size_t) -1 && inc == 0 && outc == 0)
249         result = (c != 0xfeff);
250     }
251 #endif /* HAVE_ICONV */
252   return result;
253 }