PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
euc_jp_and_sjis.c File Reference
#include "postgres.h"
#include "fmgr.h"
#include "mb/pg_wchar.h"
#include "sjis.map"
Include dependency graph for euc_jp_and_sjis.c:

Go to the source code of this file.

Macros

#define PGSJISALTCODE   0x81ac
 
#define PGEUCALTCODE   0xa2ae
 

Functions

 PG_FUNCTION_INFO_V1 (euc_jp_to_sjis)
 
 PG_FUNCTION_INFO_V1 (sjis_to_euc_jp)
 
 PG_FUNCTION_INFO_V1 (euc_jp_to_mic)
 
 PG_FUNCTION_INFO_V1 (mic_to_euc_jp)
 
 PG_FUNCTION_INFO_V1 (sjis_to_mic)
 
 PG_FUNCTION_INFO_V1 (mic_to_sjis)
 
static int sjis2mic (const unsigned char *sjis, unsigned char *p, int len, bool noError)
 
static int mic2sjis (const unsigned char *mic, unsigned char *p, int len, bool noError)
 
static int euc_jp2mic (const unsigned char *euc, unsigned char *p, int len, bool noError)
 
static int mic2euc_jp (const unsigned char *mic, unsigned char *p, int len, bool noError)
 
static int euc_jp2sjis (const unsigned char *euc, unsigned char *p, int len, bool noError)
 
static int sjis2euc_jp (const unsigned char *sjis, unsigned char *p, int len, bool noError)
 
Datum euc_jp_to_sjis (PG_FUNCTION_ARGS)
 
Datum sjis_to_euc_jp (PG_FUNCTION_ARGS)
 
Datum euc_jp_to_mic (PG_FUNCTION_ARGS)
 
Datum mic_to_euc_jp (PG_FUNCTION_ARGS)
 
Datum sjis_to_mic (PG_FUNCTION_ARGS)
 
Datum mic_to_sjis (PG_FUNCTION_ARGS)
 

Variables

 PG_MODULE_MAGIC
 

Macro Definition Documentation

◆ PGEUCALTCODE

#define PGEUCALTCODE   0xa2ae

Definition at line 23 of file euc_jp_and_sjis.c.

◆ PGSJISALTCODE

#define PGSJISALTCODE   0x81ac

Definition at line 22 of file euc_jp_and_sjis.c.

Function Documentation

◆ euc_jp2mic()

static int euc_jp2mic ( const unsigned char *  euc,
unsigned char *  p,
int  len,
bool  noError 
)
static

Definition at line 406 of file euc_jp_and_sjis.c.

407{
408 const unsigned char *start = euc;
409 int c1;
410 int l;
411
412 while (len > 0)
413 {
414 c1 = *euc;
415 if (!IS_HIGHBIT_SET(c1))
416 {
417 /* ASCII */
418 if (c1 == 0)
419 {
420 if (noError)
421 break;
423 (const char *) euc, len);
424 }
425 *p++ = c1;
426 euc++;
427 len--;
428 continue;
429 }
430 l = pg_encoding_verifymbchar(PG_EUC_JP, (const char *) euc, len);
431 if (l < 0)
432 {
433 if (noError)
434 break;
436 (const char *) euc, len);
437 }
438 if (c1 == SS2)
439 { /* 1 byte kana? */
440 *p++ = LC_JISX0201K;
441 *p++ = euc[1];
442 }
443 else if (c1 == SS3)
444 { /* JIS X0212 kanji? */
445 *p++ = LC_JISX0212;
446 *p++ = euc[1];
447 *p++ = euc[2];
448 }
449 else
450 { /* kanji? */
451 *p++ = LC_JISX0208;
452 *p++ = c1;
453 *p++ = euc[1];
454 }
455 euc += l;
456 len -= l;
457 }
458 *p = '\0';
459
460 return euc - start;
461}
#define IS_HIGHBIT_SET(ch)
Definition: c.h:1112
return str start
void report_invalid_encoding(int encoding, const char *mbstr, int len)
Definition: mbutils.c:1698
const void size_t len
@ PG_EUC_JP
Definition: pg_wchar.h:227
#define SS2
Definition: pg_wchar.h:38
#define LC_JISX0208
Definition: pg_wchar.h:134
#define LC_JISX0212
Definition: pg_wchar.h:136
#define LC_JISX0201K
Definition: pg_wchar.h:113
#define SS3
Definition: pg_wchar.h:39
int pg_encoding_verifymbchar(int encoding, const char *mbstr, int len)
Definition: wchar.c:2103

