?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GenericParameter.cs: override Module properly
[mcs.git] / class / corlib / System.Text / UTF32Encoding.cs
blob9e97f6aefab42b81c3f2a581748b5db47d4d2b56
1 /*
2 * UTF32Encoding.cs - Implementation of the
3 * "System.Text.UTF32Encoding" class.
4 *
5 * Author: Atsushi Enomoto <atsushi@ximian.com>
6 *
7 * Copyright (C) 2005 Novell, Inc. http://www.novell.com
8 *
9 * The basic part (now almost nothing) is copied from UnicodeEncoding.cs.
10 * Original copyrights goes here:
11 *
12 * Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd
13 * Copyright (C) 2003, 2004 Novell, Inc.
14 *
15 * Permission is hereby granted, free of charge, to any person obtaining
16 * a copy of this software and associated documentation files (the "Software"),
17 * to deal in the Software without restriction, including without limitation
18 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
19 * and/or sell copies of the Software, and to permit persons to whom the
20 * Software is furnished to do so, subject to the following conditions:
21 *
22 * The above copyright notice and this permission notice shall be included
23 * in all copies or substantial portions of the Software.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
26 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
28 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
29 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
30 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
31 * OTHER DEALINGS IN THE SOFTWARE.
32 */
33
34 namespace System.Text
35 {
36
37 using System;
38
39 [Serializable]
40 public sealed class UTF32Encoding : Encoding
41 {
42 // Magic numbers used by Windows for UTF32.
43 internal const int UTF32_CODE_PAGE = 12000;
44 internal const int BIG_UTF32_CODE_PAGE = 12001;
45
46 // Internal state.
47 private bool bigEndian;
48 private bool byteOrderMark;
49
50 // Constructors.
51 public UTF32Encoding () : this (false, true, false)
52 {
53 }
54
55 public UTF32Encoding (bool bigEndian, bool byteOrderMark)
56 : this (bigEndian, byteOrderMark, false)
57 {
58 }
59
60 public UTF32Encoding (bool bigEndian, bool byteOrderMark, bool throwOnInvalidCharacters)
61 : base ((bigEndian ? BIG_UTF32_CODE_PAGE : UTF32_CODE_PAGE))
62 {
63 this.bigEndian = bigEndian;
64 this.byteOrderMark = byteOrderMark;
65
66 if (throwOnInvalidCharacters)
67 SetFallbackInternal (EncoderFallback.ExceptionFallback,
68 DecoderFallback.ExceptionFallback);
69 else
70 SetFallbackInternal (new EncoderReplacementFallback ("\uFFFD"),
71 new DecoderReplacementFallback ("\uFFFD"));
72
73 if (bigEndian){
74 body_name = "utf-32BE";
75 encoding_name = "UTF-32 (Big-Endian)";
76 header_name = "utf-32BE";
77 web_name = "utf-32BE";
78 } else {
79 body_name = "utf-32";
80 encoding_name = "UTF-32";
81 header_name = "utf-32";
82 web_name = "utf-32";
83 }
84
85 // Windows reports the same code page number for
86 // both the little-endian and big-endian forms.
87 windows_code_page = UTF32_CODE_PAGE;
88 }
89
90 // Get the number of bytes needed to encode a character buffer.
91 [MonoTODO ("handle fallback")]
92 public override int GetByteCount (char[] chars, int index, int count)
93 {
94 if (chars == null) {
95 throw new ArgumentNullException ("chars");
96 }
97 if (index < 0 || index > chars.Length) {
98 throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
99 }
100 if (count < 0 || count > (chars.Length - index)) {
101 throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
102 }
103 int ret = 0;
104 for (int i = index; i < index + count; i++) {
105 if (Char.IsSurrogate (chars [i])) {
106 if (i + 1 < chars.Length && Char.IsSurrogate (chars [i + 1]))
107 ret += 4;
108 else
109 // FIXME: handle fallback
110 // ret += DecoderFallback.MaxCharCount;
111 ret += 4;
112 }
113 else
114 ret += 4;
115 }
116 return ret;
117 }
118
119 // Get the bytes that result from encoding a character buffer.
120 [MonoTODO ("handle fallback")]
121 public override int GetBytes (char[] chars, int charIndex, int charCount,
122 byte[] bytes, int byteIndex)
123 {
124 if (chars == null) {
125 throw new ArgumentNullException ("chars");
126 }
127 if (bytes == null) {
128 throw new ArgumentNullException ("bytes");
129 }
130 if (charIndex < 0 || charIndex > chars.Length) {
131 throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
132 }
133 if (charCount < 0 || charCount > (chars.Length - charIndex)) {
134 throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_Array"));
135 }
136 if (byteIndex < 0 || byteIndex > bytes.Length) {
137 throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
138 }
139 if ((bytes.Length - byteIndex) < (charCount * 4)) {
140 throw new ArgumentException (_("Arg_InsufficientSpace"));
141 }
142 int posn = byteIndex;
143 char ch;
144
145 while (charCount-- > 0) {
146 ch = chars[charIndex++];
147 if (Char.IsSurrogate (ch)) {
148 if (charCount-- > 0) {
149 int value = 0x400 * (ch - 0xD800) + 0x10000 + chars [charIndex++] - 0xDC00;
150 if (bigEndian) {
151 for (int i = 0; i < 4; i++) {
152 bytes [posn + 3 - i] = (byte) (value % 0x100);
153 value >>= 8;
154 }
155 posn += 4;
156 } else {
157 for (int i = 0; i < 4; i++) {
158 bytes [posn++] = (byte) (value % 0x100);
159 value >>= 8;
160 }
161 }
162 } else {
163 // Illegal surrogate
164 // FIXME: use fallback
165 if (bigEndian) {
166 bytes[posn++] = 0;
167 bytes[posn++] = 0;
168 bytes[posn++] = 0;
169 bytes[posn++] = (byte) '?';
170 } else {
171 bytes[posn++] = (byte) '?';
172 bytes[posn++] = 0;
173 bytes[posn++] = 0;
174 bytes[posn++] = 0;
175 }
176 }
177 } else {
178 if (bigEndian) {
179 bytes[posn++] = 0;
180 bytes[posn++] = 0;
181 bytes[posn++] = (byte)(ch >> 8);
182 bytes[posn++] = (byte)ch;
183 } else {
184 bytes[posn++] = (byte)ch;
185 bytes[posn++] = (byte)(ch >> 8);
186 bytes[posn++] = 0;
187 bytes[posn++] = 0;
188 }
189 }
190 }
191
192 return posn - byteIndex;
193 }
194
195 // Get the number of characters needed to decode a byte buffer.
196 public override int GetCharCount (byte[] bytes, int index, int count)
197 {
198 if (bytes == null) {
199 throw new ArgumentNullException ("bytes");
200 }
201 if (index < 0 || index > bytes.Length) {
202 throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
203 }
204 if (count < 0 || count > (bytes.Length - index)) {
205 throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
206 }
207 return count / 4;
208 }
209
210 // Get the characters that result from decoding a byte buffer.
211 public override int GetChars (byte[] bytes, int byteIndex, int byteCount,
212 char[] chars, int charIndex)
213 {
214 if (bytes == null) {
215 throw new ArgumentNullException ("bytes");
216 }
217 if (chars == null) {
218 throw new ArgumentNullException ("chars");
219 }
220 if (byteIndex < 0 || byteIndex > bytes.Length) {
221 throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
222 }
223 if (byteCount < 0 || byteCount > (bytes.Length - byteIndex)) {
224 throw new ArgumentOutOfRangeException ("byteCount", _("ArgRange_Array"));
225 }
226 if (charIndex < 0 || charIndex > chars.Length) {
227 throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
228 }
229
230 /*
231 // Determine the byte order in the incoming buffer.
232 bool isBigEndian;
233 if (byteCount >= 2) {
234 if (bytes[byteIndex] == (byte)0xFE && bytes[byteIndex + 1] == (byte)0xFF) {
235 isBigEndian = true;
236 } else if (bytes[byteIndex] == (byte)0xFF && bytes[byteIndex + 1] == (byte)0xFE) {
237 isBigEndian = false;
238 } else {
239 isBigEndian = bigEndian;
240 }
241 } else {
242 isBigEndian = bigEndian;
243 }
244 */
245
246 // Validate that we have sufficient space in "chars".
247 if ((chars.Length - charIndex) < (byteCount / 4)) {
248 throw new ArgumentException (_("Arg_InsufficientSpace"));
249 }
250
251 // Convert the characters.
252 int posn = charIndex;
253 if (bigEndian) {
254 while (byteCount >= 4) {
255 chars[posn++] = (char) (
256 bytes[byteIndex] << 24 |
257 bytes[byteIndex + 1] << 16 |
258 bytes[byteIndex + 2] << 8 |
259 bytes[byteIndex + 3]);
260 byteIndex += 4;
261 byteCount -= 4;
262 }
263 } else {
264 while (byteCount >= 4) {
265 chars[posn++] = (char) (
266 bytes[byteIndex] |
267 bytes[byteIndex + 1] << 8 |
268 bytes[byteIndex + 2] << 16 |
269 bytes[byteIndex + 3] << 24);
270 byteIndex += 4;
271 byteCount -= 4;
272 }
273 }
274 return posn - charIndex;
275 }
276
277 // Get the maximum number of bytes needed to encode a
278 // specified number of characters.
279 public override int GetMaxByteCount (int charCount)
280 {
281 if (charCount < 0) {
282 throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_NonNegative"));
283 }
284 return charCount * 4;
285 }
286
287 // Get the maximum number of characters needed to decode a
288 // specified number of bytes.
289 public override int GetMaxCharCount (int byteCount)
290 {
291 if (byteCount < 0) {
292 throw new ArgumentOutOfRangeException
293 ("byteCount", _("ArgRange_NonNegative"));
294 }
295 return byteCount / 4;
296 }
297
298 // Get a UTF32-specific decoder that is attached to this instance.
299 public override Decoder GetDecoder ()
300 {
301 return new UTF32Decoder (bigEndian);
302 }
303
304 // Get the UTF32 preamble.
305 public override byte[] GetPreamble ()
306 {
307 if (byteOrderMark) {
308 byte[] preamble = new byte[4];
309 if (bigEndian) {
310 preamble[2] = (byte)0xFE;
311 preamble[3] = (byte)0xFF;
312 } else {
313 preamble[0] = (byte)0xFF;
314 preamble[1] = (byte)0xFE;
315 }
316 return preamble;
317 } else {
318 return new byte [0];
319 }
320 }
321
322 // Determine if this object is equal to another.
323 public override bool Equals (Object value)
324 {
325 UTF32Encoding enc = (value as UTF32Encoding);
326 if (enc != null) {
327 return (codePage == enc.codePage &&
328 bigEndian == enc.bigEndian &&
329 byteOrderMark == enc.byteOrderMark &&
330 base.Equals (value));
331 } else {
332 return false;
333 }
334 }
335
336 // Get the hash code for this object.
337 public override int GetHashCode ()
338 {
339 int basis = base.GetHashCode ();
340 if (bigEndian)
341 basis ^= 0x1F;
342 if (byteOrderMark)
343 basis ^= 0x3F;
344 return basis;
345 }
346
347 // UTF32 decoder implementation.
348 private sealed class UTF32Decoder : Decoder
349 {
350 private bool bigEndian;
351 private int leftOverByte;
352 private int leftOverLength;
353
354 // Constructor.
355 public UTF32Decoder (bool bigEndian)
356 {
357 this.bigEndian = bigEndian;
358 leftOverByte = -1;
359 }
360
361 // Override inherited methods.
362 public override int GetCharCount (byte[] bytes, int index, int count)
363 {
364 if (bytes == null) {
365 throw new ArgumentNullException ("bytes");
366 }
367 if (index < 0 || index > bytes.Length) {
368 throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
369 }
370 if (count < 0 || count > (bytes.Length - index)) {
371 throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
372 }
373 if (leftOverByte != -1) {
374 return (count + 1) / 4;
375 } else {
376 return count / 4;
377 }
378 }
379
380 public override int GetChars (byte[] bytes, int byteIndex,
381 int byteCount, char[] chars,
382 int charIndex)
383 {
384 if (bytes == null) {
385 throw new ArgumentNullException ("bytes");
386 }
387 if (chars == null) {
388 throw new ArgumentNullException ("chars");
389 }
390 if (byteIndex < 0 || byteIndex > bytes.Length) {
391 throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
392 }
393 if (byteCount < 0 || byteCount > (bytes.Length - byteIndex)) {
394 throw new ArgumentOutOfRangeException ("byteCount", _("ArgRange_Array"));
395 }
396 if (charIndex < 0 || charIndex > chars.Length) {
397 throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
398 }
399
400 // Convert the characters.
401 int posn = charIndex;
402 int leftOver = leftOverByte;
403 int length = chars.Length;
404 char ch;
405
406 int remain = 4 - leftOverLength;
407 if (leftOverLength > 0 && byteCount > remain) {
408 if (bigEndian) {
409 for (int i = 0; i < remain; i++)
410 leftOver += bytes [byteIndex++] << (4 - byteCount--);
411 } else {
412 for (int i = 0; i < remain; i++)
413 leftOver += bytes [byteIndex++] << byteCount--;
414 }
415 if (leftOver > char.MaxValue && posn + 1 < length
416 || posn < length)
417 throw new ArgumentException (_("Arg_InsufficientSpace"));
418 if (leftOver > char.MaxValue) {
419 chars [posn++] = (char) ((leftOver - 10000) / 0x400 + 0xD800);
420 chars [posn++] = (char) ((leftOver - 10000) % 0x400 + 0xDC00);
421 }
422 else
423 chars [posn++] = (char) leftOver;
424
425 leftOver = -1;
426 leftOverLength = 0;
427 }
428
429 while (byteCount > 3) {
430 if (bigEndian) {
431 ch = (char) (
432 bytes[byteIndex++] << 24 |
433 bytes[byteIndex++] << 16 |
434 bytes[byteIndex++] << 8 |
435 bytes[byteIndex++]);
436 } else {
437 ch = (char) (
438 bytes[byteIndex++] |
439 bytes[byteIndex++] << 8 |
440 bytes[byteIndex++] << 16 |
441 bytes[byteIndex++] << 24);
442 }
443 byteCount -= 4;
444
445 if (posn < length) {
446 chars[posn++] = ch;
447 } else {
448 throw new ArgumentException (_("Arg_InsufficientSpace"));
449 }
450 }
451 if (byteCount > 0) {
452 leftOverLength = byteCount;
453 leftOver = 0;
454 if (bigEndian) {
455 for (int i = 0; i < byteCount; i++)
456 leftOver += bytes [byteIndex++] << (4 - byteCount--);
457 } else {
458 for (int i = 0; i < byteCount; i++)
459 leftOver += bytes [byteIndex++] << byteCount--;
460 }
461 leftOverByte = leftOver;
462 }
463
464 // Finished - return the converted length.
465 return posn - charIndex;
466 }
467
468 } // class UTF32Decoder
469
470 [CLSCompliantAttribute(false)]
471 public unsafe override int GetByteCount (char *chars, int count)
472 {
473 if (chars == null)
474 throw new ArgumentNullException ("chars");
475 return count * 4;
476 }
477
478 // a bunch of practically missing implementations (but should just work)
479
480 public override int GetByteCount (string s)
481 {
482 return base.GetByteCount (s);
483 }
484
485 [CLSCompliantAttribute (false)]
486 public override unsafe int GetBytes (char *chars, int charCount, byte *bytes, int byteCount)
487 {
488 return base.GetBytes (chars, charCount, bytes, byteCount);
489 }
490
491 public override int GetBytes (string s, int charIndex, int charCount, byte [] bytes, int byteIndex)
492 {
493 return base.GetBytes (s, charIndex, charCount, bytes, byteIndex);
494 }
495
496 [CLSCompliantAttribute (false)]
497 public override unsafe int GetCharCount (byte *bytes, int count)
498 {
499 return base.GetCharCount (bytes, count);
500 }
501
502 [CLSCompliantAttribute (false)]
503 public override unsafe int GetChars (byte *bytes, int byteCount, char* chars, int charCount)
504 {
505 return base.GetChars (bytes, byteCount, chars, charCount);
506 }
507
508 public override string GetString (byte [] bytes, int index, int count)
509 {
510 return base.GetString (bytes, index, count);
511 }
512
513 public override Encoder GetEncoder ()
514 {
515 return base.GetEncoder ();
516 }
517 }; // class UTF32Encoding
518
519 }; // namespace System.Text
git-svn mirror of mcs