/src/w3m/libwc/sjis.c

Source (jump to first uncovered line)

#include "wc.h"
#include "sjis.h"
#include "jis.h"
#include "wtf.h"
#include "ucs.h"

#include "map/jisx02132_sjis.map"
wc_uchar *wc_jisx0212_jisx02132_map = jisx02132_sjis_map;

#define C0  WC_SJIS_MAP_C0
#define GL  WC_SJIS_MAP_GL
#define LB  WC_SJIS_MAP_LB
#define S80 WC_SJIS_MAP_80
#define SK  WC_SJIS_MAP_SK
#define SL  WC_SJIS_MAP_SL
#define SH  WC_SJIS_MAP_SH
#define SX  WC_SJIS_MAP_SX
#define C1  WC_SJIS_MAP_C1
#define SA0 WC_SJIS_MAP_A0

wc_uint8 WC_SJIS_MAP[ 0x100 ] = {
    C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
    C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
    GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
    GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
    LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, 
    LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, 
    LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, 
    LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, C0,

    S80,SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL,
    SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL,
    SA0,SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
    SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
    SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
    SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
    SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH,
    SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, C1, C1, C1,
};

#define sjis_to_jisx0208(ub, lb) \
{ \
    ub -= (ub < 0xa0) ? 0x81 : 0xc1; \
    ub = (ub << 1) + 0x21; \
    if (lb < 0x9f) { \
  lb -= (lb > 0x7e) ? 0x20 : 0x1f; \
    } else { \
  ub++; \
  lb -= 0x7e; \
    } \
}
#define sjis_to_jisx02132(ub, lb) \
{ \
    if (lb < 0x9f) { \
  ub = sjis1_jisx02132_map[ub - 0xf0]; \
  lb -= (lb > 0x7e) ? 0x20 : 0x1f; \
    } else { \
  ub = sjis2_jisx02132_map[ub - 0xf0]; \
  lb -= 0x7e; \
    } \
}
#define jisx0208_to_sjis(ub, lb) \
{ \
    lb += (ub & 1) ? 0x1f : 0x7d; \
    if (lb > 0x7e) \
  lb++; \
    ub = (ub - 0x21) >> 1; \
    ub += (ub < 0x1f) ? 0x81 : 0xc1; \
}
#define jisx02132_to_sjis(ub, lb) \
{ \
    lb += (ub & 1) ? 0x1f : 0x7d; \
    if (lb > 0x7e) \
  lb++; \
    ub = jisx02132_sjis_map[ ub ]; \
}

wc_wchar_t
wc_sjis_to_jis(wc_wchar_t cc)
{
    wc_uchar ub, lb;

    ub = cc.code >> 8;
    lb = cc.code & 0xff;
    if (ub < 0xf0) {
  sjis_to_jisx0208(ub, lb);
  cc.ccs = WC_CCS_JIS_X_0208;
    } else {
  sjis_to_jisx02132(ub, lb);
  cc.ccs = WC_CCS_JIS_X_0213_2;
    }
    cc.code = ((wc_uint32)ub << 8) | lb;
    return cc;
}

wc_wchar_t
wc_jis_to_sjis(wc_wchar_t cc)
{
    wc_uchar ub, lb;

    ub = (cc.code >> 8) & 0x7f;
    lb = cc.code & 0x7f;
    if (cc.ccs == WC_CCS_JIS_X_0213_2) {
  jisx02132_to_sjis(ub, lb);
  if (! ub) {
      cc.ccs = WC_CCS_UNKNOWN_W;
      return cc;
  }
    } else {
  jisx0208_to_sjis(ub, lb);
    }
    cc.code = ((wc_uint32)ub << 8) | lb;
    return cc;
}

wc_wchar_t
wc_sjis_ext_to_cs94w(wc_wchar_t cc)
{
    wc_uchar ub, lb;

    ub = cc.code >> 8;
    lb = cc.code & 0xff;
    sjis_to_jisx0208(ub, lb);
    if (ub <= 0x7e) {
  cc.ccs = WC_CCS_SJIS_EXT_1;
    } else {
  ub -= 0x5e;
  cc.ccs = WC_CCS_SJIS_EXT_2;
    }
    cc.code = ((wc_uint32)ub << 8) | lb;
    return cc;
}

wc_wchar_t
wc_cs94w_to_sjis_ext(wc_wchar_t cc)
{
    wc_uchar ub, lb;

    ub = (cc.code >> 8) & 0x7f;
    lb = cc.code & 0x7f;
    if (cc.ccs == WC_CCS_SJIS_EXT_2)
  ub += 0x5e;
    jisx0208_to_sjis(ub, lb);
    cc.ccs = WC_CCS_SJIS_EXT;
    cc.code = ((wc_uint32)ub << 8) | lb;
    return cc;
}

wc_uint32
wc_sjis_ext1_to_N(wc_uint32 c)
{
    wc_uchar ub;

    ub = (c >> 8) & 0x7f;
    switch(ub) {
    case 0x2D:  /* 0x8740 - */
  ub = 0;
  break;
    case 0x79:  /* 0xED40 - */
    case 0x7A:  /* 0xED9F - */
    case 0x7B:  /* 0xEE40 - */
    case 0x7C:  /* 0xEE9F - */
  ub -= 0x78;
  break;
    default:
  return WC_C_SJIS_ERROR;
    }
    return ub * 0x5e + (c & 0x7f) - 0x21;
}

