?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-03-02 Jb Evain <jbevain@novell.com>
[mcs.git] / class / I18N / CJK / CP51932.cs
blobbffb15ba77b8fabf9d62be16beb0e7759a468402
1 /*
2 * CP51932.cs - Japanese EUC-JP code page.
3 *
4 * It is based on CP932.cs from Portable.NET
5 *
6 * Author:
7 * Atsushi Enomoto <atsushi@ximian.com>
8 *
9 * Below are original (CP932.cs) copyright lines
10 *
11 * (C)2004 Novell Inc.
12 *
13 * Copyright (c) 2002 Southern Storm Software, Pty Ltd
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 /*
35
36 Well, there looks no jis.table source. Thus, it seems like it is
37 generated from text files from Unicode Home Page such like
38 ftp://ftp.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0208.TXT
39 However, it is non-normative and in Japan it is contains many problem.
40
41 FIXME: Some characters such as 0xFF0B (wide "plus") are missing in
42 that table.
43 */
44
45 /*
46 0x00-0x1F, 0x7F : control characters
47 0x20-0x7E : ASCII
48 0xA1A1-0xFEFE : Kanji (precisely, both bytes contain only A1-FE)
49 0x8EA1-0x8EDF : half-width Katakana
50 0x8FA1A1-0x8FFEFE : Complemental Kanji
51
52 */
53
54 namespace I18N.CJK
55 {
56
57 using System;
58 using System.Text;
59 using I18N.Common;
60
61 [Serializable]
62 public class CP51932 : MonoEncoding
63 {
64 // Magic number used by Windows for the EUC-JP code page.
65 private const int EUC_JP_CODE_PAGE = 51932;
66
67 // Constructor.
68 public CP51932 () : base (EUC_JP_CODE_PAGE, 932)
69 {
70 }
71
72
73 public override int GetByteCount (char [] chars, int index, int length)
74 {
75 return new CP51932Encoder (this).GetByteCount (chars, index, length, true);
76 }
77
78 public unsafe override int GetByteCountImpl (char* chars, int count)
79 {
80 return new CP51932Encoder (this).GetByteCountImpl (chars, count, true);
81 }
82
83 public unsafe override int GetBytesImpl (char* chars, int charCount, byte* bytes, int byteCount)
84 {
85 return new CP51932Encoder (this).GetBytesImpl (chars, charCount, bytes, byteCount, true);
86 }
87
88 public override int GetCharCount (byte [] bytes, int index, int count)
89 {
90 #if NET_2_0
91 return new CP51932Decoder ().GetCharCount (
92 bytes, index, count, true);
93 #else
94 return new CP51932Decoder ().GetCharCount (
95 bytes, index, count);
96 #endif
97 }
98
99 public override int GetChars (
100 byte [] bytes, int byteIndex, int byteCount,
101 char [] chars, int charIndex)
102 {
103 #if NET_2_0
104 return new CP51932Decoder ().GetChars (bytes,
105 byteIndex, byteCount, chars, charIndex, true);
106 #else
107 return new CP51932Decoder ().GetChars (bytes,
108 byteIndex, byteCount, chars, charIndex);
109 #endif
110 }
111
112 // Get the maximum number of bytes needed to encode a
113 // specified number of characters.
114 public override int GetMaxByteCount(int charCount)
115 {
116 if(charCount < 0)
117 {
118 throw new ArgumentOutOfRangeException
119 ("charCount",
120 Strings.GetString("ArgRange_NonNegative"));
121 }
122 return charCount * 3;
123 }
124
125 // Get the maximum number of characters needed to decode a
126 // specified number of bytes.
127 public override int GetMaxCharCount(int byteCount)
128 {
129 if(byteCount < 0)
130 {
131 throw new ArgumentOutOfRangeException
132 ("byteCount",
133 Strings.GetString ("ArgRange_NonNegative"));
134 }
135 return byteCount;
136 }
137
138 public override Encoder GetEncoder ()
139 {
140 return new CP51932Encoder (this);
141 }
142
143 public override Decoder GetDecoder ()
144 {
145 return new CP51932Decoder ();
146 }
147
148 #if !ECMA_COMPAT
149
150 // Get the mail body name for this encoding.
151 public override String BodyName {
152 get { return "euc-jp"; }
153 }
154
155 // Get the human-readable name for this encoding.
156 public override String EncodingName {
157 get { return "Japanese (EUC)"; }
158 }
159
160 // Get the mail agent header name for this encoding.
161 public override String HeaderName {
162 get { return "euc-jp"; }
163 }
164
165 // Determine if this encoding can be displayed in a Web browser.
166 public override bool IsBrowserDisplay {
167 get { return true; }
168 }
169
170 // Determine if this encoding can be saved from a Web browser.
171 public override bool IsBrowserSave {
172 get { return true; }
173 }
174
175 // Determine if this encoding can be displayed in a mail/news agent.
176 public override bool IsMailNewsDisplay {
177 get { return true; }
178 }
179
180 // Determine if this encoding can be saved from a mail/news agent.
181 public override bool IsMailNewsSave {
182 get { return true; }
183 }
184
185 // Get the IANA-preferred Web name for this encoding.
186 public override String WebName {
187 get { return "euc-jp"; }
188 }
189 } // CP51932
190 #endif // !ECMA_COMPAT
191
192 public class CP51932Encoder : MonoEncoder
193 {
194 public CP51932Encoder (MonoEncoding encoding)
195 : base (encoding)
196 {
197 }
198
199 // Get the number of bytes needed to encode a character buffer.
200 public unsafe override int GetByteCountImpl (
201 char* chars, int count, bool refresh)
202 {
203 // Determine the length of the final output.
204 int index = 0;
205 int length = 0;
206 int ch, value;
207 byte [] cjkToJis = JISConvert.Convert.cjkToJis;
208 byte [] extraToJis = JISConvert.Convert.extraToJis;
209
210 while (count > 0) {
211 ch = chars [index++];
212 --count;
213 ++length;
214 if (ch < 0x0080) {
215 // Character maps to itself.
216 continue;
217 } else if (ch < 0x0100) {
218 // Check for special Latin 1 characters that
219 // can be mapped to double-byte code points.
220 if(ch == 0x00A2 || ch == 0x00A3 || ch == 0x00A7 ||
221 ch == 0x00A8 || ch == 0x00AC || ch == 0x00B0 ||
222 ch == 0x00B1 || ch == 0x00B4 || ch == 0x00B6 ||
223 ch == 0x00D7 || ch == 0x00F7)
224 {
225 ++length;
226 }
227 } else if (ch >= 0x0391 && ch <= 0x0451) {
228 // Greek subset characters.
229 ++length;
230 } else if (ch >= 0x2010 && ch <= 0x9FA5) {
231 // This range contains the bulk of the CJK set.
232 value = (ch - 0x2010) * 2;
233 value = ((int) (cjkToJis[value])) | (((int)(cjkToJis[value + 1])) << 8);
234 if(value >= 0x0100)
235 ++length;
236 } else if(ch >= 0xFF01 && ch < 0xFF60) {
237 // This range contains extra characters.
238 value = (ch - 0xFF01) * 2;
239 value = ((int)(extraToJis[value])) |
240 (((int)(extraToJis[value + 1])) << 8);
241 if(value >= 0x0100)
242 ++length;
243 } else if(ch >= 0xFF60 && ch <= 0xFFA0) {
244 ++length; // half-width kana
245 }
246 }
247
248 // Return the length to the caller.
249 return length;
250 }
251
252 // Get the bytes that result from encoding a character buffer.
253 public unsafe override int GetBytesImpl (
254 char* chars, int charCount, byte* bytes, int byteCount, bool refresh)
255 {
256 int charIndex = 0;
257 int byteIndex = 0;
258
259 // Convert the characters into their byte form.
260 int posn = byteIndex;
261 int byteLength = byteCount;
262 int ch, value;
263
264 byte[] cjkToJis = JISConvert.Convert.cjkToJis;
265 byte[] greekToJis = JISConvert.Convert.greekToJis;
266 byte[] extraToJis = JISConvert.Convert.extraToJis;
267
268 for (; charCount > 0; charIndex++, --charCount) {
269 ch = chars [charIndex];
270 if (posn >= byteLength) {
271 throw new ArgumentException (Strings.GetString ("Arg_InsufficientSpace"), "bytes");
272 }
273
274 if (ch < 0x0080) {
275 // Character maps to itself.
276 bytes[posn++] = (byte)ch;
277 continue;
278 } else if (ch >= 0x0391 && ch <= 0x0451) {
279 // Greek subset characters.
280 value = (ch - 0x0391) * 2;
281 value = ((int)(greekToJis[value])) |
282 (((int)(greekToJis[value + 1])) << 8);
283 } else if (ch >= 0x2010 && ch <= 0x9FA5) {
284 // This range contains the bulk of the CJK set.
285 value = (ch - 0x2010) * 2;
286 value = ((int) (cjkToJis[value])) |
287 (((int)(cjkToJis[value + 1])) << 8);
288 } else if (ch >= 0xFF01 && ch <= 0xFF60) {
289 // This range contains extra characters,
290 // including half-width katakana.
291 value = (ch - 0xFF01) * 2;
292 value = ((int) (extraToJis [value])) |
293 (((int) (extraToJis [value + 1])) << 8);
294 } else if (ch >= 0xFF60 && ch <= 0xFFA0) {
295 value = ch - 0xFF60 + 0x8EA0;
296 } else {
297 // Invalid character.
298 value = 0;
299 }
300
301 if (value == 0) {
302 #if NET_2_0
303 HandleFallback (
304 chars, ref charIndex, ref charCount,
305 bytes, ref posn, ref byteCount);
306 #else
307 bytes [posn++] = (byte) '?';
308 #endif
309 } else if (value < 0x0100) {
310 bytes [posn++] = (byte) value;
311 } else if ((posn + 1) >= byteLength) {
312 throw new ArgumentException (Strings.GetString ("Arg_InsufficientSpace"), "bytes");
313 } else if (value < 0x8000) {
314 // general 2byte glyph/kanji
315 value -= 0x0100;
316 bytes [posn++] = (byte) (value / 0x5E + 0xA1);
317 bytes [posn++] = (byte) (value % 0x5E + 0xA1);
318 //Console.WriteLine ("{0:X04}", ch);
319 continue;
320 }
321 else
322 {
323 // half-width kana
324 bytes [posn++] = 0x8E;
325 bytes [posn++] = (byte) (value - 0x8E00);
326 }
327 }
328
329 // Return the final length to the caller.
330 return posn - byteIndex;
331 }
332 } // CP51932Encoder
333
334 internal class CP51932Decoder : DbcsEncoding.DbcsDecoder
335 {
336 public CP51932Decoder ()
337 : base (null)
338 {
339 }
340
341 int last_count, last_bytes;
342
343 // Get the number of characters needed to decode a byte buffer.
344 public override int GetCharCount (byte [] bytes, int index, int count)
345 {
346 return GetCharCount (bytes, index, count, false);
347 }
348
349 #if NET_2_0
350 public override
351 #else
352 internal
353 #endif
354 int GetCharCount (byte [] bytes, int index, int count, bool refresh)
355 {
356 CheckRange (bytes, index, count);
357
358 // Determine the total length of the converted string.
359 int value = 0;
360 byte[] table0208 = JISConvert.Convert.jisx0208ToUnicode;
361 byte[] table0212 = JISConvert.Convert.jisx0212ToUnicode;
362 int length = 0;
363 int byteval = 0;
364 int last = last_count;
365
366 while (count > 0) {
367 byteval = bytes [index++];
368 --count;
369 if (last == 0) {
370 if (byteval == 0x8F) {
371 if (byteval != 0) {
372 // Invalid second byte of a 3-byte character.
373 last = 0;
374 length++;
375 }
376 // First byte in a triple-byte sequence
377 else
378 last = byteval;
379 } else if (byteval <= 0x7F) {
380 // Ordinary ASCII/Latin1/Control character.
381 length++;
382 } else if (byteval == 0x8E) {
383 // First byte of half-width Katakana
384 last = byteval;
385 } else if (byteval >= 0xA1 && byteval <= 0xFE) {
386 // First byte in a double-byte sequence.
387 last = byteval;
388 } else {
389 // Invalid first byte.
390 length++;
391 }
392 }
393 else if (last == 0x8E) {
394 if (byteval >= 0xA1 && byteval <= 0xDF) {
395 value = ((byteval - 0x40) |
396 (last + 0x71) << 8);
397 length++;
398 } else {
399 // Invalid second byte.
400 length++;
401 }
402 last =0;
403 }
404 else if (last == 0x8F) {
405 // 3-byte character
406 // FIXME: currently not supported yet
407 last = byteval;
408 }
409 else
410 {
411 // Second byte in a double-byte sequence.
412 value = (last - 0xA1) * 0x5E;
413 last = 0;
414 if (byteval >= 0xA1 && byteval <= 0xFE)
415 {
416 value += (byteval - 0xA1);
417 }
418 else
419 {
420 // Invalid second byte.
421 last = 0;
422 length++;
423 continue;
424 }
425
426 value *= 2;
427 value = ((int) (table0208 [value]))
428 | (((int) (table0208 [value + 1])) << 8);
429 if (value == 0)
430 value = ((int) (table0212 [value]))
431 | (((int) (table0212 [value + 1])) << 8);
432 if (value != 0)
433 length++;
434 else
435 length++;
436 }
437 }
438
439 // seems like .NET 2.0 adds \u30FB for insufficient
440 // byte seuqence (for Japanese \u30FB makes sense).
441 if (refresh && last != 0)
442 length++;
443 else
444 last_count = last;
445
446 // Return the final length to the caller.
447 return length;
448 }
449
450 public override int GetChars (byte[] bytes, int byteIndex,
451 int byteCount, char[] chars,
452 int charIndex)
453 {
454 return GetChars (bytes, byteIndex, byteCount, chars, charIndex, false);
455 }
456
457 #if NET_2_0
458 public override
459 #else
460 internal
461 #endif
462 int GetChars (byte[] bytes, int byteIndex,
463 int byteCount, char[] chars,
464 int charIndex, bool refresh)
465 {
466 CheckRange (bytes, byteIndex, byteCount, chars, charIndex);
467
468 // Decode the bytes in the buffer.
469 int posn = charIndex;
470 int charLength = chars.Length;
471 int byteval, value;
472 int last = last_bytes;
473 byte[] table0208 = JISConvert.Convert.jisx0208ToUnicode;
474 byte[] table0212 = JISConvert.Convert.jisx0212ToUnicode;
475
476 while (byteCount > 0) {
477 byteval = bytes [byteIndex++];
478 --byteCount;
479 if (last == 0) {
480 if (byteval == 0x8F) {
481 if (byteval != 0) {
482 // Invalid second byte of a 3-byte character.
483 last = 0;
484 if (posn >= charLength)
485 throw Insufficient ();
486 chars [posn++] = '\u30FB';
487 }
488 // First byte in a triple-byte sequence
489 else
490 last = byteval;
491 } else if (byteval <= 0x7F) {
492 // Ordinary ASCII/Latin1/Control character.
493 if (posn >= charLength)
494 throw Insufficient ();
495 chars [posn++] = (char) byteval;
496 } else if (byteval == 0x8E) {
497 // First byte of half-width Katakana
498 last = byteval;
499 } else if (byteval >= 0xA1 && byteval <= 0xFE) {
500 // First byte in a double-byte sequence.
501 last = byteval;
502 } else {
503 // Invalid first byte.
504 if (posn >= charLength)
505 throw Insufficient ();
506 chars [posn++] = '\u30FB';
507 }
508 }
509 else if (last == 0x8E) {
510 if (byteval >= 0xA1 && byteval <= 0xDF) {
511 value = ((byteval - 0x40) |
512 (last + 0x71) << 8);
513 if (posn >= charLength)
514 throw Insufficient ();
515 chars [posn++] = (char) value;
516 } else {
517 // Invalid second byte.
518 if (posn >= charLength)
519 throw Insufficient ();
520 chars [posn++] = '\u30FB';
521 }
522 last =0;
523 }
524 else if (last == 0x8F) {
525 // 3-byte character
526 // FIXME: currently not supported yet
527 last = byteval;
528 }
529 else
530 {
531 // Second byte in a double-byte sequence.
532 value = (last - 0xA1) * 0x5E;
533 last = 0;
534 if (byteval >= 0xA1 && byteval <= 0xFE)
535 {
536 value += (byteval - 0xA1);
537 }
538 else
539 {
540 // Invalid second byte.
541 last = 0;
542 if (posn >= charLength)
543 throw Insufficient ();
544 chars [posn++] = '\u30FB';
545 continue;
546 }
547
548 value *= 2;
549 value = ((int) (table0208 [value]))
550 | (((int) (table0208 [value + 1])) << 8);
551 if (value == 0)
552 value = ((int) (table0212 [value]))
553 | (((int) (table0212 [value + 1])) << 8);
554 if (posn >= charLength)
555 throw Insufficient ();
556 if (value != 0)
557 chars [posn++] = (char)value;
558 else
559 chars [posn++] = '\u30FB';
560 }
561 }
562
563 if (refresh && last != 0) {
564 // seems like .NET 2.0 adds \u30FB for insufficient
565 // byte seuqence (for Japanese \u30FB makes sense).
566 if (posn >= charLength)
567 throw Insufficient ();
568 chars [posn++] = '\u30FB';
569 }
570 else
571 last_bytes = last;
572
573 // Return the final length to the caller.
574 return posn - charIndex;
575 }
576
577 Exception Insufficient ()
578 {
579 throw new ArgumentException
580 (Strings.GetString
581 ("Arg_InsufficientSpace"), "chars");
582 }
583 }; // class CP51932Decoder
584
585 [Serializable]
586 public class ENCeuc_jp : CP51932
587 {
588 public ENCeuc_jp () : base() {}
589
590 }; // class ENCeucjp
591
592 }; // namespace I18N.CJK
git-svn mirror of mcs