References IS_HIGHBIT_SET, LC_JISX0201K, LC_JISX0208, LC_JISX0212, len, pg_encoding_verifymbchar(), PG_EUC_JP, report_invalid_encoding(), SS2, SS3, and start.

Referenced by euc_jp_to_mic().

◆ euc_jp2sjis()

static int euc_jp2sjis ( const unsigned char *  euc,
unsigned char *  p,
int  len,
bool  noError 
)
static

Definition at line 534 of file euc_jp_and_sjis.c.

535{
536 const unsigned char *start = euc;
537 int c1,
538 c2,
539 k;
540 int l;
541
542 while (len > 0)
543 {
544 c1 = *euc;
545 if (!IS_HIGHBIT_SET(c1))
546 {
547 /* ASCII */
548 if (c1 == 0)
549 {
550 if (noError)
551 break;
553 (const char *) euc, len);
554 }
555 *p++ = c1;
556 euc++;
557 len--;
558 continue;
559 }
560 l = pg_encoding_verifymbchar(PG_EUC_JP, (const char *) euc, len);
561 if (l < 0)
562 {
563 if (noError)
564 break;
566 (const char *) euc, len);
567 }
568 if (c1 == SS2)
569 {
570 /* hankaku kana? */
571 *p++ = euc[1];
572 }
573 else if (c1 == SS3)
574 {
575 /* JIS X0212 kanji? */
576 c1 = euc[1];
577 c2 = euc[2];
578 k = c1 << 8 | c2;
579 if (k >= 0xf5a1)
580 {
581 /* UDC2 */
582 c1 -= 0x54;
583 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x74;
584 *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
585 }
586 else
587 {
588 int i,
589 k2;
590
591 /* IBM kanji */
592 for (i = 0;; i++)
593 {
594 k2 = ibmkanji[i].euc & 0xffff;
595 if (k2 == 0xffff)
596 {
597 *p++ = PGSJISALTCODE >> 8;
598 *p++ = PGSJISALTCODE & 0xff;
599 break;
600 }
601 if (k2 == k)
602 {
603 k = ibmkanji[i].sjis;
604 *p++ = k >> 8;
605 *p++ = k & 0xff;
606 break;
607 }
608 }
609 }
610 }
611 else
612 {
613 /* JIS X0208 kanji? */
614 c2 = euc[1];
615 k = (c1 << 8) | (c2 & 0xff);
616 if (k >= 0xf5a1)
617 {
618 /* UDC1 */
619 c1 -= 0x54;
620 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x6f;
621 }
622 else
623 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1);
624 *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
625 }
626 euc += l;
627 len -= l;
628 }
629 *p = '\0';
630
631 return euc - start;
632}
#define PGSJISALTCODE
int i
Definition: isn.c:72

References i, IS_HIGHBIT_SET, len, pg_encoding_verifymbchar(), PG_EUC_JP, PGSJISALTCODE, report_invalid_encoding(), SS2, SS3, and start.

Referenced by euc_jp_to_sjis().

◆ euc_jp_to_mic()

Datum euc_jp_to_mic ( PG_FUNCTION_ARGS  )

Definition at line 93 of file euc_jp_and_sjis.c.