wc_uint32
wc_sjis_ext2_to_N(wc_uint32 c)
{
    wc_uchar ub;

    ub = (c >> 8) & 0x7f;
    switch(ub) {
    case 0x35:  /* 0xFA40 - */
    case 0x36:  /* 0xFA9F - */
    case 0x37:  /* 0xFB40 - */
    case 0x38:  /* 0xFB9F - */
    case 0x39:  /* 0xFC40 - */
  ub -= 0x30;
  break;
    default:
  return WC_C_SJIS_ERROR;
    }
    return ub * 0x5e + (c & 0x7f) - 0x21;
}

Str
wc_conv_from_sjis(Str is, wc_ces ces)
{
    Str os;
    wc_uchar *sp = (wc_uchar *)is->ptr;
    wc_uchar *ep = sp + is->length;
    wc_uchar *p;
    wc_uchar jis[2];
    int state = WC_SJIS_NOSTATE;
    wc_wchar_t cc;

    for (p = sp; p < ep && *p < 0x80; p++)
  ;
    if (p == ep)
  return is;
    os = Strnew_size(is->length);
    if (p > sp)
  Strcat_charp_n(os, is->ptr, (int)(p - sp));

    for (; p < ep; p++) {
  switch (state) {
  case WC_SJIS_NOSTATE:
      switch (WC_SJIS_MAP[*p]) {
      case SL:
    state = WC_SJIS_SHIFT_L;
    break;
      case SH:
    state = WC_SJIS_SHIFT_H;
    break;
      case SX:
    state = WC_SJIS_SHIFT_X;
    break;
      case SK:
    wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)*p);
    break;
      case S80:
      case SA0:
      case C1:
    wtf_push_unknown(os, p, 1);
    break;
      default:
    Strcat_char(os, (char)*p);
    break;
      }
      break;
  case WC_SJIS_SHIFT_L:
  case WC_SJIS_SHIFT_H:
      if (WC_SJIS_MAP[*p] & LB) {
    jis[0] = *(p-1);
    jis[1] = *p;
    sjis_to_jisx0208(jis[0], jis[1]);
    cc.code = ((wc_uint32)jis[0] << 8) | jis[1];
    cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
    if (cc.ccs == WC_CCS_JIS_X_0208)
        wtf_push(os, cc.ccs, cc.code);
    else
        wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)*(p-1) << 8) | *p);
      } else
    wtf_push_unknown(os, p-1, 2);
      state = WC_SJIS_NOSTATE;
      break;
  case WC_SJIS_SHIFT_X:
      if (WC_SJIS_MAP[*p] & LB)
    wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)*(p-1) << 8) | *p);
      else
    wtf_push_unknown(os, p-1, 2);
      state = WC_SJIS_NOSTATE;
      break;
  }
    }
    switch (state) {
    case WC_SJIS_SHIFT_L:
    case WC_SJIS_SHIFT_H:
    case WC_SJIS_SHIFT_X:
  wtf_push_unknown(os, p-1, 1);
  break;
    }
    return os;
}

Str
wc_conv_from_sjisx0213(Str is, wc_ces ces)
{
    Str os;
    wc_uchar *sp = (wc_uchar *)is->ptr;
    wc_uchar *ep = sp + is->length;
    wc_uchar *p;
    wc_uchar jis[2];
    int state = WC_SJIS_NOSTATE;
    wc_wchar_t cc;

    for (p = sp; p < ep && *p < 0x80; p++)
  ;
    if (p == ep)
  return is;
    os = Strnew_size(is->length);
    if (p > sp)
  Strcat_charp_n(os, is->ptr, (int)(p - sp));

    for (; p < ep; p++) {
  switch (state) {
  case WC_SJIS_NOSTATE:
      switch (WC_SJIS_MAP[*p]) {
      case SL:
    state = WC_SJIS_SHIFT_L;
    break;
      case SH:
    state = WC_SJIS_SHIFT_H;
    break;
      case SX:
    state = WC_SJIS_SHIFT_X;
    break;
      case SK:
    wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)*p);
    break;
      case S80:
      case SA0:
      case C1:
    wtf_push_unknown(os, p, 1);
    break;
      default:
    Strcat_char(os, (char)*p);
    break;
      }
      break;
  case WC_SJIS_SHIFT_L:
  case WC_SJIS_SHIFT_H:
      if (WC_SJIS_MAP[*p] & LB) {
    jis[0] = *(p-1);
    jis[1] = *p;
    sjis_to_jisx0208(jis[0], jis[1]);
    cc.code = ((wc_uint32)jis[0] << 8) | jis[1];
    cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
    wtf_push(os, cc.ccs, cc.code);
      } else
    wtf_push_unknown(os, p-1, 2);
      state = WC_SJIS_NOSTATE;
      break;
  case WC_SJIS_SHIFT_X:
      if (WC_SJIS_MAP[*p] & LB) {
    jis[0] = *(p-1);
    jis[1] = *p;
    sjis_to_jisx02132(jis[0], jis[1]);
    wtf_push(os, WC_CCS_JIS_X_0213_2, ((wc_uint32)jis[0] << 8) | jis[1]);
      } else
    wtf_push_unknown(os, p-1, 2);
      state = WC_SJIS_NOSTATE;
      break;
  }
    }
    switch (state) {
    case WC_SJIS_SHIFT_L:
    case WC_SJIS_SHIFT_H:
    case WC_SJIS_SHIFT_X:
  wtf_push_unknown(os, p-1, 1);
  break;
    }
    return os;
}

