/* -*- mode: C; mode: fold -*- */
/* slkanji.c --- Interface To use Japanese 2byte KANJI code
* Copyright (c) 1995, 2000 Kazuhisa Yoshino(k-yosino@actweb.ne.jp)
* This file is part of the Japanized S-Lang library.
*
* You may distribute under the terms of either the GNU General Public
* License or the Perl Artistic License.
*/
#include <stdio.h>
#include <ctype.h>
#include "config.h"
#include "slang.h"
#include <fcntl.h>
#include "slang.h"
#include "_slang.h"
#include "slkanji.h"
static char *Kcode[] = {
"Ascii",
"Euc",
"Jis",
"Sjis",
/* "Binary", */
/* "SLang", */
NULL };
#if 1
struct _kSLcode_data /* Extended EUC */
{
unsigned char *name;
char *pre_str; /* previous string(escape sequence). If this value unset, code data output... */
unsigned char *func_name;
/* unsigned char *(*convert_func)(); */ /* argument is 1? (or 2?). */
int lenth; /* character byte length */
int width; /* character width */
int mode; /* 0: after here. 1: next word(1*lenth) only. */
/* int enable; */ /* enable/disable */
} *current_set=(struct _kSLcode_data *)NULL, kSLcode_data[0x20] =
{
/* 0x80 */ {"",NULL,NULL,1,1,1},
/* 0x81 */ {"jisx0201", "\x1b(B", NULL, 1, 1, 0},
/* 0x82 */ {0,0,0,0,0,0},
/* 0x83 */ {0,0,0,0,0,0},
/* 0x84 */ {0,0,0,0,0,0},
/* 0x85 */ {0,0,0,0,0,0},
/* 0x86 */ {0,0,0,0,0,0},
/* 0x87 */ {0,0,0,0,0,0},
/* 0x88 */ {0,0,0,0,0,0},
/* 0x89 */ {0,0,0,0,0,0},
/* 0x8a */ {0,0,0,0,0,0},
/* 0x8b */ {0,0,0,0,0,0},
/* 0x8c */ {0,0,0,0,0,0},
/* 0x8d */ {0,0,0,0,0,0},
/* 0x8e */ {"euc-jp-ss2", NULL, NULL, 1, 1, 1},
/* 0x8f */ {"euc-jp-ss3", NULL,NULL, 2,2,1},
/* 0x90 */ {"jisx0208-1983", "\x1b$B", NULL, 2, 2, 0},
/* 0x91 */ {"jisx0208-1978", "\x1b$@", NULL, 2, 2, 0},
/* 0x92 */ {0,0,0,0,0,0},
/* 0x93 */ {0,0,0,0,0,0},
/* 0x94 */ {0,0,0,0,0,0},
/* 0x95 */ {0,0,0,0,0,0},
/* 0x96 */ {0,0,0,0,0,0},
/* 0x97 */ {0,0,0,0,0,0},
/* 0x98 */ {0,0,0,0,0,0},
/* 0x99 */ {0,0,0,0,0,0},
/* 0x9a */ {0,0,0,0,0,0},
/* 0x9b */ {0,0,0,0,0,0},
/* 0x9c */ {0,0,0,0,0,0},
/* 0x9d */ {0,0,0,0,0,0},
/* 0x9e */ {"extended",NULL,NULL,-1,-1,-1},
/* 0x9f */ {"extended",NULL,NULL,-1,-1,-1}
};
int kSLset_code_data(unsigned char *name, char *pre, unsigned char *func, int len, int mod)
{
int i, n;
for (i=0 ; i<32 ; i++)
{
if (kSLcode_data[i].name == NULL && kSLcode_data[i].pre_str == NULL)
break;
}
if(i == 32) return -1; /* kSLcode_data table is full */
kSLcode_data[i].name = (unsigned char*)SLmalloc(strlen(name)+1);
strcpy(kSLcode_data[i].name, name);
kSLcode_data[i].pre_str = (char*)SLmalloc(strlen(pre)+1);
strcpy(kSLcode_data[i].pre_str, pre);
kSLcode_data[i].func_name = (char*)SLmalloc(strlen(func)+1);
strcpy(kSLcode_data[i].func_name, func);
kSLcode_data[i].lenth = len;
kSLcode_data[i].mode = mod;
return i;
}
int kSLfind_code_data(unsigned char *name, char *pre)
{
int i, n;
for (i=0 ; i<0x20 ; i++)
{
if((name && !strcmp(name, kSLcode_data[i].name))
|| (pre && !strcmp(pre, kSLcode_data[i].pre_str)))
return i;
}
return -1;
}
#if 0
void kSLget_code_data_member(int i)
{
SLang_push_string(kSLcode_data[i].name);
SLang_push_string(kSLcode_data[i].pre_str);
SLang_push_string(kSLcode_data[i].func_name);
SLang_push_integer(kSLcode_data[i].lenth);
SLang_push_integer(kSLcode_data[i].mode);
}
#endif
/*
int convert_function(void (unsigned char *buf, int bufsize, *get_func)(void))
{
}
*/
int kSLstrlen(unsigned char *str)
{
register int len, n=0;
register unsigned char *p = str;
if (!p) return 0;
while (*p)
{
if ((0x80 & *p) && (*p < 0xa0)) /* 0x80 <= *p < 0xa0 */
{
len = kSLcode_data[*p & 0x7f].lenth; /* kSLcode_data[*p - 0x80] */
n += len;
p += len;
}
else
n++;
p++;
}
return n;
}
#endif
int kSLcode = SLANG_DEFAULT_KANJI_CODE;
int kSLfile_code = SLANG_DEFAULT_KANJI_CODE, kSLinput_code = SLANG_DEFAULT_KANJI_CODE,
kSLdisplay_code = SLANG_DEFAULT_KANJI_CODE, kSLsystem_code = SLANG_DEFAULT_KANJI_CODE;
#ifdef IBMPC_SYSTEM
int kSLfiAuto = FALSE,
SKanaToDKana = FALSE;
#else
int kSLfiAuto = TRUE,
SKanaToDKana = TRUE;
#endif
int jp_nokanji = NOKANJI;
int ascii = ASCII;
int jp_euc = EUC;
int jp_jis = JIS;
int jp_sjis = SJIS;
int val_true = TRUE;
int val_false = FALSE;
int IsKanji(int c, int code) /*{{{*/
{
/* if(!code) return FALSE; */
c = (c & 0xff);
if(code == SJIS)
{
if((0x80 < c && c < 0xa0) || (0xe0 <= c && c <= 0xfc))
return TRUE;
}
else if(code == EUC)
{
if(0xa0 < c && c < 0xff)
return TRUE;
if(c == 0x8e) return TRUE; /* fake */
}
else if(code == JIS)
{
if(0x20 < c && c < 0x7f)
return TRUE;
}
return FALSE;
}
/*}}}*/
int kSLiskanji(int *n) /*{{{*/
{
return (IsKanji(*n, kSLcode));
}
/*}}}*/
/*
* distinguish KANJI code of pointed position in string
* argment:
* beg: begin of string
* pos: position of string
* return:
* 0: ASCII
* 1: KANJI 1st byte
* 2: KANJI 2nd byte
*/
int kanji_pos(unsigned char *beg, unsigned char *pos) /*{{{*/
{
int ret = 0;
unsigned char *p = beg;
if((beg == pos) || !iskanji(*(pos-1)))
{
if (iskanji(*pos))
return 1; /* KNAJI 1st byte */
else
return ASCII; /* ASCII: 0 */
}
while(p < pos)
{
if (iskanji(*p)) p++;
p++;
}
if(p != pos) return (p - pos +1);
if(iskanji(*p)) return 1;
return ASCII;
}
/*}}}*/
#define CHAR_MASK 0x000000FF
int short_kanji_pos(unsigned short *beg, unsigned short *pos) /*{{{*/
{
int ret = 0;
unsigned short *p = beg;
if((beg == pos) || !iskanji(*(pos-1) & CHAR_MASK))
{
if (iskanji(*pos & CHAR_MASK))
return 1; /* KNAJI 1st byte */
else
return ASCII; /* ASCII: 0 */
}
while(p < pos)
{
if (iskanji(*p & CHAR_MASK)) p++;
p++;
}
if (p != pos) return ((p - pos) +1);
if (iskanji(*p & CHAR_MASK)) return 1;
return ASCII;
}
/*}}}*/
int iskanji2nd(char *str, int col)
{
int j;
if(!col || !iskanji(str[col-1])) return FALSE;
for( j=0 ; j < col ; j++ )
{
if (iskanji(str[j])) j++;
}
if( j == col ) return FALSE;
else return TRUE;
}
char *kcode_to_str(int n)
{
int i=0;
while(Kcode[i])
{
if(i == n) return Kcode[n];
i++;
}
return Kcode[ASCII];
}
#ifdef REAL_UNIX_SYSTEM
int Stricmp(char *src, char *dst)
{
while(*src)
{
if(toupper(*src) != toupper(*dst))
return (toupper(*src) - toupper(*dst));
src++;
dst++;
}
return 0;
}
#endif
int str_to_kcode(char *s)
{
int i;
for(i=0 ; Kcode[i] ; i++)
{
if(!Stricmp(Kcode[i], s)) return i;
}
return (int)NULL;
}
void sjistojis(char *src, char *dst)
{
#if 1
sjistoeuc(src, dst);
*dst++ &= 0x7f;
*dst &= 0x7f;
#else
unsigned int high;
unsigned int low;
high = *src & 0xff;
low = *(src+1) & 0xff;
if (high <= 0x9f)
high -= 0x71;
else
high -= 0xb1;
high = high * 2 + 1;
if (low > 0x7f)
low--;
if (low >= 0x9e)
{
low -= 0x7d;
high++;
}
else
{
low -= 0x1f;
}
*dst = (char)(high & 0x7f);
*(dst+1) = (char)(low & 0x7f);
#endif
}
void jistosjis(char *src, char *dst)
{
int high;
int low;
high = *src & 0x7f;
low = *(src+1) & 0x7f;
if (high & 1)
low += 0x1f;
else
low += 0x7d;
if (low >= 0x7f)
low++;
high = ((high - 0x21) >> 1) + 0x81;
if (high > 0x9f)
high += 0x40;
*dst = (char)high;
*(dst+1) = (char)low;
}
void euctosjis(char *src, char *dst)
{
#if 1
euctojis(src, dst);
jistosjis(dst, dst);
#else
int high;
int low;
high = (*src & 0x7f);
low = (*(src+1) & 0x7f);
if (high & 1)
low += 0x1f;
else
low += 0x7d;
if (low >= 0x7f)
low++;
high = ((high - 0x21) >> 1) + 0x81;
if (high > 0x9f)
high += 0x40;
*dst = (char)high;
*(dst+1) = (char)low;
#endif
}
void sjistoeuc(char *src, char *dst)
{
unsigned int high;
unsigned int low;
high = *src & 0xff;
low = *(src+1) & 0xff;
if (high <= 0x9f)
high -= 0x71;
else
high -= 0xb1;
high = high * 2 + 1;
if (low > 0x7f)
low--;
if (low >= 0x9e)
{
low -= 0x7d;
high++;
}
else
{
low -= 0x1f;
}
*dst = (char)(high | 0x80);
*(dst+1) = (char)(low | 0x80);
}
void euctojis(char *src, char *dst)
{
*dst = *src & 0x7f;
*(dst+1) = *(src+1) & 0x7f;
}
void jistoeuc(char *src, char *dst)
{
*dst = (*src | 0x80);
*(dst+1) = (*(src+1) | 0x80);
}
void notconv(char *src, char *dst)
{
*dst = *src;
*(dst+1) = *(src+1);
}
void (*kSLcodeconv[NCODE][NCODE])() =
{{notconv, notconv, notconv, notconv},
{notconv, notconv, euctojis, euctosjis},
{notconv, jistoeuc, notconv, jistosjis},
{notconv, sjistoeuc, sjistojis, notconv}};
void displaycode_to_SLang(char *src, char *dst)
{
int in = kSLdisplay_code, out = kSLcode;
if (in < 0 || NCODE <= in) in = ASCII;
if (out < 0 || NCODE <= out) out = ASCII;
kSLcodeconv[in][out](src, dst);
}
#define ISMARU(c) (0xca <= (c & 0xff) && (c & 0xff) <= 0xce)
#define ISNIGORI(c) ((0xb6 <= (c & 0xff) && (c & 0xff) <= 0xc4)\
|| (0xca <= (c & 0xff) && (c & 0xff) <= 0xce)\
|| (0xb3 == (c & 0xff)))
void han2zen(in, out, lin, lout, code) /*{{{*/
unsigned char *in, *out;
int *lin, *lout, code;
{
int maru = FALSE, nigori = FALSE;
unsigned char ch1, ch2 = '\0';
int mtable[][2] = {
{129,66},{129,117},{129,118},{129,65},{129,69},{131,146},{131,64},{131,66},
{131,68},{131,70},{131,72},{131,131},{131,133},{131,135},{131,98},{129,91},
{131,65},{131,67},{131,69},{131,71},{131,73},{131,74},{131,76},{131,78},
{131,80},{131,82},{131,84},{131,86},{131,88},{131,90},{131,92},{131,94},
{131,96},{131,99},{131,101},{131,103},{131,105},{131,106},{131,107},{131,108},
{131,109},{131,110},{131,113},{131,116},{131,119},{131,122},{131,125},{131,126},
{131,128},{131,129},{131,130},{131,132},{131,134},{131,136},{131,137},{131,138},
{131,139},{131,140},{131,141},{131,143},{131,147},{129,74},{129,75}
};
if(code == EUC)
{
ch1 = in[1];
if (SKanaToDKana <= 0)
if (in[2] == SS2) ch2 = in[3];
}
else if(code == JIS)
{
ch1 = (in[0] | 0x80);
ch2 = (in[1] | 0x80);
}
else
{
ch1 = in[0];
ch2 = in[1];
}
if( ch1 == 0xa0 )
{
out[0] = ' ';
out[1] = '\0';
*lin = *lout = 1;
if(code == EUC) *lin = 2;
}
else
{
if (SKanaToDKana <= 0)
{
if(ch2 == 0xde && ISNIGORI(ch1))
nigori = TRUE;
else if(ch2 == 0xdf && ISMARU(ch1))
maru = TRUE;
}
out[0] = mtable[ch1 - 0xa1][0];
out[1] = mtable[ch1 - 0xa1][1];
if(nigori)
{
if((0x4a <= out[1] && out[1] <= 0x67) || (0x6e <= out[1] && out[1] <= 0x7a))
out[1]++;
else if(out[0] == 0x83 && out[1] == 0x45)
out[1] = 0x94;
}
else if(maru && 0x6e <= out[1] && out[1] <= 0x7a)
out[1] += 2;
if(nigori || maru) *lin = 2;
else *lin = 1;
if(code == EUC) *lin *= 2;
*lout = 2;
}
}
/*}}}*/
/*
* Not check, if src[n-1] is KANJI first byte, or if src[n-1] is in JIS ESC sequence,
* it return more bigger number. understand?
*
* if you want change "src" string from Kanji *incode to Kanji *outcode,
* this function return to need byte for Code Convert.
*
* htoz: hankaku to zenkaku flag (TRUE or FALSE)
*/
int kSLCheckLineNum(unsigned char *src, int n, int incode, int outcode, int htoz)
{
int i, siz=0;
int kflg = FALSE, hflg = FALSE;
int okflg = FALSE, ohflg = FALSE;
for (i=0 ; i<n ; )
{
if (incode == JIS && src[i] == ESC )
{
if (src[i+1] == '$')
{
if ((src[i+2] == '@') || (src[i+2] == 'B'))
{
i += 3;
kflg = TRUE;
hflg = FALSE;
}
else
{
i += 2;
siz += 2;
}
}
else if (src[i+1] == '(')
{
if ((src[i+2] == 'J') || (src[i+2] == 'B') || (src[i+2] == 'H'))
{
i += 3;
kflg = hflg = FALSE;
}
else if (src[i+2] == 'I')
{
i += 3;
kflg = FALSE;
hflg = TRUE;
}
else
{
i += 2;
siz += 2;
}
}
else
{
i++;
siz++;
}
}
else if ((incode == JIS && kflg && isjiskanji(src[i]))
|| (incode == EUC && iseuckanji(src[i]))
|| (incode == SJIS && issjiskanji(src[i])))
{
i += 2;
siz += 2;
if (outcode == JIS && !okflg)
{
siz += 3;
okflg = TRUE;
ohflg = FALSE;
}
}
else if ((incode == JIS && hflg) || (incode == EUC && src[i] == SS2)
|| (incode == SJIS && ishkana(src[i])))
{
if (htoz)
{
int sc, dc;
unsigned char p[2];
/* But &dst[o] is only SJIS code */
han2zen(&src[i], p, &sc, &dc, incode);
i += sc;
siz += dc;
if (outcode == JIS && !okflg)
{
siz += 3;
okflg = TRUE;
ohflg = FALSE;
}
}
else
{
i++; siz++;
if (incode == EUC) i++;
if (outcode == EUC) siz++;
if (outcode == JIS && !ohflg)
{
siz += 3;
okflg = FALSE;
ohflg = TRUE;
}
}
}
else
{
i++;
siz++;
if (outcode == JIS && (okflg || ohflg))
{
siz += 3;
okflg = ohflg = FALSE;
}
}
}
if (outcode == JIS && (okflg || ohflg))
{
siz += 3;
okflg = ohflg = FALSE;
}
return siz;
}
unsigned char * kSLCodeConv(unsigned char *src, int *siz, int incode, int outcode, int KanaChgFlag) /*{{{*/
{
int dstsiz;
unsigned char *dst, tmp[2];
static int kflg = FALSE, hflg = FALSE;
static int okflg = FALSE, ohflg = FALSE;
int i, o;
void (*kcodeto)(char *, char *);
void (*kanakcodeto)(char *, char *);
char *jiskanji = "\033$B",
*jiskana = "\033(I",
*jisascii = "\033(B";
static char kanji_char[2] = {'\0', '\0'}; /* If last charctor of "src" string is KANJI 1st byte,
* it charctor(KANJI 1st byte) is set this variable.
*
* And, if last charctor of "src" is KANJI 1st byte
* when it used to be this function,
* you must set to this variable.
*/
if (incode < 0 || NCODE <= incode) incode = ASCII;
if (outcode < 0 || NCODE <= outcode) outcode = ASCII;
if (!kSLcode || (incode == ASCII) || (outcode == ASCII) || !src) return src;
else if (incode == outcode)
{
if (KanaChgFlag == FALSE) return src;
}
kcodeto = kSLcodeconv[incode][outcode];
kanakcodeto = kSLcodeconv[SJIS][outcode];
dstsiz = kSLCheckLineNum (src, *siz, incode, outcode, KanaChgFlag);
if (kanji_char[0])
{
dstsiz++;
if (outcode == JIS) dstsiz += 3;
}
if ((dst = (unsigned char*)SLmalloc(dstsiz + 1)) == NULL)
{
/* error message */
return src;
}
for (i=0,o=0 ; i<*siz ; )
{
if (incode == JIS && src[i] == ESC )
{
if (src[i+1] == '$')
{
if ((src[i+2] == '@') || (src[i+2] == 'B'))
{
i += 3;
kflg = TRUE;
hflg = FALSE;
}
else
{
dst[o++] = src[i++];
}
}
else if (src[i+1] == '(')
{
if ((src[i+2] == 'J') || (src[i+2] == 'B'))
{
i += 3;
kflg = hflg = FALSE;
}
else if (src[i+2] == 'I')
{
i += 3;
kflg = FALSE;
hflg = TRUE;
}
else {
dst[o++] = src[i++];
}
}
else
{
dst[o++] = src[i++];
}
}
else if ((incode == JIS && kflg && isjiskanji(src[i]))
|| (incode == EUC && iseuckanji(src[i]))
|| (incode == SJIS && issjiskanji(src[i])) || kanji_char[0])
{
if (i == (*siz -1) && !kanji_char[0])
{
kanji_char[0] = src[i];
i++;
}
else
{
if (outcode == JIS && !okflg)
{
strcpy (&dst[o], jiskanji);
o += strlen (jiskanji);
okflg = TRUE;
ohflg = FALSE;
}
if (kanji_char[0])
{
kanji_char[1] = src[i];
kcodeto(kanji_char, &dst[o]);
kanji_char[0] = '\0';
i--;
}
else
kcodeto (&src[i], &dst[o]);
i += 2;
o += 2;
}
}
else if ((incode == JIS && hflg) || (incode == EUC && src[i] == SS2)
|| (incode == SJIS && ishkana(src[i])))
{
if (KanaChgFlag)
{
int sc, dc;
if (outcode == JIS && !okflg)
{
strcpy (&dst[o], jiskanji);
o += strlen (jiskanji);
okflg = TRUE;
ohflg = FALSE;
}
/* But &dst[o] is only SJIS code */
han2zen (&src[i], &dst[o], &sc, &dc, incode);
kanakcodeto (&dst[o], &dst[o]);
i += sc;
o += dc;
}
else
{
if (outcode == JIS && !ohflg)
{
strcpy (&dst[o], jiskana);
o += strlen (jiskana);
okflg = FALSE;
ohflg = TRUE;
}
if (incode == EUC) i++;
if (outcode == EUC) dst[o++] = SS2;
dst[o] = src[i];
if (outcode == JIS) dst[o] &= 0x7f;
else dst[o] |= 0x80;
i++; o++;
}
}
else
{
if (outcode == JIS && (okflg || ohflg))
{
strcpy (&dst[o], jisascii);
o += strlen (jisascii);
okflg = ohflg = FALSE;
}
dst[o++] = src[i++];
}
}
if (outcode == JIS && (okflg || ohflg))
{
strcpy (&dst[o], jisascii);
o += strlen (jisascii);
okflg = ohflg = FALSE;
}
dst[o] = '\0';
*siz = o;
return dst;
}
/*}}}*/
#if 0
void kSLset_kanji_filecode(int *n)
{
kSLfile_code = *n;
}
void kSLrot_kanji_filecode()
{
kSLfile_code++;
if(BINARY < kSLfile_code) kSLfile_code = ASCII;
}
int kSLget_kanji_filecode()
{
return kSLfile_code;
}
#if 0
char get_1st_kanji_filecode()
{
return *Kcode[kSLfile_code];
}
#endif
void kSLset_kanji_inputcode(int *n)
{
kSLinput_code = *n;
}
void kSLrot_kanji_inputcode()
{
kSLinput_code++;
if(SJIS < kSLinput_code) kSLinput_code = ASCII;
}
int kSLget_kanji_inputcode()
{
return kSLinput_code;
}
#if 0
char get_1st_kanji_inputcode()
{
return *Kcode[kSLinput_code];
}
#endif
void kSLset_kanji_displaycode(int *n)
{
kSLdisplay_code = *n;
}
void kSLrot_kanji_displaycode()
{
kSLdisplay_code++;
if(BINARY < kSLdisplay_code) kSLdisplay_code = ASCII;
}
int kSLget_kanji_displaycode()
{
return kSLdisplay_code;
}
#if 0
char get_1st_kanji_displaycode()
{
return *Kcode[kSLdisplay_code];
}
#endif
void kSLset_kanji_systemcode(int *n)
{
jscode = *n;
}
#if 0
void kSLrot_kanji_systemcode()
{
jscode++;
if(SJIS < jscode) jscode = ASCII;
}
char *get_kanji_systemcode()
{
return Kcode[jscode];
}
#if 0
char get_1st_kanji_systemcode()
{
return *Kcode[jscode];
}
#endif
#endif
#endif
void set_kanji_kSLcode(int *n)
{
kSLcode = *n;
if(kSLis_kanji_code() == FALSE) kSLcode = ASCII;
}
#if 0
void rot_kanji_kSLcode()
{
kSLcode++;
if(kSLis_kanji_code() == FALSE) kSLcode = ASCII;
}
#endif
char *get_kanji_kSLcode(void)
{
return Kcode[kSLcode];
}
#if 0
char get_1st_kanji_jedcode()
{
return *Kcode[kSLcode];
}
#endif
int kSLis_kanji_code(void)
{
if(kSLcode == EUC || /* kSLcode == JIS || */ kSLcode == SJIS)
return TRUE;
else
return FALSE;
}
char *file_kanji_autocode(char *fname)
{
return Kcode[kSLfile_code];
}
/* i: TRUE or FALSE */
void han_to_zen(int *i)
{
SKanaToDKana = *i;
}
int DetectLevel = 2;
/*
* flag
* 0: return
* 1: 100lines test
* 2: if first KANJI code find, it's end.
* 3: file's last made test suru.
*/
#define NLINES 1024
int kcode_detect(char *filename) /*{{{*/
{
int code = ASCII;
FILE *fp;
unsigned char buf[NLINES], *s;
int EightBit=0;
int cnt = -1;
int cod_cnt[4] = {0,0,0,0};
if(!kSLis_kanji_code()) return ASCII;
if(!DetectLevel) return kSLfile_code;
if(DetectLevel == 1) cnt = 100;
if((fp = fopen(filename, "rb")) == NULL) return kSLfile_code;
while (((!code && cnt) || DetectLevel==3) && (s = (char*)fgets((char*)buf, NLINES, fp)) != NULL)
{
code = IsKcode(buf, strlen(buf), &EightBit);
if (0 < cnt) cnt--;
if (code)
{
(cod_cnt[code])++;
cnt = 0;
}
}
fclose(fp);
for (cnt = 1 ; cnt < 4 ; cnt++) if (cod_cnt[cnt]) code = cnt;
if (cod_cnt[EUC] && cod_cnt[SJIS]) code = BINARY;
if (!code && EightBit) code = EUC;
if (!code) code = kSLfile_code;
return code;
}
/*}}}*/
#define issjis2ndkanji(c) ((0x40 <= (unsigned char)(c&0xff) && (unsigned char)(c&0xff) <= 0x7e) \
|| (0x80 <= (unsigned char)(c&0xff) && (unsigned char)(c&0xff) <= 0xfc))
int IsKcode(buf, len, EightBit)
unsigned char *buf;
int len, *EightBit;
{
int code;
int i;
code = ASCII;
for (i=0 ; (i < len) && (code == ASCII) ; )
{
if (*EightBit==0 && buf[i] == ESC)
{
if ((buf[i+1] == '$' && (buf[i+2] == '@' || buf[i+2] == 'B'))
|| (buf[i+1] == '(' && (buf[i+2] == 'J' || buf[i+2] == 'B' || buf[i+2] == 'I')))
{
code = JIS;
}
else
{
i++;
}
}
else if( (buf[i] & 0x80) == 0 )
i++;
else
{
*EightBit = 1;
if(buf[i] == SS2)
{
if(!ishkana(buf[i+1]))
{
code = SJIS;
}
else if(!issjis2ndkanji(buf[i+1]))
{
code = EUC;
}
else
{
i += 2;
}
}
/* else if(ishkana(buf[i]))
{
if(!iseuckanji(buf[i]) || !iseuckanji(buf[i+1]))
{
code = SJIS;
}
else
{
code = EUC;
i += 2;
}
} */
else if(issjiskanji(buf[i]))
{
if(!iseuckanji(buf[i]) || !iseuckanji(buf[i+1]))
{
code = SJIS;
}
else if(!issjis2ndkanji(buf[i+1]))
{
code = EUC;
}
else
{
i += 2;
}
}
else if(!iseuckanji(buf[i]) || !iseuckanji(buf[i+1]))
{
code = 5;
}
else
{
code = EUC;
}
}
}
return code;
}
#define BUFSIZE 4
#define PENDING 10
unsigned int kSLsys_getkey(void) /*{{{*/
{
static unsigned char buf[BUFSIZE], dst[BUFSIZ], nxtchar = '\0';
static int ikflg = FALSE, ihflg = FALSE;
static int okflg = FALSE, ohflg = FALSE;
int ishankana = FALSE, iszenkaku = FALSE;
unsigned int ret;
void (*kcodeto)(char *, char *);
void (*kanakcodeto)(char *, char *);
char *jiskanji = "\033$@",
*jiskana = "\033(I",
*jisascii = "\033(B";
int incode = kSLinput_code, outcode = kSLcode;
if (incode < 0 || NCODE <= incode) incode = ASCII;
if (outcode < 0 || NCODE <= outcode) outcode = ASCII;
if (!SKanaToDKana && kSLinput_code == kSLcode) return _SLsys_getkey();
kcodeto = kSLcodeconv[kSLinput_code][kSLcode];
kanakcodeto = kSLcodeconv[SJIS][kSLcode];
if (kcodeto == notconv) return _SLsys_getkey();
if(nxtchar)
{
ret = buf[0] = nxtchar;
nxtchar = '\0';
}
else
ret = buf[0] = _SLsys_getkey();
buf[1] = '\0';
while(kSLinput_code == JIS && buf[0] == ESC)
{
if(_SLsys_input_pending(PENDING))
{
buf[1] = _SLsys_getkey();
if(_SLsys_input_pending(PENDING))
{
buf[2] = _SLsys_getkey();
}
else
{
SLang_ungetkey_string(&buf[1], 1);
return ret;
}
}
else return ret;
if(buf[1] == '$' && (buf[2] == '@' || buf[2] == 'B'))
{
ikflg = TRUE;
ihflg = FALSE;
}
else if(buf[1] == '(' && buf[2] == 'I')
{
ikflg = FALSE;
ihflg = TRUE;
}
else if(buf[1] == '(' && (buf[2] == 'B' || buf[2] == 'J'))
{
ikflg = ihflg = FALSE;
}
else
{
SLang_ungetkey_string(&buf[1], 2);
return ret;
}
ret = buf[0] = _SLsys_getkey();
}
if((kSLinput_code == JIS && ikflg) || (kSLinput_code == EUC && iseuckanji(ret))
|| (kSLinput_code == SJIS && issjiskanji(ret)))
{
buf[1] = _SLsys_getkey();
kcodeto(buf, dst);
ret = dst[0];
iszenkaku = TRUE;
}
else if((kSLinput_code == JIS && ihflg) || (kSLinput_code == EUC && ret == SS2)
|| (kSLinput_code == SJIS && ishkana(ret)))
{
if(kSLinput_code == EUC)
ret = buf[0] = _SLsys_getkey();
else if(kSLinput_code == JIS)
ret = buf[0] = (ret | 0x80);
/* else if(kSLinput_code == SJIS) */
if(kSLinput_code != EUC && SKanaToDKana && ISNIGORI(ret) && _SLsys_input_pending(PENDING))
{
nxtchar = buf[1] = _SLsys_getkey();
if(kSLinput_code == JIS && nxtchar != ESC &&
(nxtchar == 0x5e || (nxtchar == 0x5f && ISMARU(ret))))
nxtchar = buf[1] = (nxtchar | 0x80);
if(buf[1] == 222 || (buf[1] == 223 && ISMARU(ret)))
{
nxtchar = '\0';
}
}
ishankana = TRUE;
}
if(ishankana)
{
if(SKanaToDKana)
{
int dummy;
buf[0] = (unsigned char)ret;
han2zen(buf, dst, &dummy, &dummy, SJIS);
kanakcodeto(dst, dst);
ret = dst[0];
ishankana = FALSE;
iszenkaku = TRUE;
}
else
{
if(kSLcode == JIS && !ohflg)
{
SLang_ungetkey_string(buf, 1);
SLang_ungetkey_string(jiskana+1, 2);
ohflg = TRUE;
okflg = FALSE;
ret = ESC;
}
else if(kSLcode == EUC)
{
SLang_ungetkey_string(buf, 1);
ret = SS2;
}
}
}
if(iszenkaku)
{
SLang_ungetkey_string(&dst[1], 1);
if(kSLcode == JIS && !okflg)
{
SLang_ungetkey_string(dst, 1);
SLang_ungetkey_string(jiskanji+1, 2);
okflg = TRUE;
ohflg = FALSE;
ret = ESC;
}
}
else if(/* !iszenkaku && */ !ishankana)
{
if(kSLcode == JIS && (okflg || ohflg))
{
if(kSLcode == JIS && !okflg)
{
SLang_ungetkey_string(buf, 1);
SLang_ungetkey_string(jisascii+1, 2);
okflg = ohflg = FALSE;
ret = ESC;
}
}
}
return ret;
}
/*}}}*/
static SLang_Intrin_Fun_Type SLKanji_ITable[] = /*{{{*/
{
MAKE_INTRINSIC_I("iskanji", kSLiskanji, SLANG_INT_TYPE),
#if 0
MAKE_INTRINSIC_SS("sjis_to_slang", notconv, SLANG_VOID_TYPE),
MAKE_INTRINSIC_SS("jis_to_slang", jistosjis, SLANG_VOID_TYPE),
MAKE_INTRINSIC_SS("euc_to_slang", euctosjis, SLANG_VOID_TYPE),
MAKE_INTRINSIC_SS("to_sjis", notconv, SLANG_VOID_TYPE),
MAKE_INTRINSIC_SS("to_euc", sjistoeuc, SLANG_VOID_TYPE),
MAKE_INTRINSIC_SS("to_jis", sjistojis, SLANG_VOID_TYPE),
#endif
SLANG_END_TABLE
};
/*}}}*/
static SLang_Intrin_Var_Type SLKanji_Vars[] = /*{{{*/
{
MAKE_VARIABLE("NOKANJI", &jp_nokanji, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("ASCII", &ascii, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("EUC", &jp_euc, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("JIS", &jp_jis, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("SJIS", &jp_sjis, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("TRUE", &val_true, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("FALSE", &val_false, SLANG_INT_TYPE, 1),
MAKE_VARIABLE("kfile_code", &kSLfile_code, SLANG_INT_TYPE, 0),
MAKE_VARIABLE("kinput_code", &kSLinput_code, SLANG_INT_TYPE, 0),
MAKE_VARIABLE("kdisplay_code", &kSLdisplay_code, SLANG_INT_TYPE, 0),
MAKE_VARIABLE("KfioAuto", &kSLfiAuto, SLANG_INT_TYPE, 0), /* for compatibility */
/* use "kanji_filecode_detect" variable */
MAKE_VARIABLE("kanji_filecode_detect", &kSLfiAuto, SLANG_INT_TYPE, 0),
MAKE_VARIABLE("han_to_zen", &SKanaToDKana, SLANG_INT_TYPE, 0),
MAKE_VARIABLE("SLang_code", &kSLcode, SLANG_INT_TYPE, 0),
MAKE_VARIABLE("KANJI_DETECT", &DetectLevel, SLANG_INT_TYPE, 0),
SLANG_END_TABLE
};
/*}}}*/
int kSLinit_kanji(void) /*{{{*/
{
int ret;
#if 0
if (-1 == SLadd_intrin_fun_table(SLKanji_ITable, NULL)
|| (-1 == SLadd_intrin_var_table (SLKanji_Vars, NULL)))
return -1;
#endif
return 0;
}
/*}}}*/