/src/w3m/libwc/sjis.c

Source

#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: 2026-04-12 06:47

Line	Count	Source
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	3.36M	#define LB WC_SJIS_MAP_LB
14	61.0k	#define S80 WC_SJIS_MAP_80
15	39.7M	#define SK WC_SJIS_MAP_SK
16	2.73M	#define SL WC_SJIS_MAP_SL
17	384k	#define SH WC_SJIS_MAP_SH
18	238k	#define SX WC_SJIS_MAP_SX
19	344k	#define C1 WC_SJIS_MAP_C1
20	218k	#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	3.64M	#define sjis_to_jisx0208(ub, lb) \
43	3.64M	{ \
44	3.64M	ub -= (ub < 0xa0) ? 0x81 : 0xc1; \
45	3.64M	ub = (ub << 1) + 0x21; \
46	3.64M	if (lb < 0x9f) { \
47	2.72M	lb -= (lb > 0x7e) ? 0x20 : 0x1f; \
48	2.72M	} else { \
49	923k	ub++; \
50	923k	lb -= 0x7e; \
51	923k	} \
52	3.64M	}
53	50.3k	#define sjis_to_jisx02132(ub, lb) \
54	50.3k	{ \
55	50.3k	if (lb < 0x9f) { \
56	22.9k	ub = sjis1_jisx02132_map[ub - 0xf0]; \
57	22.9k	lb -= (lb > 0x7e) ? 0x20 : 0x1f; \
58	27.4k	} else { \
59	27.4k	ub = sjis2_jisx02132_map[ub - 0xf0]; \
60	27.4k	lb -= 0x7e; \
61	27.4k	} \
62	50.3k	}
63	5.30M	#define jisx0208_to_sjis(ub, lb) \
64	5.30M	{ \
65	5.30M	lb += (ub & 1) ? 0x1f : 0x7d; \
66	5.30M	if (lb > 0x7e) \
67	5.30M	lb++; \
68	5.30M	ub = (ub - 0x21) >> 1; \
69	5.30M	ub += (ub < 0x1f) ? 0x81 : 0xc1; \
70	5.30M	}
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	786k	{
120	786k	wc_uchar ub, lb;
121
122	786k	ub = cc.code >> 8;
123	786k	lb = cc.code & 0xff;
124	786k	sjis_to_jisx0208(ub, lb);
125	786k	if (ub <= 0x7e) {
126	513k	cc.ccs = WC_CCS_SJIS_EXT_1;
127	513k	} else {
128	273k	ub -= 0x5e;
129	273k	cc.ccs = WC_CCS_SJIS_EXT_2;
130	273k	}
131	786k	cc.code = ((wc_uint32)ub << 8) \| lb;
132	786k	return cc;
133	786k	}
134
135		wc_wchar_t
136		wc_cs94w_to_sjis_ext(wc_wchar_t cc)
137	395k	{
138	395k	wc_uchar ub, lb;
139
140	395k	ub = (cc.code >> 8) & 0x7f;
141	395k	lb = cc.code & 0x7f;
142	395k	if (cc.ccs == WC_CCS_SJIS_EXT_2)
143	138k	ub += 0x5e;
144	395k	jisx0208_to_sjis(ub, lb);
145	395k	cc.ccs = WC_CCS_SJIS_EXT;
146	395k	cc.code = ((wc_uint32)ub << 8) \| lb;
147	395k	return cc;
148	395k	}
149
150		wc_uint32
151		wc_sjis_ext1_to_N(wc_uint32 c)
152	256k	{
153	256k	wc_uchar ub;
154
155	256k	ub = (c >> 8) & 0x7f;
156	256k	switch(ub) {
157	5.28k	case 0x2D: /* 0x8740 - */
158	5.28k	ub = 0;
159	5.28k	break;
160	4.58k	case 0x79: /* 0xED40 - */
161	121k	case 0x7A: /* 0xED9F - */
162	125k	case 0x7B: /* 0xEE40 - */
163	130k	case 0x7C: /* 0xEE9F - */
164	130k	ub -= 0x78;
165	130k	break;
166	120k	default:
167	120k	return WC_C_SJIS_ERROR;
168	256k	}
169	136k	return ub * 0x5e + (c & 0x7f) - 0x21;
170	256k	}
171
172		wc_uint32
173		wc_sjis_ext2_to_N(wc_uint32 c)
174	134k	{
175	134k	wc_uchar ub;
176
177	134k	ub = (c >> 8) & 0x7f;
178	134k	switch(ub) {
179	4.04k	case 0x35: /* 0xFA40 - */
180	17.3k	case 0x36: /* 0xFA9F - */
181	21.7k	case 0x37: /* 0xFB40 - */
182	26.3k	case 0x38: /* 0xFB9F - */
183	30.6k	case 0x39: /* 0xFC40 - */
184	30.6k	ub -= 0x30;
185	30.6k	break;
186	104k	default:
187	104k	return WC_C_SJIS_ERROR;
188	134k	}
189	30.6k	return ub * 0x5e + (c & 0x7f) - 0x21;
190	134k	}
191
192		Str
193		wc_conv_from_sjis(Str is, wc_ces ces)
194	1.40k	{
195	1.40k	Str os;
196	1.40k	wc_uchar sp = (wc_uchar )is->ptr;
197	1.40k	wc_uchar *ep = sp + is->length;
198	1.40k	wc_uchar *p;
199	1.40k	wc_uchar jis[2];
200	1.40k	int state = WC_SJIS_NOSTATE;
201	1.40k	wc_wchar_t cc;
202
203	2.76k	for (p = sp; p < ep && *p < 0x80; p++)
204	1.35k	;
205	1.40k	if (p == ep)
206	98	return is;
207	1.30k	os = Strnew_size(is->length);
208	1.30k	if (p > sp)
209	247	Strcat_charp_n(os, is->ptr, (int)(p - sp));
210
211	50.6M	for (; p < ep; p++) {
212	50.6M	switch (state) {
213	48.0M	case WC_SJIS_NOSTATE:
214	48.0M	switch (WC_SJIS_MAP[*p]) {
215	2.05M	case SL:
216	2.05M	state = WC_SJIS_SHIFT_L;
217	2.05M	break;
218	307k	case SH:
219	307k	state = WC_SJIS_SHIFT_H;
220	307k	break;
221	171k	case SX:
222	171k	state = WC_SJIS_SHIFT_X;
223	171k	break;
224	37.9M	case SK:
225	37.9M	wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)*p);
226	37.9M	break;
227	53.2k	case S80:
228	205k	case SA0:
229	299k	case C1:
230	299k	wtf_push_unknown(os, p, 1);
231	299k	break;
232	7.34M	default:
233	7.34M	Strcat_char(os, (char)*p);
234	7.34M	break;
235	48.0M	}
236	48.0M	break;
237	48.0M	case WC_SJIS_SHIFT_L:
238	2.36M	case WC_SJIS_SHIFT_H:
239	2.36M	if (WC_SJIS_MAP[*p] & LB) {
240	2.16M	jis[0] = *(p-1);
241	2.16M	jis[1] = *p;
242	2.16M	sjis_to_jisx0208(jis[0], jis[1]);
243	2.16M	cc.code = ((wc_uint32)jis[0] << 8) \| jis[1];
244	2.16M	cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
245	2.16M	if (cc.ccs == WC_CCS_JIS_X_0208)
246	1.90M	wtf_push(os, cc.ccs, cc.code);
247	255k	else
248	255k	wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)(p-1) << 8) \| p);
249	2.16M	} else
250	203k	wtf_push_unknown(os, p-1, 2);
251	2.36M	state = WC_SJIS_NOSTATE;
252	2.36M	break;
253	171k	case WC_SJIS_SHIFT_X:
254	171k	if (WC_SJIS_MAP[*p] & LB)
255	132k	wtf_push(os, WC_CCS_SJIS_EXT, ((wc_uint32)(p-1) << 8) \| p);
256	39.7k	else
257	39.7k	wtf_push_unknown(os, p-1, 2);
258	171k	state = WC_SJIS_NOSTATE;
259	171k	break;
260	50.6M	}
261	50.6M	}
262	1.30k	switch (state) {
263	39	case WC_SJIS_SHIFT_L:
264	59	case WC_SJIS_SHIFT_H:
265	70	case WC_SJIS_SHIFT_X:
266	70	wtf_push_unknown(os, p-1, 1);
267	70	break;
268	1.30k	}
269	1.30k	return os;
270	1.30k	}
271
272		Str
273		wc_conv_from_sjisx0213(Str is, wc_ces ces)
274	166	{
275	166	Str os;
276	166	wc_uchar sp = (wc_uchar )is->ptr;
277	166	wc_uchar *ep = sp + is->length;
278	166	wc_uchar *p;
279	166	wc_uchar jis[2];
280	166	int state = WC_SJIS_NOSTATE;
281	166	wc_wchar_t cc;
282
283	688	for (p = sp; p < ep && *p < 0x80; p++)
284	522	;
285	166	if (p == ep)
286	11	return is;
287	155	os = Strnew_size(is->length);
288	155	if (p > sp)
289	36	Strcat_charp_n(os, is->ptr, (int)(p - sp));
290
291	4.46M	for (; p < ep; p++) {
292	4.46M	switch (state) {
293	3.64M	case WC_SJIS_NOSTATE:
294	3.64M	switch (WC_SJIS_MAP[*p]) {
295	680k	case SL:
296	680k	state = WC_SJIS_SHIFT_L;
297	680k	break;
298	77.1k	case SH:
299	77.1k	state = WC_SJIS_SHIFT_H;
300	77.1k	break;
301	66.7k	case SX:
302	66.7k	state = WC_SJIS_SHIFT_X;
303	66.7k	break;
304	1.86M	case SK:
305	1.86M	wtf_push(os, WC_CCS_JIS_X_0201K, (wc_uint32)*p);
306	1.86M	break;
307	7.82k	case S80:
308	13.6k	case SA0:
309	45.0k	case C1:
310	45.0k	wtf_push_unknown(os, p, 1);
311	45.0k	break;
312	903k	default:
313	903k	Strcat_char(os, (char)*p);
314	903k	break;
315	3.64M	}
316	3.64M	break;
317	3.64M	case WC_SJIS_SHIFT_L:
318	757k	case WC_SJIS_SHIFT_H:
319	757k	if (WC_SJIS_MAP[*p] & LB) {
320	696k	jis[0] = *(p-1);
321	696k	jis[1] = *p;
322	696k	sjis_to_jisx0208(jis[0], jis[1]);
323	696k	cc.code = ((wc_uint32)jis[0] << 8) \| jis[1];
324	696k	cc.ccs = wc_jisx0208_or_jisx02131(cc.code);
325	696k	wtf_push(os, cc.ccs, cc.code);
326	696k	} else
327	60.4k	wtf_push_unknown(os, p-1, 2);
328	757k	state = WC_SJIS_NOSTATE;
329	757k	break;
330	66.7k	case WC_SJIS_SHIFT_X:
331	66.7k	if (WC_SJIS_MAP[*p] & LB) {
332	50.3k	jis[0] = *(p-1);
333	50.3k	jis[1] = *p;
334	50.3k	sjis_to_jisx02132(jis[0], jis[1]);
335	50.3k	wtf_push(os, WC_CCS_JIS_X_0213_2, ((wc_uint32)jis[0] << 8) \| jis[1]);
336	50.3k	} else
337	16.3k	wtf_push_unknown(os, p-1, 2);
338	66.7k	state = WC_SJIS_NOSTATE;
339	66.7k	break;
340	4.46M	}
341	4.46M	}
342	155	switch (state) {
343	10	case WC_SJIS_SHIFT_L:
344	15	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	155	}
349	155	return os;
350	155	}
351
352		void
353		wc_push_to_sjis(Str os, wc_wchar_t cc, wc_status *st)
354	7.92M	{
355	7.92M	wc_uchar ub, lb;
356
357	10.2M	while (1) {
358	10.2M	switch (cc.ccs) {
359	1.54M	case WC_CCS_US_ASCII:
360	1.54M	Strcat_char(os, cc.code);
361	1.54M	return;
362	29.6k	case WC_CCS_JIS_X_0201K:
363	29.6k	if (WcOption.use_jisx0201k) {
364	0	Strcat_char(os, cc.code \| 0x80);
365	0	return;
366	29.6k	} else if (WcOption.fix_width_conv)
367	29.6k	cc.ccs = WC_CCS_UNKNOWN;
368	0	else
369	0	cc = wc_jisx0201k_to_jisx0208(cc);
370	29.6k	continue;
371	4.13M	case WC_CCS_JIS_X_0208:
372	4.13M	ub = (cc.code >> 8) & 0x7f;
373	4.13M	lb = cc.code & 0x7f;
374	4.13M	jisx0208_to_sjis(ub, lb);
375	4.13M	Strcat_char(os, ub);
376	4.13M	Strcat_char(os, lb);
377	4.13M	return;
378	905	case WC_CCS_SJIS_EXT_1:
379	6.92k	case WC_CCS_SJIS_EXT_2:
380	6.92k	cc = wc_cs94w_to_sjis_ext(cc);
381	10.8k	case WC_CCS_SJIS_EXT:
382	10.8k	Strcat_char(os, (char)(cc.code >> 8));
383	10.8k	Strcat_char(os, (char)(cc.code & 0xff));
384	10.8k	return;
385	525k	case WC_CCS_UNKNOWN_W:
386	525k	if (!WcOption.no_replace)
387	525k	Strcat_charp(os, WC_REPLACE_W);
388	525k	return;
389	1.71M	case WC_CCS_UNKNOWN:
390	1.71M	if (!WcOption.no_replace)
391	1.71M	Strcat_charp(os, WC_REPLACE);
392	1.71M	return;
393	2.33M	default:
394	2.33M	#ifdef USE_UNICODE
395	2.33M	if (WcOption.ucs_conv)
396	2.33M	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	2.33M	continue;
401	10.2M	}
402	10.2M	}
403	7.92M	}
404
405		void
406		wc_push_to_sjisx0213(Str os, wc_wchar_t cc, wc_status *st)
407	3.27M	{
408	3.27M	wc_uchar ub, lb;
409
410	4.94M	while (1) {
411	4.94M	switch (cc.ccs) {
412	526k	case WC_CCS_US_ASCII:
413	526k	Strcat_char(os, cc.code);
414	526k	return;
415	5.28k	case WC_CCS_JIS_X_0201K:
416	5.28k	if (WcOption.use_jisx0201k) {
417	0	Strcat_char(os, cc.code \| 0x80);
418	0	return;
419	5.28k	} else if (WcOption.fix_width_conv)
420	5.28k	cc.ccs = WC_CCS_UNKNOWN;
421	0	else
422	0	cc = wc_jisx0201k_to_jisx0208(cc);
423	5.28k	continue;
424	6.59k	case WC_CCS_JIS_X_0213_1:
425	6.59k	if (! WcOption.use_jisx0213) {
426	6.59k	cc.ccs = WC_CCS_UNKNOWN_W;
427	6.59k	continue;
428	6.59k	}
429	777k	case WC_CCS_JIS_X_0208:
430	777k	ub = (cc.code >> 8) & 0x7f;
431	777k	lb = cc.code & 0x7f;
432	777k	jisx0208_to_sjis(ub, lb);
433	777k	Strcat_char(os, ub);
434	777k	Strcat_char(os, lb);
435	777k	return;
436	5.66k	case WC_CCS_JIS_X_0213_2:
437	5.66k	if (! WcOption.use_jisx0213) {
438	5.66k	cc.ccs = WC_CCS_UNKNOWN_W;
439	5.66k	continue;
440	5.66k	}
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	51.1k	case WC_CCS_UNKNOWN_W:
450	51.1k	if (!WcOption.no_replace)
451	51.1k	Strcat_charp(os, WC_REPLACE_W);
452	51.1k	return;
453	1.91M	case WC_CCS_UNKNOWN:
454	1.91M	if (!WcOption.no_replace)
455	1.91M	Strcat_charp(os, WC_REPLACE);
456	1.91M	return;
457	1.65M	default:
458	1.65M	#ifdef USE_UNICODE
459	1.65M	if (WcOption.ucs_conv)
460	1.65M	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	1.65M	continue;
465	4.94M	}
466	4.94M	}
467	3.27M	}
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	}