void
wc_push_to_sjis(Str os, wc_wchar_t cc, wc_status *st)
{
    wc_uchar ub, lb;

  while (1) {
    switch (cc.ccs) {
    case WC_CCS_US_ASCII:
  Strcat_char(os, cc.code);
  return;
    case WC_CCS_JIS_X_0201K:
  if (WcOption.use_jisx0201k) {
      Strcat_char(os, cc.code | 0x80);
      return;
  } else if (WcOption.fix_width_conv)
      cc.ccs = WC_CCS_UNKNOWN;
  else
      cc = wc_jisx0201k_to_jisx0208(cc);
  continue;
    case WC_CCS_JIS_X_0208:
  ub = (cc.code >> 8) & 0x7f;
  lb = cc.code & 0x7f;
  jisx0208_to_sjis(ub, lb);
  Strcat_char(os, ub);
  Strcat_char(os, lb);
  return;
    case WC_CCS_SJIS_EXT_1:
    case WC_CCS_SJIS_EXT_2:
  cc = wc_cs94w_to_sjis_ext(cc);
    case WC_CCS_SJIS_EXT:
  Strcat_char(os, (char)(cc.code >> 8));
  Strcat_char(os, (char)(cc.code & 0xff));
  return;
    case WC_CCS_UNKNOWN_W:
  if (!WcOption.no_replace)
      Strcat_charp(os, WC_REPLACE_W);
  return;
    case WC_CCS_UNKNOWN:
  if (!WcOption.no_replace)
      Strcat_charp(os, WC_REPLACE);
  return;
    default:
#ifdef USE_UNICODE
  if (WcOption.ucs_conv)
      cc = wc_any_to_any_ces(cc, st);
  else
#endif
      cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
  continue;
    }
  }
}

void
wc_push_to_sjisx0213(Str os, wc_wchar_t cc, wc_status *st)
{
    wc_uchar ub, lb;

  while (1) {
    switch (cc.ccs) {
    case WC_CCS_US_ASCII:
  Strcat_char(os, cc.code);
  return;
    case WC_CCS_JIS_X_0201K:
  if (WcOption.use_jisx0201k) {
      Strcat_char(os, cc.code | 0x80);
      return;
  } else if (WcOption.fix_width_conv)
      cc.ccs = WC_CCS_UNKNOWN;
  else
      cc = wc_jisx0201k_to_jisx0208(cc);
  continue;
    case WC_CCS_JIS_X_0213_1:
  if (! WcOption.use_jisx0213) {
      cc.ccs = WC_CCS_UNKNOWN_W;
      continue;
  }
    case WC_CCS_JIS_X_0208:
  ub = (cc.code >> 8) & 0x7f;
  lb = cc.code & 0x7f;
  jisx0208_to_sjis(ub, lb);
  Strcat_char(os, ub);
  Strcat_char(os, lb);
  return;
    case WC_CCS_JIS_X_0213_2:
  if (! WcOption.use_jisx0213) {
      cc.ccs = WC_CCS_UNKNOWN_W;
      continue;
  }
  ub = (cc.code >> 8) & 0x7f;
  lb = cc.code & 0x7f;
  jisx02132_to_sjis(ub, lb);
  if (ub) {
      Strcat_char(os, ub);
      Strcat_char(os, lb);
      return;
  }
    case WC_CCS_UNKNOWN_W:
  if (!WcOption.no_replace)
      Strcat_charp(os, WC_REPLACE_W);
  return;
    case WC_CCS_UNKNOWN:
  if (!WcOption.no_replace)
      Strcat_charp(os, WC_REPLACE);
  return;
    default:
#ifdef USE_UNICODE
  if (WcOption.ucs_conv)
      cc = wc_any_to_any_ces(cc, st);
  else
#endif
      cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
  continue;
    }
  }
}

Str
wc_char_conv_from_sjis(wc_uchar c, wc_status *st)
{
    static Str os;
    static wc_uchar jis[2];
    wc_wchar_t cc;

    if (st->state == -1) {
  st->state = WC_SJIS_NOSTATE;
  os = Strnew_size(8);
    }

    switch (st->state) {
    case WC_SJIS_NOSTATE:
  switch (WC_SJIS_MAP[c]) {
  case SL:
      jis[0] = c;
      st->state = WC_SJIS_SHIFT_L;
      return NULL;
  case SH:
      jis[0] = c;
      st->state = WC_SJIS_SHIFT_H;
      return NULL;
  case SX:
      jis[0] = c;
      st->state = WC_SJIS_SHIFT_X;
      return NULL;
  case SK:
      wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)c);
      break;
  case S80:
  case SA0:
  case C1:
      break;
  default:
      Strcat_char(os, (char)c);
      break;
  }
  break;
    case WC_SJIS_SHIFT_L:
    case WC_SJIS_SHIFT_H:
  if (WC_SJIS_MAP[c] & LB) {
      jis[1] = c;
      sjis_to_jisx0208(jis[0], jis[1]);
      cc.code = ((wc_uint32)jis[0] << 8) | jis[1];
      cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
      if (cc.ccs == WC_CCS_JIS_X_0208)
    wtf_push(os, cc.ccs, cc.code);
      else
          wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)jis[0] << 8) | jis[1]);
  }
  st->state = WC_SJIS_NOSTATE;
  break;
    case WC_SJIS_SHIFT_X:
  if (WC_SJIS_MAP[c] & LB) {
      jis[1] = c;
      wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)jis[0] << 8) | jis[1]);
  }
  st->state = WC_SJIS_NOSTATE;
  break;
    }
    st->state = -1;
    return os;
}

