sj4/lib/sj3core/mkkouho.c

/*
 * Copyright (c) 1991-1994  Sony Corporation
 * 
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL SONY CORPORATION BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * 
 * Except as contained in this notice, the name of Sony Corporation
 * shall not be used in advertising or otherwise to promote the sale, use
 * or other dealings in this Software without prior written authorization
 * from Sony Corporation.
 *
 */

/*
 * $SonyRCSfile: mkkouho.c,v $  
 * $SonyRevision: 1.1 $ 
 * $SonyDate: 1994/06/03 08:02:04 $
 */




#include "sj_euc.h"
#include "sj_kcnv.h"
#include "sj_hinsi.h"
#include "sj_suuji.h"
#include "sj_dict.h"

#include "sj_kanakan.h"

static  void	getkhtbl(), cl_kanji();
static  int	diffknj();
static  void	cl_numcmn();
static  u_char	*makekan();

void
mkkouho()
{
	CLREC	*clrec;
	int	keeplen;

	khcount = nkhcount = 0;

	keeplen = clt1st -> cllen;

	clrec = clt1st;

	do {
		getkhtbl(clrec);
		clrec = clrec -> clsort;
	} while (clrec && (keeplen == clrec -> cllen));
}



static void
getkhtbl(CLREC *clrec)
{
	JREC	*jrec;

	jrec = clrec -> jnode;

	switch (jrec -> class) {
	case C_DICT:
		cl_kanji(jrec, clrec);
		break;
	case C_N_ARABIA:
	case C_N_ARACMA:
	case C_N_KAZU:
	case C_N_SUUJI:
	case C_N_NANSUU:
	case C_N_KANKURA:
	case C_N_ARAKURA:
	case C_N_KAZULONG:
	case C_N_KAZULCMA:
	case C_N_SUUJILONG:
		cl_numcmn(jrec, clrec);
		break;
	case C_BUNSETU:
		break;
	case C_MINASI:
	case C_WAKACHI:
		setkouho(clrec, (TypeDicOfs)0, 0);
		break;
	}
}



static void
cl_kanji(JREC *jrec, CLREC *clrec)
{
	u_char	*ptr;
	int	kcount = khcount;

	if (seldict(jrec -> dicid)) {
		(*curdict->getdic)(curdict, jrec -> jseg);
		ptr = dicbuf + jrec->jofsst + 1;

		get_askknj();

		while (*ptr != HINSIBLKTERM) {
			if (diffknj(jrec, ptr, kcount)) {
				setkouho(clrec, (TypeDicOfs)(ptr - dicbuf), 0);
			}
			ptr = skipkstr(ptr);
		}
	}
	else {
		setkouho(clrec, (TypeDicOfs)1, 0);
	}
}



u_char *
makekan_none(u_char *s, u_char *d, int flg)
{
	return d;
}



u_char *
makekan_1byte(u_char *s, u_char *d, int flg)
{
	if ((*s & KANJIMODEMASK) == ZENHIRAASSYUKU)
	  *d++ = 0x10 | (*s & KNJASSYUKUMASK);
	else
	  *d++ = 0x90 | (*s & KNJASSYUKUMASK);

	if (flg) *d++ = KANJISTREND;
	return d;
}



u_char *
makekan_knj(u_char *s, u_char *d, int flg)
{
	return makekan(askknj[*s & KNJASSYUKUMASK], d, flg);
}



u_char	*makekan_ofs(u_char *s, u_char *d, int flg)
{
        return makekan(dicbuf + ((*s & KANJICODEMASK) << 8) + *(s + 1),
                                d, flg);
}



u_char *
makekan_norm(u_char *s, u_char *d, int flg)
{
	u_char c;

	if (*s != 0) {
		c = s[1];
		if (c & 0x80)
		  *d++ = SS3;
		*d++ = *s | 0x80;
		*d++ =  c | 0x80;
	} else {
		*d++ = *s;
	}
	if (flg) *d++ = KANJISTREND;
	return d;
}



u_char *
makekan_ascii(u_char *s, u_char *d, int flg)
{
	u_char c;

	c = s[1];
	if (c & 0x80)
	  *d++ = SS2;
	*d++ = c;

	if (flg) *d++ = KANJISTREND;

	return d;
}



static u_char *
makekan(u_char *s, u_char *d, int flg)
{
	int csize;

	for ( ; ; ) {
		csize = codesize(*s);
		if (s[csize] == KANJISTREND) {
			switch(*s & KANJIMODEMASK) {
			      case ZENHIRAASSYUKU:
                                d = makekan_1byte(s, d, flg); break;

			      case ZENKATAASSYUKU:
                                d = makekan_1byte(s, d, flg); break;

			      case OFFSETASSYUKU:
                                d = makekan_ofs(s, d, flg); break;

			      case AIATTRIBUTE:
                                d = makekan_none(s, d, flg); break;

			      case LEADINGHANKAKU:
				d = makekan_ascii(s, d, flg); break;

			      case KANJIASSYUKU:
				d = makekan_knj(s, d, flg); break;

			      default:
				d = makekan_norm(s, d, flg);
			}
			break;
		}
		else
			switch(*s & KANJIMODEMASK) {
			      case ZENHIRAASSYUKU:
                                d = makekan_1byte(s, d, FALSE); break;

			      case ZENKATAASSYUKU:
                                d = makekan_1byte(s, d, FALSE); break;

			      case OFFSETASSYUKU:
                                d = makekan_ofs(s, d, FALSE); break;

			      case AIATTRIBUTE:
                                d = makekan_none(s, d, FALSE); break;

			      case LEADINGHANKAKU:
				d = makekan_ascii(s, d, FALSE); break;

			      case KANJIASSYUKU:
				d = makekan_knj(s, d, FALSE); break;

			      default:
				d = makekan_norm(s, d, FALSE);
			}
		s += codesize(*s);
	}

	return d;
}



