?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-11-02 Jb Evain <jbevain@novell.com>
[mcs.git] / class / I18N / CJK / CP932.cs
blobe5f81aa7ca87ae0c1983a976cc58f6da74db347c
1 /*
2 * CP932.cs - Japanese (Shift-JIS) code page.
3 *
4 * Copyright (c) 2002 Southern Storm Software, Pty Ltd
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 //
26 // Copyright (C) 2005-2006 Novell, Inc.
27 //
28
29 namespace I18N.CJK
30 {
31
32 using System;
33 using System.Text;
34 using I18N.Common;
35
36 [Serializable]
37 public unsafe class CP932 : MonoEncoding
38 {
39 // Magic number used by Windows for the Shift-JIS code page.
40 private const int SHIFTJIS_CODE_PAGE = 932;
41
42 // Constructor.
43 public CP932() : base(SHIFTJIS_CODE_PAGE)
44 {
45 }
46
47 // Get the number of bytes needed to encode a character buffer.
48 public unsafe override int GetByteCountImpl (char* chars, int count)
49 {
50 int index = 0;
51
52 // Determine the length of the final output.
53 int length = 0;
54 int ch, value;
55 #if __PNET__
56 byte *cjkToJis = JISConvert.Convert.cjkToJis;
57 byte *extraToJis = JISConvert.Convert.extraToJis;
58 #else
59 byte[] cjkToJis = JISConvert.Convert.cjkToJis;
60 byte[] extraToJis = JISConvert.Convert.extraToJis;
61 #endif
62 while(count > 0)
63 {
64 ch = chars[index++];
65 --count;
66 ++length;
67 if(ch < 0x0080)
68 {
69 // Character maps to itself.
70 continue;
71 }
72 else if(ch < 0x0100)
73 {
74 // Check for special Latin 1 characters that
75 // can be mapped to double-byte code points.
76 if(ch == 0x00A2 || ch == 0x00A3 || ch == 0x00A7 ||
77 ch == 0x00A8 || ch == 0x00AC || ch == 0x00B0 ||
78 ch == 0x00B1 || ch == 0x00B4 || ch == 0x00B6 ||
79 ch == 0x00D7 || ch == 0x00F7)
80 {
81 ++length;
82 }
83 }
84 else if(ch >= 0x0391 && ch <= 0x0451)
85 {
86 // Greek subset characters.
87 ++length;
88 }
89 else if(ch >= 0x2010 && ch <= 0x9FA5)
90 {
91 // This range contains the bulk of the CJK set.
92 value = (ch - 0x2010) * 2;
93 value = ((int)(cjkToJis[value])) |
94 (((int)(cjkToJis[value + 1])) << 8);
95 if(value >= 0x0100)
96 {
97 ++length;
98 }
99 }
100 else if(ch >= 0xE000 && ch <= 0xE757)
101 // PrivateUse
102 ++length;
103 else if(ch >= 0xFF01 && ch <= 0xFFEF)
104 {
105 // This range contains extra characters,
106 // including half-width katakana.
107 value = (ch - 0xFF01) * 2;
108 value = ((int)(extraToJis[value])) |
109 (((int)(extraToJis[value + 1])) << 8);
110 if(value >= 0x0100)
111 {
112 ++length;
113 }
114 }
115 }
116
117 // Return the length to the caller.
118 return length;
119 }
120
121 // Get the bytes that result from encoding a character buffer.
122 public unsafe override int GetBytesImpl (
123 char* chars, int charCount, byte* bytes, int byteCount)
124 {
125 int charIndex = 0;
126 int byteIndex = 0;
127 #if NET_2_0
128 EncoderFallbackBuffer buffer = null;
129 #endif
130
131 // Convert the characters into their byte form.
132 int posn = byteIndex;
133 int byteLength = byteCount;
134 int ch, value;
135 #if __PNET__
136 byte *cjkToJis = JISConvert.Convert.cjkToJis;
137 byte *greekToJis = JISConvert.Convert.greekToJis;
138 byte *extraToJis = JISConvert.Convert.extraToJis;
139 #else
140 byte[] cjkToJis = JISConvert.Convert.cjkToJis;
141 byte[] greekToJis = JISConvert.Convert.greekToJis;
142 byte[] extraToJis = JISConvert.Convert.extraToJis;
143 #endif
144 while(charCount > 0)
145 {
146 ch = chars[charIndex++];
147 --charCount;
148 if(posn >= byteLength)
149 {
150 throw new ArgumentException
151 (Strings.GetString("Arg_InsufficientSpace"),
152 "bytes");
153 }
154 if(ch < 0x0080)
155 {
156 // Character maps to itself.
157 bytes[posn++] = (byte)ch;
158 continue;
159 }
160 else if(ch < 0x0100)
161 {
162 // Check for special Latin 1 characters that
163 // can be mapped to double-byte code points.
164 if(ch == 0x00A2 || ch == 0x00A3 || ch == 0x00A7 ||
165 ch == 0x00A8 || ch == 0x00AC || ch == 0x00B0 ||
166 ch == 0x00B1 || ch == 0x00B4 || ch == 0x00B6 ||
167 ch == 0x00D7 || ch == 0x00F7)
168 {
169 if((posn + 1) >= byteLength)
170 {
171 throw new ArgumentException
172 (Strings.GetString
173 ("Arg_InsufficientSpace"), "bytes");
174 }
175 switch(ch)
176 {
177 case 0x00A2:
178 bytes[posn++] = (byte)0x81;
179 bytes[posn++] = (byte)0x91;
180 break;
181
182 case 0x00A3:
183 bytes[posn++] = (byte)0x81;
184 bytes[posn++] = (byte)0x92;
185 break;
186
187 case 0x00A7:
188 bytes[posn++] = (byte)0x81;
189 bytes[posn++] = (byte)0x98;
190 break;
191
192 case 0x00A8:
193 bytes[posn++] = (byte)0x81;
194 bytes[posn++] = (byte)0x4E;
195 break;
196
197 case 0x00AC:
198 bytes[posn++] = (byte)0x81;
199 bytes[posn++] = (byte)0xCA;
200 break;
201
202 case 0x00B0:
203 bytes[posn++] = (byte)0x81;
204 bytes[posn++] = (byte)0x8B;
205 break;
206
207 case 0x00B1:
208 bytes[posn++] = (byte)0x81;
209 bytes[posn++] = (byte)0x7D;
210 break;
211
212 case 0x00B4:
213 bytes[posn++] = (byte)0x81;
214 bytes[posn++] = (byte)0x4C;
215 break;
216
217 case 0x00B6:
218 bytes[posn++] = (byte)0x81;
219 bytes[posn++] = (byte)0xF7;
220 break;
221
222 case 0x00D7:
223 bytes[posn++] = (byte)0x81;
224 bytes[posn++] = (byte)0x7E;
225 break;
226
227 case 0x00F7:
228 bytes[posn++] = (byte)0x81;
229 bytes[posn++] = (byte)0x80;
230 break;
231 }
232 }
233 else if(ch == 0x00A5)
234 {
235 // Yen sign.
236 bytes[posn++] = (byte)0x5C;
237 }
238 else
239 {
240 #if NET_2_0
241 HandleFallback (ref buffer,
242 chars, ref charIndex, ref charCount,
243 bytes, ref posn, ref byteCount);
244 #else
245 // Invalid character.
246 bytes[posn++] = (byte)'?';
247 #endif
248 }
249 continue;
250 }
251 else if(ch >= 0x0391 && ch <= 0x0451)
252 {
253 // Greek subset characters.
254 value = (ch - 0x0391) * 2;
255 value = ((int)(greekToJis[value])) |
256 (((int)(greekToJis[value + 1])) << 8);
257 }
258 else if(ch >= 0x2010 && ch <= 0x9FA5)
259 {
260 // This range contains the bulk of the CJK set.
261 value = (ch - 0x2010) * 2;
262 value = ((int)(cjkToJis[value])) |
263 (((int)(cjkToJis[value + 1])) << 8);
264 }
265 else if(ch >= 0xE000 && ch <= 0xE757)
266 {
267 // PrivateUse
268 int diff = ch - 0xE000;
269 value = ((int) (diff / 0xBC) << 8)
270 + (diff % 0xBC)
271 + 0xF040;
272 if (value % 0x100 >= 0x7F)
273 value++;
274 }
275 else if(ch >= 0xFF01 && ch <= 0xFF60)
276 {
277 value = (ch - 0xFF01) * 2;
278 value = ((int)(extraToJis[value])) |
279 (((int)(extraToJis[value + 1])) << 8);
280 }
281 else if(ch >= 0xFF60 && ch <= 0xFFA0)
282 {
283 value = ch - 0xFF60 + 0xA0;
284 }
285 else
286 {
287 // Invalid character.
288 value = 0;
289 }
290 if(value == 0)
291 {
292 #if NET_2_0
293 HandleFallback (ref buffer,
294 chars, ref charIndex, ref charCount,
295 bytes, ref posn, ref byteCount);
296 #else
297 bytes[posn++] = (byte)'?';
298 #endif
299 }
300 else if(value < 0x0100)
301 {
302 bytes[posn++] = (byte)value;
303 }
304 else if((posn + 1) >= byteLength)
305 {
306 throw new ArgumentException
307 (Strings.GetString("Arg_InsufficientSpace"),
308 "bytes");
309 }
310 else if(value < 0x8000)
311 {
312 // JIS X 0208 character.
313 value -= 0x0100;
314 ch = (value / 0xBC);
315 value = (value % 0xBC) + 0x40;
316 if(value >= 0x7F)
317 {
318 ++value;
319 }
320 if(ch < (0x9F - 0x80))
321 {
322 bytes[posn++] = (byte)(ch + 0x81);
323 }
324 else
325 {
326 bytes[posn++] = (byte)(ch - (0x9F - 0x80) + 0xE0);
327 }
328 bytes[posn++] = (byte)value;
329 }
330 else if (value >= 0xF040 && value <= 0xF9FC)
331 {
332 // PrivateUse
333 bytes[posn++] = (byte) (value / 0x100);
334 bytes[posn++] = (byte) (value % 0x100);
335 }
336 else
337 {
338 // JIS X 0212 character, which Shift-JIS doesn't
339 // support, but we've already allocated two slots.
340 bytes[posn++] = (byte)'?';
341 bytes[posn++] = (byte)'?';
342 }
343 }
344
345 // Return the final length to the caller.
346 return posn - byteIndex;
347 }
348
349 public override int GetCharCount (byte [] bytes, int index, int count)
350 {
351 return new CP932Decoder (JISConvert.Convert).GetCharCount (
352 bytes, index, count, true);
353 }
354
355 public override int GetChars (
356 byte [] bytes, int byteIndex, int byteCount,
357 char [] chars, int charIndex)
358 {
359 return new CP932Decoder (JISConvert.Convert).GetChars (bytes,
360 byteIndex, byteCount, chars, charIndex,
361 true);
362 }
363
364 // Get the maximum number of bytes needed to encode a
365 // specified number of characters.
366 public override int GetMaxByteCount(int charCount)
367 {
368 if(charCount < 0)
369 {
370 throw new ArgumentOutOfRangeException
371 ("charCount",
372 Strings.GetString("ArgRange_NonNegative"));
373 }
374 return charCount * 2;
375 }
376
377 // Get the maximum number of characters needed to decode a
378 // specified number of bytes.
379 public override int GetMaxCharCount(int byteCount)
380 {
381 if(byteCount < 0)
382 {
383 throw new ArgumentOutOfRangeException
384 ("byteCount",
385 Strings.GetString("ArgRange_NonNegative"));
386 }
387 return byteCount;
388 }
389
390 // Get a decoder that handles a rolling Shift-JIS state.
391 public override Decoder GetDecoder()
392 {
393 return new CP932Decoder(JISConvert.Convert);
394 }
395
396 #if !ECMA_COMPAT
397
398 // Get the mail body name for this encoding.
399 public override String BodyName {
400 get { return "iso-2022-jp"; }
401 }
402
403 // Get the human-readable name for this encoding.
404 public override String EncodingName {
405 get { return "Japanese (Shift-JIS)"; }
406 }
407
408 // Get the mail agent header name for this encoding.
409 public override String HeaderName {
410 get { return "iso-2022-jp"; }
411 }
412
413 // Determine if this encoding can be displayed in a Web browser.
414 public override bool IsBrowserDisplay {
415 get { return true; }
416 }
417
418 // Determine if this encoding can be saved from a Web browser.
419 public override bool IsBrowserSave {
420 get { return true; }
421 }
422
423 // Determine if this encoding can be displayed in a mail/news agent.
424 public override bool IsMailNewsDisplay {
425 get { return true; }
426 }
427
428 // Determine if this encoding can be saved from a mail/news agent.
429 public override bool IsMailNewsSave {
430 get { return true; }
431 }
432
433 // Get the IANA-preferred Web name for this encoding.
434 public override String WebName {
435 get { return "shift_jis"; }
436 }
437
438 // Get the Windows code page represented by this object.
439 public override int WindowsCodePage {
440 get { return SHIFTJIS_CODE_PAGE; }
441 }
442
443 }; // class CP932
444
445 #endif // !ECMA_COMPAT
446
447 // Decoder that handles a rolling Shift-JIS state.
448 sealed class CP932Decoder : DbcsEncoding.DbcsDecoder
449 {
450 private JISConvert convert;
451 private int last_byte_count;
452 private int last_byte_chars;
453
454 // Constructor.
455 public CP932Decoder(JISConvert convert)
456 : base (null)
457 {
458 this.convert = convert;
459 }
460
461 // Override inherited methods.
462
463 public override int GetCharCount (
464 byte [] bytes, int index, int count)
465 {
466 return GetCharCount (bytes, index, count, false);
467 }
468
469 public
470 #if NET_2_0
471 override
472 #endif
473 int GetCharCount (byte [] bytes, int index, int count, bool refresh)
474 {
475 CheckRange (bytes, index, count);
476
477 // Determine the total length of the converted string.
478 int length = 0;
479 int byteval;
480 int last = last_byte_count;
481 while(count > 0)
482 {
483 byteval = bytes[index++];
484 --count;
485 if(last == 0)
486 {
487 if((byteval >= 0x81 && byteval <= 0x9F) ||
488 (byteval >= 0xE0 && byteval <= 0xEF))
489 {
490 // First byte in a double-byte sequence.
491 last = byteval;
492 }
493 ++length;
494 }
495 else
496 {
497 // Second byte in a double-byte sequence.
498 last = 0;
499 }
500 }
501 if (refresh) {
502 if (last != 0)
503 length++;
504 last_byte_count = '\0';
505 }
506 else
507 last_byte_count = last;
508
509 // Return the total length.
510 return length;
511 }
512
513 public override int GetChars (
514 byte [] bytes, int byteIndex, int byteCount,
515 char [] chars, int charIndex)
516 {
517 return GetChars (bytes, byteIndex, byteCount,
518 chars, charIndex, false);
519 }
520
521 public
522 #if NET_2_0
523 override
524 #endif
525 int GetChars (
526 byte [] bytes, int byteIndex, int byteCount,
527 char [] chars, int charIndex, bool refresh)
528 {
529 CheckRange (bytes, byteIndex, byteCount,
530 chars, charIndex);
531
532 // Decode the bytes in the buffer.
533 int posn = charIndex;
534 int charLength = chars.Length;
535 int byteval, value;
536 int last = last_byte_chars;
537 #if __PNET__
538 byte *table = convert.jisx0208ToUnicode;
539 #else
540 byte[] table = convert.jisx0208ToUnicode;
541 #endif
542 while(byteCount > 0)
543 {
544 byteval = bytes[byteIndex++];
545 --byteCount;
546 if(last == 0)
547 {
548 if(posn >= charLength)
549 {
550 throw new ArgumentException
551 (Strings.GetString
552 ("Arg_InsufficientSpace"), "chars");
553 }
554 if((byteval >= 0x81 && byteval <= 0x9F) ||
555 (byteval >= 0xE0 && byteval <= 0xEF))
556 {
557 // First byte in a double-byte sequence.
558 last = byteval;
559 }
560 else if(byteval < 0x80)
561 {
562 // Ordinary ASCII/Latin1 character.
563 chars[posn++] = (char)byteval;
564 }
565 else if(byteval >= 0xA1 && byteval <= 0xDF)
566 {
567 // Half-width katakana character.
568 chars[posn++] = (char)(byteval - 0xA1 + 0xFF61);
569 }
570 else
571 {
572 // Invalid first byte.
573 chars[posn++] = '?';
574 }
575 }
576 else
577 {
578 // Second byte in a double-byte sequence.
579 if(last >= 0x81 && last <= 0x9F)
580 {
581 value = (last - 0x81) * 0xBC;
582 }
583 else if (last >= 0xF0 && last <= 0xFC && byteval <= 0xFC)
584 {
585 // PrivateUse
586 value = 0xE000 + (last - 0xF0) * 0xBC + byteval;
587 if (byteval > 0x7F)
588 value--;
589 }
590 else
591 {
592 value = (last - 0xE0 + (0xA0 - 0x81)) * 0xBC;
593 }
594 last = 0;
595 if(byteval >= 0x40 && byteval <= 0x7E)
596 {
597 value += (byteval - 0x40);
598 }
599 else if(byteval >= 0x80 && byteval <= 0xFC)
600 {
601 value += (byteval - 0x80 + 0x3F);
602 }
603 else
604 {
605 // Invalid second byte.
606 chars[posn++] = '?';
607 continue;
608 }
609 value *= 2;
610 value = ((int)(table[value])) |
611 (((int)(table[value + 1])) << 8);
612 if(value != 0)
613 {
614 chars[posn++] = (char)value;
615 }
616 else
617 {
618 chars[posn++] = '?';
619 }
620 }
621 }
622 if (refresh) {
623 if (last != 0)
624 chars[posn++] = '\u30FB';
625 last_byte_chars = '\0';
626 }
627 else
628 last_byte_chars = last;
629
630 // Return the final length to the caller.
631 return posn - charIndex;
632 }
633
634 } // class CP932Decoder
635
636 [Serializable]
637 public class ENCshift_jis : CP932
638 {
639 public ENCshift_jis() : base() {}
640
641 }; // class ENCshift_jis
642
643 }; // namespace I18N.CJK
git-svn mirror of mcs