94{
95 unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
96 unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
97 int len = PG_GETARG_INT32(4);
98 bool noError = PG_GETARG_BOOL(5);
99 int converted;
100
102
103 converted = euc_jp2mic(src, dest, len, noError);
104
105 PG_RETURN_INT32(converted);
106}
static int euc_jp2mic(const unsigned char *euc, unsigned char *p, int len, bool noError)
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:277
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274
@ PG_MULE_INTERNAL
Definition: pg_wchar.h:233
#define CHECK_ENCODING_CONVERSION_ARGS(srcencoding, destencoding)
Definition: pg_wchar.h:507

References CHECK_ENCODING_CONVERSION_ARGS, generate_unaccent_rules::dest, euc_jp2mic(), len, PG_EUC_JP, PG_GETARG_BOOL, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_MULE_INTERNAL, and PG_RETURN_INT32.

◆ euc_jp_to_sjis()

Datum euc_jp_to_sjis ( PG_FUNCTION_ARGS  )

Definition at line 61 of file euc_jp_and_sjis.c.

62{
63 unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
64 unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
65 int len = PG_GETARG_INT32(4);
66 bool noError = PG_GETARG_BOOL(5);
67 int converted;
68
70
71 converted = euc_jp2sjis(src, dest, len, noError);
72
73 PG_RETURN_INT32(converted);
74}
static int euc_jp2sjis(const unsigned char *euc, unsigned char *p, int len, bool noError)
@ PG_SJIS
Definition: pg_wchar.h:264

References CHECK_ENCODING_CONVERSION_ARGS, generate_unaccent_rules::dest, euc_jp2sjis(), len, PG_EUC_JP, PG_GETARG_BOOL, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_RETURN_INT32, and PG_SJIS.

◆ mic2euc_jp()

static int mic2euc_jp ( const unsigned char *  mic,
unsigned char *  p,
int  len,
bool  noError 
)
static

Definition at line 467 of file euc_jp_and_sjis.c.

468{
469 const unsigned char *start = mic;
470 int c1;
471 int l;
472
473 while (len > 0)
474 {
475 c1 = *mic;
476 if (!IS_HIGHBIT_SET(c1))
477 {
478 /* ASCII */
479 if (c1 == 0)
480 {
481 if (noError)
482 break;
484 (const char *) mic, len);
485 }
486 *p++ = c1;
487 mic++;
488 len--;
489 continue;
490 }
491 l = pg_encoding_verifymbchar(PG_MULE_INTERNAL, (const char *) mic, len);
492 if (l < 0)
493 {
494 if (noError)
495 break;
497 (const char *) mic, len);
498 }
499 if (c1 == LC_JISX0201K)
500 {
501 *p++ = SS2;
502 *p++ = mic[1];
503 }
504 else if (c1 == LC_JISX0212)
505 {
506 *p++ = SS3;
507 *p++ = mic[1];
508 *p++ = mic[2];
509 }
510 else if (c1 == LC_JISX0208)
511 {
512 *p++ = mic[1];
513 *p++ = mic[2];
514 }
515 else
516 {
517 if (noError)
518 break;
520 (const char *) mic, len);
521 }
522 mic += l;
523 len -= l;
524 }
525 *p = '\0';
526
527 return mic - start;
528}
void report_untranslatable_char(int src_encoding, int dest_encoding, const char *mbstr, int len)
Definition: mbutils.c:1730

References IS_HIGHBIT_SET, LC_JISX0201K, LC_JISX0208, LC_JISX0212, len, pg_encoding_verifymbchar(), PG_EUC_JP, PG_MULE_INTERNAL, report_invalid_encoding(), report_untranslatable_char(), SS2, SS3, and start.

Referenced by mic_to_euc_jp().

◆ mic2sjis()

static int mic2sjis ( const unsigned char *  mic,
unsigned char *  p,
int  len,
bool  noError 
)
static

Definition at line 299 of file euc_jp_and_sjis.c.

