sj3/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.
 *
 */

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

static void	      getkhtbl(CLREC* clrec);
static void	      cl_kanji(JREC* jrec, CLREC* clrec);
static unsigned char* makekan(unsigned char* s, unsigned char* d, int flg);
static int	      diffknj(JREC* jrec, unsigned char* ptr, int num);
static void	      cl_numcmn(JREC* jrec, CLREC* clrec);

void mkkouho(void) {
	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) {
	unsigned 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);
	}
}

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

unsigned char*
makekan_1byte(unsigned char* s, unsigned char* d, int flg) {
	if((*s & KanjiModeMask) == ZenHiraAssyuku)
		*d++ = 0x10 | (*s & KnjAssyukuMask);
	else
		*d++ = 0x90 | (*s & KnjAssyukuMask);

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

unsigned char*
makekan_knj(unsigned char* s, unsigned char* d, int flg) {

	return makekan(askknj[*s & KnjAssyukuMask], d, flg);
}

unsigned char*
makekan_ofs(unsigned char* s, unsigned char* d, int flg) {

	return makekan(dicbuf + ((*s & KanjiCodeMask) << 8) + *(s + 1),
		       d, flg);
}

unsigned char*
makekan_norm(unsigned char* s, unsigned char* d, int flg) {
	unsigned 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;
}

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

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

	if(flg) *d++ = KanjiStrEnd;

	return d;
}

static unsigned char*
makekan(unsigned char* s, unsigned 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(unsigned char* p, int plen, unsigned char* q, int 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, unsigned char* ptr, int num) {
	KHREC*	      kptr;
	JREC*	      jptr;
	int	      i;
	unsigned char kbuf1[MaxWdKanjiLen];
	unsigned 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(unsigned short flg, unsigned short cond) {
	unsigned short must;

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

	return TRUE;
}

int sel_sjmode(JREC* jrec) {
	unsigned short	i;
	unsigned short* p;
	unsigned 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) {
	unsigned char*	p;
	int		i;
	unsigned short	j;
	unsigned 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));
		}
	}
}