?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-05-27 Jb Evain <jbevain@novell.com>
[mcs.git] / class / Mono.Posix / Mono.Unix / UnixEncoding.cs
blob1d8e40ca45cf5ac5e4fcec6e97eaa6f754790c51
1 /*
2 * Mono.Unix/UnixEncoding.cs
3 *
4 * Authors:
5 * Jonathan Pryor (jonpryor@vt.edu)
6 *
7 * Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd
8 * Copyright (C) 2004 Novell, Inc (http://www.novell.com)
9 * Copyright (C) 2005 Jonathan Pryor
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining
12 * a copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
28 */
29
30 namespace Mono.Unix
31 {
32
33 using System;
34 using System.Text;
35
36 [Serializable]
37 public class UnixEncoding : Encoding
38 {
39 public static readonly Encoding Instance = new UnixEncoding ();
40
41 public static readonly char EscapeByte = '\u0000';
42
43 // Constructors.
44 public UnixEncoding ()
45 {
46 }
47
48 // Internal version of "GetByteCount" which can handle a rolling
49 // state between multiple calls to this method.
50 private static int InternalGetByteCount (char[] chars, int index, int count, uint leftOver, bool flush)
51 {
52 // Validate the parameters.
53 if (chars == null) {
54 throw new ArgumentNullException ("chars");
55 }
56 if (index < 0 || index > chars.Length) {
57 throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
58 }
59 if (count < 0 || count > (chars.Length - index)) {
60 throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
61 }
62
63 // Determine the lengths of all characters.
64 char ch;
65 int length = 0;
66 uint pair = leftOver;
67 while (count > 0) {
68 ch = chars[index];
69 if (pair == 0) {
70 if (ch == EscapeByte && count > 1) {
71 ++length;
72 ++index;
73 --count;
74 } else if (ch < '\u0080') {
75 ++length;
76 } else if (ch < '\u0800') {
77 length += 2;
78 } else if (ch >= '\uD800' && ch <= '\uDBFF') {
79 // This is the start of a surrogate pair.
80 pair = (uint)ch;
81 } else {
82 length += 3;
83 }
84 } else if (ch >= '\uDC00' && ch <= '\uDFFF') {
85 // We have a surrogate pair.
86 length += 4;
87 pair = 0;
88 } else {
89 // We have a surrogate start followed by a
90 // regular character. Technically, this is
91 // invalid, but we have to do something.
92 // We write out the surrogate start and then
93 // re-visit the current character again.
94 length += 3;
95 pair = 0;
96 continue;
97 }
98 ++index;
99 --count;
100 }
101 if (flush && pair != 0) {
102 // Flush the left-over surrogate pair start.
103 length += 3;
104 }
105
106 // Return the final length to the caller.
107 return length;
108 }
109
110 // Get the number of bytes needed to encode a character buffer.
111 public override int GetByteCount (char[] chars, int index, int count)
112 {
113 return InternalGetByteCount (chars, index, count, 0, true);
114 }
115
116 // Convenience wrappers for "GetByteCount".
117 public override int GetByteCount (String s)
118 {
119 // Validate the parameters.
120 if (s == null) {
121 throw new ArgumentNullException ("s");
122 }
123
124 // Determine the lengths of all characters.
125 char ch;
126 int index = 0;
127 int count = s.Length;
128 int length = 0;
129 uint pair;
130 while (count > 0) {
131 ch = s[index++];
132 if (ch == EscapeByte && count > 1) {
133 ++length;
134 ++index;
135 --count;
136 } else if (ch < '\u0080') {
137 ++length;
138 } else if (ch < '\u0800') {
139 length += 2;
140 } else if (ch >= '\uD800' && ch <= '\uDBFF' && count > 1) {
141 // This may be the start of a surrogate pair.
142 pair = (uint)(s[index]);
143 if (pair >= (uint)0xDC00 && pair <= (uint)0xDFFF) {
144 length += 4;
145 ++index;
146 --count;
147 } else {
148 length += 3;
149 }
150 } else {
151 length += 3;
152 }
153 --count;
154 }
155
156 // Return the final length to the caller.
157 return length;
158 }
159
160 // Internal version of "GetBytes" which can handle a rolling
161 // state between multiple calls to this method.
162 private static int InternalGetBytes (char[] chars, int charIndex,
163 int charCount, byte[] bytes,
164 int byteIndex, ref uint leftOver,
165 bool flush)
166 {
167 // Validate the parameters.
168 if (chars == null) {
169 throw new ArgumentNullException ("chars");
170 }
171 if (bytes == null) {
172 throw new ArgumentNullException ("bytes");
173 }
174 if (charIndex < 0 || charIndex > chars.Length) {
175 throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
176 }
177 if (charCount < 0 || charCount > (chars.Length - charIndex)) {
178 throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_Array"));
179 }
180 if (byteIndex < 0 || byteIndex > bytes.Length) {
181 throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
182 }
183
184 // Convert the characters into bytes.
185 char ch;
186 int length = bytes.Length;
187 uint pair;
188 uint left = leftOver;
189 int posn = byteIndex;
190 while (charCount > 0) {
191 // Fetch the next UTF-16 character pair value.
192 ch = chars[charIndex++];
193 --charCount;
194 if (left == 0) {
195 if (ch >= '\uD800' && ch <= '\uDBFF') {
196 // This is the start of a surrogate pair.
197 left = (uint)ch;
198 continue;
199 } else if (ch == EscapeByte) {
200 if (posn >= length) {
201 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
202 }
203 if (--charCount >= 0) {
204 bytes[posn++] = (byte) chars [charIndex++];
205 }
206 continue;
207 } else {
208 // This is a regular character.
209 pair = (uint)ch;
210 }
211 } else if (ch >= '\uDC00' && ch <= '\uDFFF') {
212 // We have a surrogate pair.
213 pair = ((left - (uint)0xD800) << 10) +
214 (((uint)ch) - (uint)0xDC00) +
215 (uint)0x10000;
216 left = 0;
217 } else {
218 // We have a surrogate start followed by a
219 // regular character. Technically, this is
220 // invalid, but we have to do something.
221 // We write out the surrogate start and then
222 // re-visit the current character again.
223 pair = (uint)left;
224 left = 0;
225 --charIndex;
226 ++charCount;
227 }
228
229 // Encode the character pair value.
230 if (pair < (uint)0x0080) {
231 if (posn >= length) {
232 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
233 }
234 bytes[posn++] = (byte)pair;
235 } else if (pair < (uint)0x0800) {
236 if ((posn + 2) > length) {
237 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
238 }
239 bytes[posn++] = (byte)(0xC0 | (pair >> 6));
240 bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
241 } else if (pair < (uint)0x10000) {
242 if ((posn + 3) > length) {
243 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
244 }
245 bytes[posn++] = (byte)(0xE0 | (pair >> 12));
246 bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
247 bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
248 } else {
249 if ((posn + 4) > length) {
250 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
251 }
252 bytes[posn++] = (byte)(0xF0 | (pair >> 18));
253 bytes[posn++] = (byte)(0x80 | ((pair >> 12) & 0x3F));
254 bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
255 bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
256 }
257 }
258 if (flush && left != 0) {
259 // Flush the left-over surrogate pair start.
260 if ((posn + 3) > length) {
261 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
262 }
263 bytes[posn++] = (byte)(0xE0 | (left >> 12));
264 bytes[posn++] = (byte)(0x80 | ((left >> 6) & 0x3F));
265 bytes[posn++] = (byte)(0x80 | (left & 0x3F));
266 left = 0;
267 }
268 leftOver = left;
269
270 // Return the final count to the caller.
271 return posn - byteIndex;
272 }
273
274 // Get the bytes that result from encoding a character buffer.
275 public override int GetBytes (char[] chars, int charIndex, int charCount,
276 byte[] bytes, int byteIndex)
277 {
278 uint leftOver = 0;
279 return InternalGetBytes (chars, charIndex, charCount, bytes, byteIndex, ref leftOver, true);
280 }
281
282 // Convenience wrappers for "GetBytes".
283 public override int GetBytes (String s, int charIndex, int charCount,
284 byte[] bytes, int byteIndex)
285 {
286 // Validate the parameters.
287 if (s == null) {
288 throw new ArgumentNullException ("s");
289 }
290 if (bytes == null) {
291 throw new ArgumentNullException ("bytes");
292 }
293 if (charIndex < 0 || charIndex > s.Length) {
294 throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_StringIndex"));
295 }
296 if (charCount < 0 || charCount > (s.Length - charIndex)) {
297 throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_StringRange"));
298 }
299 if (byteIndex < 0 || byteIndex > bytes.Length) {
300 throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
301 }
302
303 // Convert the characters into bytes.
304 char ch;
305 int length = bytes.Length;
306 uint pair;
307 int posn = byteIndex;
308 while (charCount > 0) {
309 // Fetch the next UTF-16 character pair value.
310 ch = s[charIndex++];
311 if (ch >= '\uD800' && ch <= '\uDBFF' && charCount > 1) {
312 // This may be the start of a surrogate pair.
313 pair = (uint)(s[charIndex]);
314 if (pair >= (uint)0xDC00 && pair <= (uint)0xDFFF) {
315 pair = (pair - (uint)0xDC00) +
316 ((((uint)ch) - (uint)0xD800) << 10) +
317 (uint)0x10000;
318 ++charIndex;
319 --charCount;
320 } else {
321 pair = (uint)ch;
322 }
323 } else if (ch == EscapeByte && charCount > 1) {
324 if (posn >= length) {
325 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
326 }
327 charCount -= 2;
328 if (charCount >= 0) {
329 bytes[posn++] = (byte) s [charIndex++];
330 }
331 continue;
332 } else {
333 pair = (uint)ch;
334 }
335 --charCount;
336
337 // Encode the character pair value.
338 if (pair < (uint)0x0080) {
339 if (posn >= length) {
340 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
341 }
342 bytes[posn++] = (byte)pair;
343 } else if (pair < (uint)0x0800) {
344 if ((posn + 2) > length) {
345 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
346 }
347 bytes[posn++] = (byte)(0xC0 | (pair >> 6));
348 bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
349 } else if (pair < (uint)0x10000) {
350 if ((posn + 3) > length) {
351 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
352 }
353 bytes[posn++] = (byte)(0xE0 | (pair >> 12));
354 bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
355 bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
356 } else {
357 if ((posn + 4) > length) {
358 throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
359 }
360 bytes[posn++] = (byte)(0xF0 | (pair >> 18));
361 bytes[posn++] = (byte)(0x80 | ((pair >> 12) & 0x3F));
362 bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
363 bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
364 }
365 }
366
367 // Return the final count to the caller.
368 return posn - byteIndex;
369 }
370
371 // Internal version of "GetCharCount" which can handle a rolling
372 // state between multiple calls to this method.
373 private static int InternalGetCharCount (byte[] bytes, int index, int count,
374 uint leftOverBits,
375 uint leftOverCount,
376 bool throwOnInvalid, bool flush)
377 {
378 // Validate the parameters.
379 if (bytes == null) {
380 throw new ArgumentNullException ("bytes");
381 }
382 if (index < 0 || index > bytes.Length) {
383 throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
384 }
385 if (count < 0 || count > (bytes.Length - index)) {
386 throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
387 }
388
389 // Determine the number of characters that we have.
390 int next_raw = 0;
391 uint ch;
392 int length = 0;
393 uint leftBits = leftOverBits;
394 uint leftSoFar = (leftOverCount & (uint)0x0F);
395 uint leftSize = ((leftOverCount >> 4) & (uint)0x0F);
396 while (count > 0) {
397 ch = (uint)(bytes[index++]);
398 ++next_raw;
399 --count;
400 if (leftSize == 0) {
401 // Process a UTF-8 start character.
402 if (ch < (uint)0x0080) {
403 // Single-byte UTF-8 character.
404 ++length;
405 next_raw = 0;
406 } else if ((ch & (uint)0xE0) == (uint)0xC0) {
407 // Double-byte UTF-8 character.
408 leftBits = (ch & (uint)0x1F);
409 leftSoFar = 1;
410 leftSize = 2;
411 } else if ((ch & (uint)0xF0) == (uint)0xE0) {
412 // Three-byte UTF-8 character.
413 leftBits = (ch & (uint)0x0F);
414 leftSoFar = 1;
415 leftSize = 3;
416 } else if ((ch & (uint)0xF8) == (uint)0xF0) {
417 // Four-byte UTF-8 character.
418 leftBits = (ch & (uint)0x07);
419 leftSoFar = 1;
420 leftSize = 4;
421 } else if ((ch & (uint)0xFC) == (uint)0xF8) {
422 // Five-byte UTF-8 character.
423 leftBits = (ch & (uint)0x03);
424 leftSoFar = 1;
425 leftSize = 5;
426 } else if ((ch & (uint)0xFE) == (uint)0xFC) {
427 // Six-byte UTF-8 character.
428 leftBits = (ch & (uint)0x03);
429 leftSoFar = 1;
430 leftSize = 6;
431 } else {
432 // Invalid UTF-8 start character.
433 if (throwOnInvalid) {
434 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
435 }
436 length += next_raw*2;
437 next_raw = 0;
438 }
439 } else {
440 // Process an extra byte in a multi-byte sequence.
441 if ((ch & (uint)0xC0) == (uint)0x80) {
442 leftBits = ((leftBits << 6) | (ch & (uint)0x3F));
443 if (++leftSoFar >= leftSize) {
444 // We have a complete character now.
445 if (leftBits < (uint)0x10000) {
446 // is it an overlong ?
447 bool overlong = false;
448 switch (leftSize) {
449 case 2:
450 overlong = (leftBits <= 0x7F);
451 break;
452 case 3:
453 overlong = (leftBits <= 0x07FF);
454 break;
455 case 4:
456 overlong = (leftBits <= 0xFFFF);
457 break;
458 case 5:
459 overlong = (leftBits <= 0x1FFFFF);
460 break;
461 case 6:
462 overlong = (leftBits <= 0x03FFFFFF);
463 break;
464 }
465 if (overlong) {
466 // if (throwOnInvalid)
467 // throw new ArgumentException (_("Overlong"), leftBits.ToString ());
468 length += next_raw*2;
469 }
470 else
471 ++length;
472 } else if (leftBits < (uint)0x110000) {
473 length += 2;
474 } else if (throwOnInvalid) {
475 // ???
476 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
477 length += next_raw*2;
478 }
479 leftSize = 0;
480 next_raw = 0;
481 }
482 } else {
483 // Invalid UTF-8 sequence: clear and restart.
484 if (throwOnInvalid) {
485 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
486 }
487 // don't escape the current byte, process it normally
488 if (ch < (uint)0x0080) {
489 --index;
490 ++count;
491 --next_raw;
492 }
493 length += next_raw*2;
494 leftSize = 0;
495 next_raw = 0;
496 }
497 }
498 }
499 if (flush && leftSize != 0 && throwOnInvalid) {
500 // We had left-over bytes that didn't make up
501 // a complete UTF-8 character sequence.
502 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
503 length += next_raw * 2;
504 }
505
506 // Return the final length to the caller.
507 return length;
508 }
509
510 // Get the number of characters needed to decode a byte buffer.
511 public override int GetCharCount (byte[] bytes, int index, int count)
512 {
513 return InternalGetCharCount (bytes, index, count, 0, 0, true, true);
514 }
515
516 // Get the characters that result from decoding a byte buffer.
517 private static int InternalGetChars (byte[] bytes, int byteIndex,
518 int byteCount, char[] chars,
519 int charIndex, ref uint leftOverBits,
520 ref uint leftOverCount,
521 bool throwOnInvalid, bool flush)
522 {
523 // Validate the parameters.
524 if (bytes == null) {
525 throw new ArgumentNullException ("bytes");
526 }
527 if (chars == null) {
528 throw new ArgumentNullException ("chars");
529 }
530 if (byteIndex < 0 || byteIndex > bytes.Length) {
531 throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
532 }
533 if (byteCount < 0 || byteCount > (bytes.Length - byteIndex)) {
534 throw new ArgumentOutOfRangeException ("byteCount", _("ArgRange_Array"));
535 }
536 if (charIndex < 0 || charIndex > chars.Length) {
537 throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
538 }
539
540 if (charIndex == chars.Length)
541 return 0;
542
543 // Convert the bytes into the output buffer.
544 byte[] raw = new byte[6];
545 int next_raw = 0;
546 uint ch;
547 int length = chars.Length;
548 int posn = charIndex;
549 uint leftBits = leftOverBits;
550 uint leftSoFar = (leftOverCount & (uint)0x0F);
551 uint leftSize = ((leftOverCount >> 4) & (uint)0x0F);
552 while (byteCount > 0) {
553 // Fetch the next character from the byte buffer.
554 ch = (uint)(bytes[byteIndex++]);
555 raw [next_raw++] = (byte) ch;
556 --byteCount;
557 if (leftSize == 0) {
558 // Process a UTF-8 start character.
559 if (ch < (uint)0x0080) {
560 // Single-byte UTF-8 character.
561 if (posn >= length) {
562 throw new ArgumentException (_("Arg_InsufficientSpace"), "chars");
563 }
564 next_raw = 0;
565 chars[posn++] = (char)ch;
566 } else if ((ch & (uint)0xE0) == (uint)0xC0) {
567 // Double-byte UTF-8 character.
568 leftBits = (ch & (uint)0x1F);
569 leftSoFar = 1;
570 leftSize = 2;
571 } else if ((ch & (uint)0xF0) == (uint)0xE0) {
572 // Three-byte UTF-8 character.
573 leftBits = (ch & (uint)0x0F);
574 leftSoFar = 1;
575 leftSize = 3;
576 } else if ((ch & (uint)0xF8) == (uint)0xF0) {
577 // Four-byte UTF-8 character.
578 leftBits = (ch & (uint)0x07);
579 leftSoFar = 1;
580 leftSize = 4;
581 } else if ((ch & (uint)0xFC) == (uint)0xF8) {
582 // Five-byte UTF-8 character.
583 leftBits = (ch & (uint)0x03);
584 leftSoFar = 1;
585 leftSize = 5;
586 } else if ((ch & (uint)0xFE) == (uint)0xFC) {
587 // Six-byte UTF-8 character.
588 leftBits = (ch & (uint)0x03);
589 leftSoFar = 1;
590 leftSize = 6;
591 } else {
592 // Invalid UTF-8 start character.
593 if (throwOnInvalid) {
594 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
595 }
596 next_raw = 0;
597 chars[posn++] = EscapeByte;
598 chars[posn++] = (char) ch;
599 }
600 } else {
601 // Process an extra byte in a multi-byte sequence.
602 if ((ch & (uint)0xC0) == (uint)0x80) {
603 leftBits = ((leftBits << 6) | (ch & (uint)0x3F));
604 if (++leftSoFar >= leftSize) {
605 // We have a complete character now.
606 if (leftBits < (uint)0x10000) {
607 // is it an overlong ?
608 bool overlong = false;
609 switch (leftSize) {
610 case 2:
611 overlong = (leftBits <= 0x7F);
612 break;
613 case 3:
614 overlong = (leftBits <= 0x07FF);
615 break;
616 case 4:
617 overlong = (leftBits <= 0xFFFF);
618 break;
619 case 5:
620 overlong = (leftBits <= 0x1FFFFF);
621 break;
622 case 6:
623 overlong = (leftBits <= 0x03FFFFFF);
624 break;
625 }
626 if (overlong) {
627 // if (throwOnInvalid)
628 // throw new ArgumentException (_("Overlong"), leftBits.ToString ());
629 CopyRaw (raw, ref next_raw, chars, ref posn, length);
630 }
631 else {
632 if (posn >= length) {
633 throw new ArgumentException
634 (_("Arg_InsufficientSpace"), "chars");
635 }
636 chars[posn++] = (char)leftBits;
637 }
638 } else if (leftBits < (uint)0x110000) {
639 if ((posn + 2) > length) {
640 throw new ArgumentException
641 (_("Arg_InsufficientSpace"), "chars");
642 }
643 leftBits -= (uint)0x10000;
644 chars[posn++] = (char)((leftBits >> 10) +
645 (uint)0xD800);
646 chars[posn++] =
647 (char)((leftBits & (uint)0x3FF) + (uint)0xDC00);
648 } else if (throwOnInvalid) {
649 // ???
650 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
651 CopyRaw (raw, ref next_raw, chars, ref posn, length);
652 }
653 leftSize = 0;
654 next_raw = 0;
655 }
656 } else {
657 // Invalid UTF-8 sequence: clear and restart.
658 if (throwOnInvalid) {
659 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
660 }
661 // don't escape the current byte, process it normally
662 if (ch < (uint)0x0080) {
663 --byteIndex;
664 ++byteCount;
665 --next_raw;
666 }
667 CopyRaw (raw, ref next_raw, chars, ref posn, length);
668 leftSize = 0;
669 next_raw = 0;
670 }
671 }
672 }
673 if (flush && leftSize != 0 && throwOnInvalid) {
674 // We had left-over bytes that didn't make up
675 // a complete UTF-8 character sequence.
676 // throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
677 CopyRaw (raw, ref next_raw, chars, ref posn, length);
678 }
679 leftOverBits = leftBits;
680 leftOverCount = (leftSoFar | (leftSize << 4));
681
682 // Return the final length to the caller.
683 return posn - charIndex;
684 }
685
686 private static void CopyRaw (byte[] raw, ref int next_raw, char[] chars, ref int posn, int length)
687 {
688 if (posn+(next_raw*2) > length)
689 throw new ArgumentException (_("Arg_InsufficientSpace"), "chars");
690
691 for (int i = 0; i < next_raw; ++i) {
692 chars[posn++] = EscapeByte;
693 chars[posn++] = (char) raw [i];
694 }
695
696 next_raw = 0;
697 }
698
699 // Get the characters that result from decoding a byte buffer.
700 public override int GetChars (byte[] bytes, int byteIndex, int byteCount,
701 char[] chars, int charIndex)
702 {
703 uint leftOverBits = 0;
704 uint leftOverCount = 0;
705 return InternalGetChars (bytes, byteIndex, byteCount, chars,
706 charIndex, ref leftOverBits, ref leftOverCount, true, true);
707 }
708
709 // Get the maximum number of bytes needed to encode a
710 // specified number of characters.
711 public override int GetMaxByteCount (int charCount)
712 {
713 if (charCount < 0) {
714 throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_NonNegative"));
715 }
716 return charCount * 4;
717 }
718
719 // Get the maximum number of characters needed to decode a
720 // specified number of bytes.
721 public override int GetMaxCharCount (int byteCount)
722 {
723 if (byteCount < 0) {
724 throw new ArgumentOutOfRangeException ("byteCount", _("ArgRange_NonNegative"));
725 }
726 return byteCount;
727 }
728
729 // Get a Unix-specific decoder that is attached to this instance.
730 public override Decoder GetDecoder ()
731 {
732 return new UnixDecoder ();
733 }
734
735 // Get a Unix-specific encoder that is attached to this instance.
736 public override Encoder GetEncoder ()
737 {
738 return new UnixEncoder ();
739 }
740
741 // Get the Unix preamble.
742 public override byte[] GetPreamble ()
743 {
744 return new byte [0];
745 }
746
747 // Determine if this object is equal to another.
748 public override bool Equals (Object value)
749 {
750 UnixEncoding enc = (value as UnixEncoding);
751 if (enc != null) {
752 return true;
753 }
754 else {
755 return false;
756 }
757 }
758
759 // Get the hash code for this object.
760 public override int GetHashCode ()
761 {
762 return base.GetHashCode ();
763 }
764
765 public override byte [] GetBytes (String s)
766 {
767 if (s == null)
768 throw new ArgumentNullException ("s");
769
770 int length = GetByteCount (s);
771 byte [] bytes = new byte [length];
772 GetBytes (s, 0, s.Length, bytes, 0);
773 return bytes;
774 }
775
776 // Unix decoder implementation.
777 [Serializable]
778 private class UnixDecoder : Decoder
779 {
780 private uint leftOverBits;
781 private uint leftOverCount;
782
783 // Constructor.
784 public UnixDecoder ()
785 {
786 leftOverBits = 0;
787 leftOverCount = 0;
788 }
789
790 // Override inherited methods.
791 public override int GetCharCount (byte[] bytes, int index, int count)
792 {
793 return InternalGetCharCount (bytes, index, count,
794 leftOverBits, leftOverCount, true, false);
795 }
796 public override int GetChars (byte[] bytes, int byteIndex,
797 int byteCount, char[] chars, int charIndex)
798 {
799 return InternalGetChars (bytes, byteIndex, byteCount,
800 chars, charIndex, ref leftOverBits, ref leftOverCount, true, false);
801 }
802
803 }
804
805 // Unix encoder implementation.
806 [Serializable]
807 private class UnixEncoder : Encoder
808 {
809 private uint leftOver;
810
811 // Constructor.
812 public UnixEncoder ()
813 {
814 leftOver = 0;
815 }
816
817 // Override inherited methods.
818 public override int GetByteCount (char[] chars, int index,
819 int count, bool flush)
820 {
821 return InternalGetByteCount (chars, index, count, leftOver, flush);
822 }
823 public override int GetBytes (char[] chars, int charIndex,
824 int charCount, byte[] bytes, int byteCount, bool flush)
825 {
826 int result;
827 result = InternalGetBytes (chars, charIndex, charCount, bytes, byteCount, ref leftOver, flush);
828 return result;
829 }
830 }
831
832 private static string _ (string arg)
833 {
834 return arg;
835 }
836 }
837 }
838
git-svn mirror of mcs