300{
301 const unsigned char *start = mic;
302 int c1,
303 c2,
304 k,
305 l;
306
307 while (len > 0)
308 {
309 c1 = *mic;
310 if (!IS_HIGHBIT_SET(c1))
311 {
312 /* ASCII */
313 if (c1 == 0)
314 {
315 if (noError)
316 break;
318 (const char *) mic, len);
319 }
320 *p++ = c1;
321 mic++;
322 len--;
323 continue;
324 }
325 l = pg_encoding_verifymbchar(PG_MULE_INTERNAL, (const char *) mic, len);
326 if (l < 0)
327 {
328 if (noError)
329 break;
331 (const char *) mic, len);
332 }
333 if (c1 == LC_JISX0201K)
334 *p++ = mic[1];
335 else if (c1 == LC_JISX0208)
336 {
337 c1 = mic[1];
338 c2 = mic[2];
339 k = (c1 << 8) | (c2 & 0xff);
340 if (k >= 0xf5a1)
341 {
342 /* UDC1 */
343 c1 -= 0x54;
344 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x6f;
345 }
346 else
347 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1);
348 *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
349 }
350 else if (c1 == LC_JISX0212)
351 {
352 int i,
353 k2;
354
355 c1 = mic[1];
356 c2 = mic[2];
357 k = c1 << 8 | c2;
358 if (k >= 0xf5a1)
359 {
360 /* UDC2 */
361 c1 -= 0x54;
362 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x74;
363 *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
364 }
365 else
366 {
367 /* IBM kanji */
368 for (i = 0;; i++)
369 {
370 k2 = ibmkanji[i].euc & 0xffff;
371 if (k2 == 0xffff)
372 {
373 *p++ = PGSJISALTCODE >> 8;
374 *p++ = PGSJISALTCODE & 0xff;
375 break;
376 }
377 if (k2 == k)
378 {
379 k = ibmkanji[i].sjis;
380 *p++ = k >> 8;
381 *p++ = k & 0xff;
382 break;
383 }
384 }
385 }
386 }
387 else
388 {
389 if (noError)
390 break;
392 (const char *) mic, len);
393 }
394 mic += l;
395 len -= l;
396 }
397 *p = '\0';
398
399 return mic - start;
400}

References i, IS_HIGHBIT_SET, LC_JISX0201K, LC_JISX0208, LC_JISX0212, len, pg_encoding_verifymbchar(), PG_MULE_INTERNAL, PG_SJIS, PGSJISALTCODE, report_invalid_encoding(), report_untranslatable_char(), and start.

Referenced by mic_to_sjis().

◆ mic_to_euc_jp()

Datum mic_to_euc_jp ( PG_FUNCTION_ARGS  )

Definition at line 109 of file euc_jp_and_sjis.c.

110{
111 unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
112 unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
113 int len = PG_GETARG_INT32(4);
114 bool noError = PG_GETARG_BOOL(5);
115 int converted;
116
118
119 converted = mic2euc_jp(src, dest, len, noError);
120
121 PG_RETURN_INT32(converted);
122}
static int mic2euc_jp(const unsigned char *mic, unsigned char *p, int len, bool noError)

References CHECK_ENCODING_CONVERSION_ARGS, generate_unaccent_rules::dest, len, mic2euc_jp(), PG_EUC_JP, PG_GETARG_BOOL, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_MULE_INTERNAL, and PG_RETURN_INT32.

◆ mic_to_sjis()

Datum mic_to_sjis ( PG_FUNCTION_ARGS  )

Definition at line 141 of file euc_jp_and_sjis.c.

142{
143 unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
144 unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
145 int len = PG_GETARG_INT32(4);
146 bool noError = PG_GETARG_BOOL(5);
147 int converted;
148
150
151 converted = mic2sjis(src, dest, len, noError);
152
153 PG_RETURN_INT32(converted);
154}
static int mic2sjis(const unsigned char *mic, unsigned char *p, int len, bool noError)