#define	PEND	2
#define	QEND	1
static int
sameknj(u_char *p, u_char plen, u_char *q, u_char qlen)
{
	int	i;
	int	j;
	int	endf = 0;
	int     brkf;

	do {
		if ((i = euc_codesize(*p)) != euc_codesize(*q)) return FALSE;

		brkf = 0;
		for (j = 0; j < i; j++) {
			if (p[j] != q[j] ) {
				brkf = 1;
				break;
			}
		}
		if (brkf) break;

		if (p[i] == KANJISTREND) endf += PEND;
		if (q[i] == KANJISTREND) endf += QEND;

		p += i;
		q += i;
	} while (!endf);

	switch (endf) {
	case (PEND | QEND):
		if (plen == qlen) return TRUE;
		break;

	case PEND:
		i = plen;
		plen = qlen;
		qlen = i;
		p = q;

	case QEND:
		if (p[euc_codesize(*p)] != KANJISTREND) break;
		if ((*p & KANJIMODEMASK) != 0x10 ) break;
		if (qlen != plen - (*p & KANJICODEMASK) - 1) break;
		return TRUE;

	default:
		if (q[euc_codesize(*q)] != KANJISTREND) break;
		if (p[euc_codesize(*p)] != KANJISTREND) break;
		if ((*q & KANJIMODEMASK) != 0x10 ) break;
		if ((*p & KANJIMODEMASK) != 0x10 ) break;
		if (plen - (*p & KANJICODEMASK) != qlen - (*q & KANJICODEMASK))
			break;
		return TRUE;
	}

	return FALSE;
}
#undef	PEND
#undef	QEND



static int
diffknj(JREC *jrec, u_char *ptr, int num)
{
	KHREC	*kptr;
	JREC	*jptr;
	int	i;
	u_char	kbuf1[MAXWDKANJILEN];
	u_char	kbuf2[MAXWDKANJILEN];

	if (jrec -> hinsi == TANKANJI) return TRUE;

	makekan(ptr, kbuf1, TRUE);

	for (i = 0, kptr = kouhotbl ; i < num ; i++, kptr++) {
		if ((jptr = kptr -> clrec -> jnode) == jrec)
			return FALSE;

		if (jptr -> hinsi == TANKANJI) continue;

		if (jptr -> class != jrec -> class) continue;

		if (jptr -> dicid != jrec -> dicid) continue;

		if (jptr -> jseg != jrec -> jseg) continue;

		if (jptr -> sttofs != jrec -> sttofs) continue;

		if (jptr -> stbofs != jrec -> stbofs) continue;

		makekan(dicbuf + kptr -> offs, kbuf2, TRUE);

		if (sameknj(kbuf1, jrec -> jlen, kbuf2, jptr -> jlen))
			return FALSE;
	}

	return TRUE;
}




static int
chrck_numtbl(u_short flg, u_short cond)
{
	u_short	must;

	if (cond = SelNumCond(cond)) {
		if (must = (cond & SELNUMMUST)) {
			if ((flg & must) != must) return FALSE;
			cond &= ~must;
		}
		if (cond && !(cond & flg)) return FALSE;
	}

	return TRUE;
}



int
sel_sjmode(JREC *jrec)
{
	u_short	i;
	u_short	*p;
	u_short	*q;

	switch (jrec -> class) {
	case C_N_ARABIA:
	case C_N_ARACMA:
	case C_N_KAZU:
	case C_N_SUUJI:
	case C_N_NANSUU:
	case C_N_KANKURA:
	case C_N_ARAKURA:
	case C_N_KAZULONG:
	case C_N_KAZULCMA:
	case C_N_SUUJILONG:
		p = q = Selsjadrs(jrec->class - C_N_ARABIA);
		break;

	default:
		return SELARB;
	}

	while ((i = *p++) != SELNUMTERM) {
		if (chrck_numtbl(jrec -> flags, i)) break;
	}

	if (i == SELNUMTERM) i = *q;

	return SelNumFunc(i);
}



static void
cl_numcmn(JREC *jrec, CLREC *clrec)
{
	u_char 	*p;
	int	i;
	u_short	j;
	u_short	*tbl;

	p = cnvstart;
	if ((i = jrec -> sttofs) == SETTOU_DAI)
		p += SttYomiLen(Settou_ptr(i));
	else if (i == SETTOU_KIGOU)
		p++;

	if (jrec -> jofsst) {
		i = sel_sjmode(jrec);

		if (seldict(jrec -> dicid)) {
			(*curdict->getdic)(curdict, jrec -> jseg);

			p = dicbuf + jrec->jofsst + 1;

			while (*p != HINSIBLKTERM) {
				setkouho(clrec, (TypeDicOfs)(p - dicbuf), i);
				p = skipkstr(p);
			}
		}
		else {
			setkouho(clrec, (TypeDicOfs)1, i);
		}
	}
	else {
		tbl = Selsjadrs(jrec->class - C_N_ARABIA);
		while ((j = *tbl++) != SELNUMTERM) {
			if (!chrck_numtbl(jrec -> flags, j)) continue;

			setkouho(clrec, (TypeDicOfs)0, (int)SelNumFunc(j));
		}
	}
}