Str
wc_char_conv_from_sjisx0213(wc_uchar c, wc_status *st)
{
    static Str os;
    static wc_uchar jis[2];
    wc_wchar_t cc;

    if (st->state == -1) {
  st->state = WC_SJIS_NOSTATE;
  os = Strnew_size(8);
    }

    switch (st->state) {
    case WC_SJIS_NOSTATE:
  switch (WC_SJIS_MAP[c]) {
  case SL:
      jis[0] = c;
      st->state = WC_SJIS_SHIFT_L;
      return NULL;
  case SH:
      jis[0] = c;
      st->state = WC_SJIS_SHIFT_H;
      return NULL;
  case SX:
      jis[0] = c;
      st->state = WC_SJIS_SHIFT_X;
      return NULL;
  case SK:
      wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)c);
      break;
  case S80:
  case SA0:
  case C1:
      break;
  default:
      Strcat_char(os, (char)c);
      break;
  }
  break;
    case WC_SJIS_SHIFT_L:
    case WC_SJIS_SHIFT_H:
  if (WC_SJIS_MAP[c] & LB) {
      jis[1] = c;
      sjis_to_jisx0208(jis[0], jis[1]);
      cc.code = ((wc_uint32)jis[0] << 8) | jis[1];
      cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
      wtf_push(os, cc.ccs, cc.code);
  }
  st->state = WC_SJIS_NOSTATE;
  break;
    case WC_SJIS_SHIFT_X:
  if (WC_SJIS_MAP[c] & LB) {
      jis[1] = c;
      sjis_to_jisx02132(jis[0], jis[1]);
      wtf_push(os, WC_CCS_JIS_X_0213_2, ((wc_uint32)jis[0] << 8) | jis[1]);
  }
  st->state = WC_SJIS_NOSTATE;
  break;
    }
    st->state = -1;
    return os;
}

Coverage Report

Created: 2025-08-28 06:51