References CHECK_ENCODING_CONVERSION_ARGS, generate_unaccent_rules::dest, len, mic2sjis(), PG_GETARG_BOOL, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_MULE_INTERNAL, PG_RETURN_INT32, and PG_SJIS.

◆ PG_FUNCTION_INFO_V1() [1/6]

PG_FUNCTION_INFO_V1 ( euc_jp_to_mic  )

◆ PG_FUNCTION_INFO_V1() [2/6]

PG_FUNCTION_INFO_V1 ( euc_jp_to_sjis  )

◆ PG_FUNCTION_INFO_V1() [3/6]

PG_FUNCTION_INFO_V1 ( mic_to_euc_jp  )

◆ PG_FUNCTION_INFO_V1() [4/6]

PG_FUNCTION_INFO_V1 ( mic_to_sjis  )

◆ PG_FUNCTION_INFO_V1() [5/6]

PG_FUNCTION_INFO_V1 ( sjis_to_euc_jp  )

◆ PG_FUNCTION_INFO_V1() [6/6]

PG_FUNCTION_INFO_V1 ( sjis_to_mic  )

◆ sjis2euc_jp()

static int sjis2euc_jp ( const unsigned char *  sjis,
unsigned char *  p,
int  len,
bool  noError 
)
static

Definition at line 638 of file euc_jp_and_sjis.c.

639{
640 const unsigned char *start = sjis;
641 int c1,
642 c2,
643 i,
644 k,
645 k2;
646 int l;
647
648 while (len > 0)
649 {
650 c1 = *sjis;
651 if (!IS_HIGHBIT_SET(c1))
652 {
653 /* ASCII */
654 if (c1 == 0)
655 {
656 if (noError)
657 break;
659 (const char *) sjis, len);
660 }
661 *p++ = c1;
662 sjis++;
663 len--;
664 continue;
665 }
666 l = pg_encoding_verifymbchar(PG_SJIS, (const char *) sjis, len);
667 if (l < 0)
668 {
669 if (noError)
670 break;
672 (const char *) sjis, len);
673 }
674 if (c1 >= 0xa1 && c1 <= 0xdf)
675 {
676 /* JIS X0201 (1 byte kana) */
677 *p++ = SS2;
678 *p++ = c1;
679 }
680 else
681 {
682 /*
683 * JIS X0208, X0212, user defined extended characters
684 */
685 c2 = sjis[1];
686 k = (c1 << 8) + c2;
687 if (k >= 0xed40 && k < 0xf040)
688 {
689 /* NEC selection IBM kanji */
690 for (i = 0;; i++)
691 {
692 k2 = ibmkanji[i].nec;
693 if (k2 == 0xffff)
694 break;
695 if (k2 == k)
696 {
697 k = ibmkanji[i].sjis;
698 c1 = (k >> 8) & 0xff;
699 c2 = k & 0xff;
700 }
701 }
702 }
703
704 if (k < 0xeb3f)
705 {
706 /* JIS X0208 */
707 *p++ = ((c1 & 0x3f) << 1) + 0x9f + (c2 > 0x9e);
708 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
709 }
710 else if ((k >= 0xeb40 && k < 0xf040) || (k >= 0xfc4c && k <= 0xfcfc))
711 {
712 /* NEC selection IBM kanji - Other undecided justice */
713 *p++ = PGEUCALTCODE >> 8;
714 *p++ = PGEUCALTCODE & 0xff;
715 }
716 else if (k >= 0xf040 && k < 0xf540)
717 {
718 /*
719 * UDC1 mapping to X0208 85 ku - 94 ku JIS code 0x7521 -
720 * 0x7e7e EUC 0xf5a1 - 0xfefe
721 */
722 c1 -= 0x6f;
723 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
724 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
725 }
726 else if (k >= 0xf540 && k < 0xfa40)
727 {
728 /*
729 * UDC2 mapping to X0212 85 ku - 94 ku JIS code 0x7521 -
730 * 0x7e7e EUC 0x8ff5a1 - 0x8ffefe
731 */
732 *p++ = SS3;
733 c1 -= 0x74;
734 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
735 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
736 }
737 else if (k >= 0xfa40)
738 {
739 /*
740 * mapping IBM kanji to X0208 and X0212
741 *
742 */
743 for (i = 0;; i++)
744 {
745 k2 = ibmkanji[i].sjis;
746 if (k2 == 0xffff)
747 break;
748 if (k2 == k)
749 {
750 k = ibmkanji[i].euc;
751 if (k >= 0x8f0000)
752 {
753 *p++ = SS3;
754 *p++ = 0x80 | ((k & 0xff00) >> 8);
755 *p++ = 0x80 | (k & 0xff);
756 }
757 else
758 {
759 *p++ = 0x80 | (k >> 8);
760 *p++ = 0x80 | (k & 0xff);
761 }
762 }
763 }
764 }
765 }
766 sjis += l;
767 len -= l;
768 }
769 *p = '\0';
770
771 return sjis - start;
772}
#define PGEUCALTCODE

References i, IS_HIGHBIT_SET, len, pg_encoding_verifymbchar(), PG_SJIS, PGEUCALTCODE, report_invalid_encoding(), SS2, SS3, and start.

Referenced by sjis_to_euc_jp().

◆ sjis2mic()

static int sjis2mic ( const unsigned char *  sjis,
unsigned char *  p,
int  len,
bool  noError 
)
static

Definition at line 160 of file euc_jp_and_sjis.c.

161{
162 const unsigned char *start = sjis;
163 int c1,
164 c2,
165 i,
166 k,
167 k2;
168
169 while (len > 0)
170 {
171 c1 = *sjis;
172 if (c1 >= 0xa1 && c1 <= 0xdf)
173 {
174 /* JIS X0201 (1 byte kana) */
175 *p++ = LC_JISX0201K;
176 *p++ = c1;
177 sjis++;
178 len--;
179 }
180 else if (IS_HIGHBIT_SET(c1))
181 {
182 /*
183 * JIS X0208, X0212, user defined extended characters
184 */
185 if (len < 2 || !ISSJISHEAD(c1) || !ISSJISTAIL(sjis[1]))
186 {
187 if (noError)
188 break;
189 report_invalid_encoding(PG_SJIS, (const char *) sjis, len);
190 }
191 c2 = sjis[1];
192 k = (c1 << 8) + c2;
193 if (k >= 0xed40 && k < 0xf040)
194 {
195 /* NEC selection IBM kanji */
196 for (i = 0;; i++)
197 {
198 k2 = ibmkanji[i].nec;
199 if (k2 == 0xffff)
200 break;
201 if (k2 == k)
202 {
203 k = ibmkanji[i].sjis;
204 c1 = (k >> 8) & 0xff;
205 c2 = k & 0xff;
206 }
207 }
208 }
209
210 if (k < 0xeb3f)
211 {
212 /* JIS X0208 */
213 *p++ = LC_JISX0208;
214 *p++ = ((c1 & 0x3f) << 1) + 0x9f + (c2 > 0x9e);
215 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
216 }
217 else if ((k >= 0xeb40 && k < 0xf040) || (k >= 0xfc4c && k <= 0xfcfc))
218 {
219 /* NEC selection IBM kanji - Other undecided justice */
220 *p++ = LC_JISX0208;
221 *p++ = PGEUCALTCODE >> 8;
222 *p++ = PGEUCALTCODE & 0xff;
223 }
224 else if (k >= 0xf040 && k < 0xf540)
225 {
226 /*
227 * UDC1 mapping to X0208 85 ku - 94 ku JIS code 0x7521 -
228 * 0x7e7e EUC 0xf5a1 - 0xfefe
229 */
230 *p++ = LC_JISX0208;
231 c1 -= 0x6f;
232 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
233 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
234 }
235 else if (k >= 0xf540 && k < 0xfa40)
236 {
237 /*
238 * UDC2 mapping to X0212 85 ku - 94 ku JIS code 0x7521 -
239 * 0x7e7e EUC 0x8ff5a1 - 0x8ffefe
240 */
241 *p++ = LC_JISX0212;
242 c1 -= 0x74;
243 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
244 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
245 }
246 else if (k >= 0xfa40)
247 {
248 /*
249 * mapping IBM kanji to X0208 and X0212
250 */
251 for (i = 0;; i++)
252 {
253 k2 = ibmkanji[i].sjis;
254 if (k2 == 0xffff)
255 break;
256 if (k2 == k)
257 {
258 k = ibmkanji[i].euc;
259 if (k >= 0x8f0000)
260 {
261 *p++ = LC_JISX0212;
262 *p++ = 0x80 | ((k & 0xff00) >> 8);
263 *p++ = 0x80 | (k & 0xff);
264 }
265 else
266 {
267 *p++ = LC_JISX0208;
268 *p++ = 0x80 | (k >> 8);
269 *p++ = 0x80 | (k & 0xff);
270 }
271 }
272 }
273 }
274 sjis += 2;
275 len -= 2;
276 }
277 else
278 { /* should be ASCII */
279 if (c1 == 0)
280 {
281 if (noError)
282 break;
283 report_invalid_encoding(PG_SJIS, (const char *) sjis, len);
284 }
285 *p++ = c1;
286 sjis++;
287 len--;
288 }
289 }
290 *p = '\0';
291
292 return sjis - start;
293}
#define ISSJISTAIL(c)
Definition: pg_wchar.h:45
#define ISSJISHEAD(c)
Definition: pg_wchar.h:44