Line	Count	Source (jump to first uncovered line)
1
2		#include "wc.h"
3		#include "sjis.h"
4		#include "jis.h"
5		#include "wtf.h"
6		#include "ucs.h"
7
8		#include "map/jisx02132_sjis.map"
9		wc_uchar *wc_jisx0212_jisx02132_map = jisx02132_sjis_map;
10
11		#define C0 WC_SJIS_MAP_C0
12		#define GL WC_SJIS_MAP_GL
13	303k	#define LB WC_SJIS_MAP_LB
14	55.2k	#define S80 WC_SJIS_MAP_80
15	39.4M	#define SK WC_SJIS_MAP_SK
16	195k	#define SL WC_SJIS_MAP_SL
17	51.1k	#define SH WC_SJIS_MAP_SH
18	57.0k	#define SX WC_SJIS_MAP_SX
19	190k	#define C1 WC_SJIS_MAP_C1
20	60.0k	#define SA0 WC_SJIS_MAP_A0
21
22		wc_uint8 WC_SJIS_MAP[ 0x100 ] = {
23		C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
24		C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
25		GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
26		GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
27		LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
28		LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
29		LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
30		LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, C0,
31
32		S80,SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL,
33		SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL, SL,
34		SA0,SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
35		SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
36		SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
37		SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK, SK,
38		SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH, SH,
39		SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, SX, C1, C1, C1,
40		};
41
42	361k	#define sjis_to_jisx0208(ub, lb) \
43	361k	{ \
44	361k	ub -= (ub < 0xa0) ? 0x81 : 0xc1; \
45	361k	ub = (ub << 1) + 0x21; \
46	361k	if (lb < 0x9f) { \
47	190k	lb -= (lb > 0x7e) ? 0x20 : 0x1f; \
48	190k	} else { \
49	171k	ub++; \
50	171k	lb -= 0x7e; \
51	171k	} \
52	361k	}
53	12.4k	#define sjis_to_jisx02132(ub, lb) \
54	12.4k	{ \
55	12.4k	if (lb < 0x9f) { \
56	2.93k	ub = sjis1_jisx02132_map[ub - 0xf0]; \
57	2.93k	lb -= (lb > 0x7e) ? 0x20 : 0x1f; \
58	9.48k	} else { \
59	9.48k	ub = sjis2_jisx02132_map[ub - 0xf0]; \
60	9.48k	lb -= 0x7e; \
61	9.48k	} \
62	12.4k	}
63	6.45M	#define jisx0208_to_sjis(ub, lb) \
64	6.45M	{ \
65	6.45M	lb += (ub & 1) ? 0x1f : 0x7d; \
66	6.45M	if (lb > 0x7e) \
67	6.45M	lb++; \
68	6.45M	ub = (ub - 0x21) >> 1; \
69	6.45M	ub += (ub < 0x1f) ? 0x81 : 0xc1; \
70	6.45M	}
71	0	#define jisx02132_to_sjis(ub, lb) \
72	0	{ \
73	0	lb += (ub & 1) ? 0x1f : 0x7d; \
74	0	if (lb > 0x7e) \
75	0	lb++; \
76	0	ub = jisx02132_sjis_map[ ub ]; \
77	0	}
78
79		wc_wchar_t
80		wc_sjis_to_jis(wc_wchar_t cc)
81	0	{
82	0	wc_uchar ub, lb;
83
84	0	ub = cc.code >> 8;
85	0	lb = cc.code & 0xff;
86	0	if (ub < 0xf0) {
87	0	sjis_to_jisx0208(ub, lb);
88	0	cc.ccs = WC_CCS_JIS_X_0208;
89	0	} else {
90	0	sjis_to_jisx02132(ub, lb);
91	0	cc.ccs = WC_CCS_JIS_X_0213_2;
92	0	}
93	0	cc.code = ((wc_uint32)ub << 8) \| lb;
94	0	return cc;
95	0	}
96
97		wc_wchar_t
98		wc_jis_to_sjis(wc_wchar_t cc)
99	0	{
100	0	wc_uchar ub, lb;
101
102	0	ub = (cc.code >> 8) & 0x7f;
103	0	lb = cc.code & 0x7f;
104	0	if (cc.ccs == WC_CCS_JIS_X_0213_2) {
105	0	jisx02132_to_sjis(ub, lb);
106	0	if (! ub) {
107	0	cc.ccs = WC_CCS_UNKNOWN_W;
108	0	return cc;
109	0	}
110	0	} else {
111	0	jisx0208_to_sjis(ub, lb);
112	0	}
113	0	cc.code = ((wc_uint32)ub << 8) \| lb;
114	0	return cc;
115	0	}
116
117		wc_wchar_t
118		wc_sjis_ext_to_cs94w(wc_wchar_t cc)
119	194k	{
120	194k	wc_uchar ub, lb;
121
122	194k	ub = cc.code >> 8;
123	194k	lb = cc.code & 0xff;
124	194k	sjis_to_jisx0208(ub, lb);
125	194k	if (ub <= 0x7e) {
126	107k	cc.ccs = WC_CCS_SJIS_EXT_1;
127	107k	} else {
128	87.7k	ub -= 0x5e;
129	87.7k	cc.ccs = WC_CCS_SJIS_EXT_2;
130	87.7k	}
131	194k	cc.code = ((wc_uint32)ub << 8) \| lb;
132	194k	return cc;
133	194k	}
134
135		wc_wchar_t
136		wc_cs94w_to_sjis_ext(wc_wchar_t cc)
137	105k	{
138	105k	wc_uchar ub, lb;
139
140	105k	ub = (cc.code >> 8) & 0x7f;
141	105k	lb = cc.code & 0x7f;
142	105k	if (cc.ccs == WC_CCS_SJIS_EXT_2)
143	35.4k	ub += 0x5e;
144	105k	jisx0208_to_sjis(ub, lb);
145	105k	cc.ccs = WC_CCS_SJIS_EXT;
146	105k	cc.code = ((wc_uint32)ub << 8) \| lb;
147	105k	return cc;
148	105k	}
149
150		wc_uint32
151		wc_sjis_ext1_to_N(wc_uint32 c)
152	36.6k	{
153	36.6k	wc_uchar ub;
154
155	36.6k	ub = (c >> 8) & 0x7f;
156	36.6k	switch(ub) {
157	1.86k	case 0x2D: /* 0x8740 - */
158	1.86k	ub = 0;
159	1.86k	break;
160	557	case 0x79: /* 0xED40 - */
161	4.47k	case 0x7A: /* 0xED9F - */
162	5.04k	case 0x7B: /* 0xEE40 - */
163	6.59k	case 0x7C: /* 0xEE9F - */
164	6.59k	ub -= 0x78;
165	6.59k	break;
166	28.2k	default:
167	28.2k	return WC_C_SJIS_ERROR;
168	36.6k	}
169	8.45k	return ub * 0x5e + (c & 0x7f) - 0x21;
170	36.6k	}
171
172		wc_uint32
173		wc_sjis_ext2_to_N(wc_uint32 c)
174	52.3k	{
175	52.3k	wc_uchar ub;
176
177	52.3k	ub = (c >> 8) & 0x7f;
178	52.3k	switch(ub) {
179	488	case 0x35: /* 0xFA40 - */
180	8.78k	case 0x36: /* 0xFA9F - */
181	9.17k	case 0x37: /* 0xFB40 - */
182	9.99k	case 0x38: /* 0xFB9F - */
183	10.4k	case 0x39: /* 0xFC40 - */
184	10.4k	ub -= 0x30;
185	10.4k	break;
186	41.9k	default:
187	41.9k	return WC_C_SJIS_ERROR;
188	52.3k	}
189	10.4k	return ub * 0x5e + (c & 0x7f) - 0x21;
190	52.3k	}
191
192		Str
193		wc_conv_from_sjis(Str is, wc_ces ces)
194	1.47k	{
195	1.47k	Str os;
196	1.47k	wc_uchar sp = (wc_uchar )is->ptr;
197	1.47k	wc_uchar *ep = sp + is->length;
198	1.47k	wc_uchar *p;
199	1.47k	wc_uchar jis[2];
200	1.47k	int state = WC_SJIS_NOSTATE;
201	1.47k	wc_wchar_t cc;
202
203	3.18k	for (p = sp; p < ep && *p < 0x80; p++)
204	1.70k	;
205	1.47k	if (p == ep)
206	132	return is;
207	1.34k	os = Strnew_size(is->length);
208	1.34k	if (p > sp)
209	252	Strcat_charp_n(os, is->ptr, (int)(p - sp));
210
211	37.7M	for (; p < ep; p++) {
212	37.7M	switch (state) {
213	37.5M	case WC_SJIS_NOSTATE:
214	37.5M	switch (WC_SJIS_MAP[*p]) {
215	140k	case SL:
216	140k	state = WC_SJIS_SHIFT_L;
217	140k	break;
218	38.7k	case SH:
219	38.7k	state = WC_SJIS_SHIFT_H;
220	38.7k	break;
221	41.4k	case SX:
222	41.4k	state = WC_SJIS_SHIFT_X;
223	41.4k	break;
224	34.3M	case SK:
225	34.3M	wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)*p);
226	34.3M	break;
227	36.9k	case S80:
228	40.4k	case SA0:
229	124k	case C1:
230	124k	wtf_push_unknown(os, p, 1);
231	124k	break;
232	2.86M	default:
233	2.86M	Strcat_char(os, (char)*p);
234	2.86M	break;
235	37.5M	}
236	37.5M	break;
237	37.5M	case WC_SJIS_SHIFT_L:
238	178k	case WC_SJIS_SHIFT_H:
239	178k	if (WC_SJIS_MAP[*p] & LB) {
240	114k	jis[0] = *(p-1);
241	114k	jis[1] = *p;
242	114k	sjis_to_jisx0208(jis[0], jis[1]);
243	114k	cc.code = ((wc_uint32)jis[0] << 8) \| jis[1];
244	114k	cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
245	114k	if (cc.ccs == WC_CCS_JIS_X_0208)
246	83.1k	wtf_push(os, cc.ccs, cc.code);
247	30.8k	else
248	30.8k	wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)(p-1) << 8) \| p);
249	114k	} else
250	64.8k	wtf_push_unknown(os, p-1, 2);
251	178k	state = WC_SJIS_NOSTATE;
252	178k	break;
253	41.4k	case WC_SJIS_SHIFT_X:
254	41.4k	if (WC_SJIS_MAP[*p] & LB)
255	35.1k	wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)(p-1) << 8) \| p);
256	6.25k	else
257	6.25k	wtf_push_unknown(os, p-1, 2);
258	41.4k	state = WC_SJIS_NOSTATE;
259	41.4k	break;
260	37.7M	}
261	37.7M	}
262	1.34k	switch (state) {
263	30	case WC_SJIS_SHIFT_L:
264	49	case WC_SJIS_SHIFT_H:
265	58	case WC_SJIS_SHIFT_X:
266	58	wtf_push_unknown(os, p-1, 1);
267	58	break;
268	1.34k	}
269	1.34k	return os;
270	1.34k	}
271
272		Str
273		wc_conv_from_sjisx0213(Str is, wc_ces ces)
274	202	{
275	202	Str os;
276	202	wc_uchar sp = (wc_uchar )is->ptr;
277	202	wc_uchar *ep = sp + is->length;
278	202	wc_uchar *p;
279	202	wc_uchar jis[2];
280	202	int state = WC_SJIS_NOSTATE;
281	202	wc_wchar_t cc;
282
283	646	for (p = sp; p < ep && *p < 0x80; p++)
284	444	;
285	202	if (p == ep)
286	10	return is;
287	192	os = Strnew_size(is->length);
288	192	if (p > sp)
289	45	Strcat_charp_n(os, is->ptr, (int)(p - sp));
290
291	5.72M	for (; p < ep; p++) {
292	5.72M	switch (state) {
293	5.64M	case WC_SJIS_NOSTATE:
294	5.64M	switch (WC_SJIS_MAP[*p]) {
295	55.5k	case SL:
296	55.5k	state = WC_SJIS_SHIFT_L;
297	55.5k	break;
298	12.4k	case SH:
299	12.4k	state = WC_SJIS_SHIFT_H;
300	12.4k	break;
301	15.5k	case SX:
302	15.5k	state = WC_SJIS_SHIFT_X;
303	15.5k	break;
304	5.13M	case SK:
305	5.13M	wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)*p);
306	5.13M	break;
307	18.2k	case S80:
308	19.6k	case SA0:
309	66.7k	case C1:
310	66.7k	wtf_push_unknown(os, p, 1);
311	66.7k	break;
312	354k	default:
313	354k	Strcat_char(os, (char)*p);
314	354k	break;
315	5.64M	}
316	5.64M	break;
317	5.64M	case WC_SJIS_SHIFT_L:
318	67.9k	case WC_SJIS_SHIFT_H:
319	67.9k	if (WC_SJIS_MAP[*p] & LB) {
320	52.5k	jis[0] = *(p-1);
321	52.5k	jis[1] = *p;
322	52.5k	sjis_to_jisx0208(jis[0], jis[1]);
323	52.5k	cc.code = ((wc_uint32)jis[0] << 8) \| jis[1];
324	52.5k	cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
325	52.5k	wtf_push(os, cc.ccs, cc.code);
326	52.5k	} else
327	15.4k	wtf_push_unknown(os, p-1, 2);
328	67.9k	state = WC_SJIS_NOSTATE;
329	67.9k	break;
330	15.5k	case WC_SJIS_SHIFT_X:
331	15.5k	if (WC_SJIS_MAP[*p] & LB) {
332	12.4k	jis[0] = *(p-1);
333	12.4k	jis[1] = *p;
334	12.4k	sjis_to_jisx02132(jis[0], jis[1]);
335	12.4k	wtf_push(os, WC_CCS_JIS_X_0213_2, ((wc_uint32)jis[0] << 8) \| jis[1]);
336	12.4k	} else
337	3.14k	wtf_push_unknown(os, p-1, 2);
338	15.5k	state = WC_SJIS_NOSTATE;
339	15.5k	break;
340	5.72M	}
341	5.72M	}
342	192	switch (state) {
343	11	case WC_SJIS_SHIFT_L:
344	16	case WC_SJIS_SHIFT_H:
345	21	case WC_SJIS_SHIFT_X:
346	21	wtf_push_unknown(os, p-1, 1);
347	21	break;
348	192	}
349	192	return os;
350	192	}
351
352		void
353		wc_push_to_sjis(Str os, wc_wchar_t cc, wc_status *st)
354	2.47M	{
355	2.47M	wc_uchar ub, lb;
356
357	2.59M	while (1) {
358	2.59M	switch (cc.ccs) {
359	44.4k	case WC_CCS_US_ASCII:
360	44.4k	Strcat_char(os, cc.code);
361	44.4k	return;
362	8.92k	case WC_CCS_JIS_X_0201K:
363	8.92k	if (WcOption.use_jisx0201k) {
364	0	Strcat_char(os, cc.code \| 0x80);
365	0	return;
366	8.92k	} else if (WcOption.fix_width_conv)
367	8.92k	cc.ccs = WC_CCS_UNKNOWN;
368	0	else
369	0	cc = wc_jisx0201k_to_jisx0208(cc);
370	8.92k	continue;
371	2.29M	case WC_CCS_JIS_X_0208:
372	2.29M	ub = (cc.code >> 8) & 0x7f;
373	2.29M	lb = cc.code & 0x7f;
374	2.29M	jisx0208_to_sjis(ub, lb);
375	2.29M	Strcat_char(os, ub);
376	2.29M	Strcat_char(os, lb);
377	2.29M	return;
378	39.6k	case WC_CCS_SJIS_EXT_1:
379	39.9k	case WC_CCS_SJIS_EXT_2:
380	39.9k	cc = wc_cs94w_to_sjis_ext(cc);
381	56.2k	case WC_CCS_SJIS_EXT:
382	56.2k	Strcat_char(os, (char)(cc.code >> 8));
383	56.2k	Strcat_char(os, (char)(cc.code & 0xff));
384	56.2k	return;
385	4.37k	case WC_CCS_UNKNOWN_W:
386	4.37k	if (!WcOption.no_replace)
387	4.37k	Strcat_charp(os, WC_REPLACE_W);
388	4.37k	return;
389	72.5k	case WC_CCS_UNKNOWN:
390	72.5k	if (!WcOption.no_replace)
391	72.5k	Strcat_charp(os, WC_REPLACE);
392	72.5k	return;
393	113k	default:
394	113k	#ifdef USE_UNICODE
395	113k	if (WcOption.ucs_conv)
396	113k	cc = wc_any_to_any_ces(cc, st);
397	0	else
398	0	#endif
399	0	cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
400	113k	continue;
401	2.59M	}
402	2.59M	}
403	2.47M	}
404
405		void
406		wc_push_to_sjisx0213(Str os, wc_wchar_t cc, wc_status *st)
407	4.19M	{
408	4.19M	wc_uchar ub, lb;
409
410	4.29M	while (1) {
411	4.29M	switch (cc.ccs) {
412	20.7k	case WC_CCS_US_ASCII:
413	20.7k	Strcat_char(os, cc.code);
414	20.7k	return;
415	25.1k	case WC_CCS_JIS_X_0201K:
416	25.1k	if (WcOption.use_jisx0201k) {
417	0	Strcat_char(os, cc.code \| 0x80);
418	0	return;
419	25.1k	} else if (WcOption.fix_width_conv)
420	25.1k	cc.ccs = WC_CCS_UNKNOWN;
421	0	else
422	0	cc = wc_jisx0201k_to_jisx0208(cc);
423	25.1k	continue;
424	25.1k	case WC_CCS_JIS_X_0213_1:
425	1.50k	if (! WcOption.use_jisx0213) {
426	1.50k	cc.ccs = WC_CCS_UNKNOWN_W;
427	1.50k	continue;
428	1.50k	}
429	4.04M	case WC_CCS_JIS_X_0208:
430	4.04M	ub = (cc.code >> 8) & 0x7f;
431	4.04M	lb = cc.code & 0x7f;
432	4.04M	jisx0208_to_sjis(ub, lb);
433	4.04M	Strcat_char(os, ub);
434	4.04M	Strcat_char(os, lb);
435	4.04M	return;
436	3.58k	case WC_CCS_JIS_X_0213_2:
437	3.58k	if (! WcOption.use_jisx0213) {
438	3.58k	cc.ccs = WC_CCS_UNKNOWN_W;
439	3.58k	continue;
440	3.58k	}
441	0	ub = (cc.code >> 8) & 0x7f;
442	0	lb = cc.code & 0x7f;
443	0	jisx02132_to_sjis(ub, lb);
444	0	if (ub) {
445	0	Strcat_char(os, ub);
446	0	Strcat_char(os, lb);
447	0	return;
448	0	}
449	7.39k	case WC_CCS_UNKNOWN_W:
450	7.39k	if (!WcOption.no_replace)
451	7.39k	Strcat_charp(os, WC_REPLACE_W);
452	7.39k	return;
453	115k	case WC_CCS_UNKNOWN:
454	115k	if (!WcOption.no_replace)
455	115k	Strcat_charp(os, WC_REPLACE);
456	115k	return;
457	75.5k	default:
458	75.5k	#ifdef USE_UNICODE
459	75.5k	if (WcOption.ucs_conv)
460	75.5k	cc = wc_any_to_any_ces(cc, st);
461	0	else
462	0	#endif
463	0	cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
464	75.5k	continue;
465	4.29M	}
466	4.29M	}
467	4.19M	}
468
469		Str
470		wc_char_conv_from_sjis(wc_uchar c, wc_status *st)
471	0	{
472	0	static Str os;
473	0	static wc_uchar jis[2];
474	0	wc_wchar_t cc;
475
476	0	if (st->state == -1) {
477	0	st->state = WC_SJIS_NOSTATE;
478	0	os = Strnew_size(8);
479	0	}
480
481	0	switch (st->state) {
482	0	case WC_SJIS_NOSTATE:
483	0	switch (WC_SJIS_MAP[c]) {
484	0	case SL:
485	0	jis[0] = c;
486	0	st->state = WC_SJIS_SHIFT_L;
487	0	return NULL;
488	0	case SH:
489	0	jis[0] = c;
490	0	st->state = WC_SJIS_SHIFT_H;
491	0	return NULL;
492	0	case SX:
493	0	jis[0] = c;
494	0	st->state = WC_SJIS_SHIFT_X;
495	0	return NULL;
496	0	case SK:
497	0	wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)c);
498	0	break;
499	0	case S80:
500	0	case SA0:
501	0	case C1:
502	0	break;
503	0	default:
504	0	Strcat_char(os, (char)c);
505	0	break;
506	0	}
507	0	break;
508	0	case WC_SJIS_SHIFT_L:
509	0	case WC_SJIS_SHIFT_H:
510	0	if (WC_SJIS_MAP[c] & LB) {
511	0	jis[1] = c;
512	0	sjis_to_jisx0208(jis[0], jis[1]);
513	0	cc.code = ((wc_uint32)jis[0] << 8) \| jis[1];
514	0	cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
515	0	if (cc.ccs == WC_CCS_JIS_X_0208)
516	0	wtf_push(os, cc.ccs, cc.code);
517	0	else
518	0	wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)jis[0] << 8) \| jis[1]);
519	0	}
520	0	st->state = WC_SJIS_NOSTATE;
521	0	break;
522	0	case WC_SJIS_SHIFT_X:
523	0	if (WC_SJIS_MAP[c] & LB) {
524	0	jis[1] = c;
525	0	wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)jis[0] << 8) \| jis[1]);
526	0	}
527	0	st->state = WC_SJIS_NOSTATE;
528	0	break;
529	0	}
530	0	st->state = -1;
531	0	return os;
532	0	}
533
534		Str
535		wc_char_conv_from_sjisx0213(wc_uchar c, wc_status *st)
536	0	{
537	0	static Str os;
538	0	static wc_uchar jis[2];
539	0	wc_wchar_t cc;
540
541	0	if (st->state == -1) {
542	0	st->state = WC_SJIS_NOSTATE;
543	0	os = Strnew_size(8);
544	0	}
545
546	0	switch (st->state) {
547	0	case WC_SJIS_NOSTATE:
548	0	switch (WC_SJIS_MAP[c]) {
549	0	case SL:
550	0	jis[0] = c;
551	0	st->state = WC_SJIS_SHIFT_L;
552	0	return NULL;
553	0	case SH:
554	0	jis[0] = c;
555	0	st->state = WC_SJIS_SHIFT_H;
556	0	return NULL;
557	0	case SX:
558	0	jis[0] = c;
559	0	st->state = WC_SJIS_SHIFT_X;
560	0	return NULL;
561	0	case SK:
562	0	wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)c);
563	0	break;
564	0	case S80:
565	0	case SA0:
566	0	case C1:
567	0	break;
568	0	default:
569	0	Strcat_char(os, (char)c);
570	0	break;
571	0	}
572	0	break;
573	0	case WC_SJIS_SHIFT_L:
574	0	case WC_SJIS_SHIFT_H:
575	0	if (WC_SJIS_MAP[c] & LB) {
576	0	jis[1] = c;
577	0	sjis_to_jisx0208(jis[0], jis[1]);
578	0	cc.code = ((wc_uint32)jis[0] << 8) \| jis[1];
579	0	cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
580	0	wtf_push(os, cc.ccs, cc.code);
581	0	}
582	0	st->state = WC_SJIS_NOSTATE;
583	0	break;
584	0	case WC_SJIS_SHIFT_X:
585	0	if (WC_SJIS_MAP[c] & LB) {
586	0	jis[1] = c;
587	0	sjis_to_jisx02132(jis[0], jis[1]);
588	0	wtf_push(os, WC_CCS_JIS_X_0213_2, ((wc_uint32)jis[0] << 8) \| jis[1]);
589	0	}
590	0	st->state = WC_SJIS_NOSTATE;
591	0	break;
592	0	}
593	0	st->state = -1;
594	0	return os;
595	0	}