References i, IS_HIGHBIT_SET, ISSJISHEAD, ISSJISTAIL, LC_JISX0201K, LC_JISX0208, LC_JISX0212, len, PG_SJIS, PGEUCALTCODE, report_invalid_encoding(), and start.

Referenced by sjis_to_mic().

◆ sjis_to_euc_jp()

Datum sjis_to_euc_jp ( PG_FUNCTION_ARGS  )

Definition at line 77 of file euc_jp_and_sjis.c.

78{
79 unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
80 unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
81 int len = PG_GETARG_INT32(4);
82 bool noError = PG_GETARG_BOOL(5);
83 int converted;
84
86
87 converted = sjis2euc_jp(src, dest, len, noError);
88
89 PG_RETURN_INT32(converted);
90}
static int sjis2euc_jp(const unsigned char *sjis, unsigned char *p, int len, bool noError)

References CHECK_ENCODING_CONVERSION_ARGS, generate_unaccent_rules::dest, len, PG_EUC_JP, PG_GETARG_BOOL, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_RETURN_INT32, PG_SJIS, and sjis2euc_jp().

◆ sjis_to_mic()

Datum sjis_to_mic ( PG_FUNCTION_ARGS  )

Definition at line 125 of file euc_jp_and_sjis.c.

126{
127 unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
128 unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
129 int len = PG_GETARG_INT32(4);
130 bool noError = PG_GETARG_BOOL(5);
131 int converted;
132
134
135 converted = sjis2mic(src, dest, len, noError);
136
137 PG_RETURN_INT32(converted);
138}
static int sjis2mic(const unsigned char *sjis, unsigned char *p, int len, bool noError)

References CHECK_ENCODING_CONVERSION_ARGS, generate_unaccent_rules::dest, len, PG_GETARG_BOOL, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_MULE_INTERNAL, PG_RETURN_INT32, PG_SJIS, and sjis2mic().

Variable Documentation

◆ PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 30 of file euc_jp_and_sjis.c.