sj4/lib/sj3core/adddic.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: adddic.c,v $  
 * $SonyRevision: 1.1 $ 
 * $SonyDate: 1994/06/03 08:01:26 $
 */

#include <stdlib.h>
#include <string.h>


#include "sj_euc.h"
#include "sj_kcnv.h"

#include "sj_kanakan.h"

static	void	sprt_seg(TypeDicSeg, TypeDicOfs);
static	void	apnd_uidx(TypeDicSeg, u_char *, int);
static	int	cal_nextym(u_char *);
static	int	usr_freelen();
static  u_int	checkdict(u_char *, TypeGram);



u_int
adddic(u_char *yomi, u_char *kanji, TypeGram hinsi)
{
	u_int		err;
	u_char		yptr[MAXWDYOMILEN + 1];
	u_char		kptr[MAXWDKANJILEN + 1];
	int		klen;
	TypeDicSeg	segnum;
	int		saml;
	TypeDicOfs	dstofs;
	TypeDicOfs	douofs;
	TypeDicOfs	hnsofs;
	TypeDicOfs	knjofs;
	TypeDicOfs	nxtask;
	TypeDicOfs	newsiz;
	TypeDicOfs	oldsiz;
	TypeDicOfs	fresiz;
	TypeIdxOfs	freidx;
	u_char		*douptr;
	u_char		*dstptr;
	TypeDicOfs	pos;
	u_char		*p1;
	int		i;
	int		nlen, plen;
	int		size;
	STDYIN	*stdy;
	STDYOUT	stdydat;

	if (err = addel_arg(yomi, kanji, hinsi, yptr, sizeof(yptr)))
		return err;

	inputyomi = yomi;
	cnvstart = ystart = yptr;
	cnvlen = sstrlen(yptr);

	if (err = checkdict(kanji, hinsi))
		return err;

	if (!curdict -> maxunit)
		return AD_NOTUSERDICT;

	klen = cvtknj(yomi, kanji, kptr);

        newsiz = DOUONBLKSIZENUMBER + cnvlen + (klen !=0 ? klen+1 : 0) + 2;

	if (newsiz > MAXDOUONBLK)
		return AD_OVFLWDOUBLK;
	if (newsiz > curdict->seglen)
		return AD_OVFLWDOUBLK;

	segnum = srchidx((TypeDicSeg)DICSEGBASE, cnvlen);

	for ( ; ; ) {
		(*curdict->getdic)(curdict, segnum);
		i = srchkana(&p1, &saml);
		dstofs = douofs = p1 - dicbuf;
		hnsofs = knjofs = 0;
		if (i) {
			i = srchgram(p1, &p1, hinsi);
			dstofs = hnsofs = p1 - dicbuf;
			if (i) {
				srchkanji(&p1, kptr, klen);
				if (*p1 != HINSIBLKTERM)
					return AD_AREXIST;
				dstofs = knjofs = p1 - dicbuf;
			}
		}

		p1 = dicbuf + douofs;

		if (!hnsofs) {
			oldsiz = 0;
			nlen = cnvlen - saml;
		        newsiz = DOUONBLKSIZENUMBER + nlen;

			nxtask = cal_nextym(p1);
		}
		else {
			oldsiz = newsiz = getsize(p1);
			nxtask = 0;
		}
		if (!knjofs) newsiz += 2;

	        newsiz += (klen != 0 ? klen+1 : 0);

		fresiz = usr_freelen();

		if ((unsigned int) (newsiz - oldsiz - nxtask) <=
		    (unsigned int) fresiz) break;

		if (segend(p1) && (segnum + 1 < curdict->segunit)) {
			segnum++;
			continue;
		}

		if (curdict->segunit >= curdict->maxunit)
			return AD_OVFLWUSRDIC;

		freidx = count_uidx();

		if ((unsigned int) (douofs + newsiz) <= curdict->seglen) {
			if (hnsofs)
				p1 = getntag(p1);
			pos = p1 - dicbuf;

			nlen = getnlen(p1);
		        if ((unsigned int) freidx < getplen(p1) + nlen + 1)
				return AD_OVFLWINDEX;

			if ((*curdict->putdic)(curdict, curdict->segunit))
				return AD_OVFLWUSRDIC;

			sprt_seg(segnum, pos);

			nxtask = 0;
			break;
		}

		if (segend(p1)) {
			if ((unsigned int) freidx < cnvlen + 1)
				return AD_OVFLWINDEX;

			if ((*curdict->putdic)(curdict, curdict->segunit))
				return AD_OVFLWUSRDIC;
			curdict->segunit++;

			(*curdict->getdic)(curdict, curdict->segunit - 1);
			memset(dicbuf, DICSEGTERM, (int)curdict->seglen);
			dicbuf[0] = 0;
			(*curdict->putdic)(curdict, curdict->segunit - 1);
			(*curdict->rszdic)(curdict, curdict->segunit);
			mkidxtbl(curdict);

			segnum++;
		}
		else {
			nlen = getnlen(p1);
			if ((unsigned int) freidx < getplen(p1) + nlen + 1)
				return AD_OVFLWINDEX;

			if ((*curdict->putdic)(curdict, curdict->segunit))
				return AD_OVFLWUSRDIC;

			sprt_seg(segnum, douofs);

			segnum++;
		}
	}

	douptr = dicbuf + douofs;

	if (nxtask) {
		u_char	*tp;

		size = getsize(douptr) - nxtask;
		plen = getplen(douptr) + nxtask;
		nlen = getnlen(douptr) - nxtask;
		*douptr = (size >> 8);
		if (nlen & 0x10)
			*douptr |= NOKORIYOMITOP;
		if (plen & 0x10)
			*douptr |= ASSYUKUYOMITOP;
		*(douptr + 1) = size;
		*(douptr + 2) = ((nlen & 0x0f) | ((plen & 0x0f) << 4));

		p1 = douptr + DOUONBLKSIZENUMBER;
		tp = p1 + nxtask;
		mvmemi(tp, p1, dicbuf + curdict->seglen - tp);
	}

	dstptr = dicbuf + dstofs;
	size = newsiz - oldsiz;
	p1 = dicbuf + curdict->seglen;
	mvmemd(p1 - size, p1, p1 - dstptr - size);

	if (!hnsofs) {
		if (douofs == segtop() - dicbuf) {
			chg_uidx(segnum, yptr, cnvlen);
		}

		*dstptr   = 0;
		nlen = cnvlen - saml;
		if (nlen & 0x10)
			*dstptr |= NOKORIYOMITOP;
		if (saml & 0x10)
			*dstptr |= ASSYUKUYOMITOP;
		*dstptr++ |= (size >> 8);
		*dstptr++  = size;
		*dstptr++  = ((nlen&0x0f)|((saml&0x0f)<<4));

		while (saml < cnvlen) *dstptr++ = yptr[saml++];
	}
	else {
		plen = getplen(douptr);
		nlen = getnlen(douptr);
		*douptr = (newsiz >> 8);
		if (nlen & 0x10)
			*douptr |= NOKORIYOMITOP;
		if (plen & 0x10)
			*douptr |= ASSYUKUYOMITOP;
		*(douptr + 1) = newsiz;
		*(douptr + 2) = ((nlen & 0x0f) | ((plen & 0x0f) << 4));
	}

	if (!knjofs)
		*dstptr++ = hinsi;

	stdydat.stdy1.offset = dstptr - dicbuf;
	for (saml = 0 ; saml < klen ; )
		*dstptr++ = kptr[saml++];
        if (klen > 0)
		*dstptr++ = KANJISTREND;

	if (!knjofs)
		*dstptr++ = HINSIBLKTERM;

	(*curdict->putdic)(curdict, segnum);

	if (StudyExist()) {
		size -= nxtask;
		for (i = STUDYCOUNT, stdy = STUDYDICT ; i-- ; stdy++) {
			if (stdy -> dicid != curdict->dicid)
				continue;
			if (stdy -> seg != segnum)
				continue;
			if (stdy -> offset >= dstofs)
				stdy -> offset += size;
		}

		for (p1 = CLSTUDYDICT ; !iseocl(p1) ; p1 = ClNextTag(p1)) {
			err = sstrncmp(yptr, (u_char *)ClYomiPos(p1),
					(int)ClYomiLen(p1));
			if (err == MATCH) {
				delclsub(p1);
				mkclidx();
				putcldic();
				break;
			} else if (err == OVER)
				break;
		}
	}

	stdydat.stdy1.seg    = segnum;
	stdydat.stdy1.dicid  = curdict->dicid;
	stdydat.stdy1.styno  = 0;
	stdydat.stdy1.sttkj  = 0;
	stdydat.stdy1.ka_kj  = 0;
	stdydat.stdy1.nmflg  = 0;
	stdydat.hinshi       = hinsi;
	stdydat.len          = cnvlen;
	stdydat.sttlen       = 0;
	stdydat.sttfg        = 0;
	stdydat.ka_fg        = 0;
	(void)study(&stdydat);

	return AD_DONE;
}



static int
checksub(u_char *kanji, TypeGram grm)
{
	u_char	*tagp;
	u_char	*ptr;
	u_char	*endp;
	int	flg, nlen;
	int	dounum;
	u_char	buf[MAXWDKANJILEN + 1];

	dicinl = cnvlen;
	dicsaml = 0;
	prevseg = (TypeDicSeg)-1;
	for (;;) {
		if (!(tagp = srchdict(tagp)))
			return 0;
		if (cnvlen == getnlen(tagp) + getplen(tagp))
			break;
	}

	dounum = 0;

	nlen = getnlen(tagp);
        ptr = tagp + DOUONBLKSIZENUMBER + nlen;

	endp = tagp + getsize(tagp);

	while (ptr < endp) {
		flg = (grm == *ptr++);
		while (*ptr != HINSIBLKTERM) {
			if (flg) {
				buf[getkanji(inputyomi, cnvlen, ptr, buf)] = 0;
				if (cmpstr(kanji, buf))
					return -1;
			}
			dounum++;
			ptr = skipkstr(ptr);
		}

		ptr++;
	}

	return dounum;
}



static u_int
checkdict(u_char *kanji, TypeGram grm)
{
	DICTL	*dp;
	int	dounum = 0;
	int	tmp;
	DICT	*tmpdict;

	tmpdict = curdict;
	for (dp = dictlist ; dp ; dp = dp -> next) {

		curdict = dp -> dict;

		if ((tmp = checksub(kanji, grm)) < 0) {
			curdict = tmpdict;
			return AD_AREXIST;
		}

		dounum += tmp;
	}
	curdict = tmpdict;

	if (MAXKOUHONUMBER <= dounum)
		return AD_OVFLWDOUNUM;

	return 0;
}



static int
cal_nextym(u_char *ptr)
{
	int	count = 0;
	u_char	*src;
	int	len;

	if (!segend(ptr)) {
		src = cnvstart + getplen(ptr);

		len = getnlen(ptr);
		ptr += DOUONBLKSIZENUMBER;

 		while (len--) {
			if (*ptr++ == *src++)
				count++;
			else
				break;
		}
	}
	return count;
}



static int
usr_freelen()
{
	u_char	*ptr;

	ptr = segtop();
	while (!segend(ptr))
		ptr += getsize(ptr);

	return curdict->seglen - (ptr - dicbuf);
}



static void
sprt_seg(TypeDicSeg seg, TypeDicOfs ofs)
{
	TypeDicSeg	s;
	u_char		*pos;
	u_char	*p;
	u_char	*q;
	int		i;
	int		j;
	int		ylen, nlen;
	TypeDicID	dicid;
	u_char		yomi[MAXWDYOMILEN];
	STDYIN		*stdy;

	for (s = curdict->segunit - 1 ; s >= seg ; s--) {
		(*curdict->getdic)(curdict, s);
		(*curdict->putdic)(curdict, s + 1);
	}
	curdict->segunit++;
	(*curdict->rszdic)(curdict, curdict->segunit);

	(*curdict->getdic)(curdict, seg + 1);

	pos = dicbuf + ofs;

	for (p = segtop() ; (p <= pos) && !segend(p) ; p = q) {
		q = getntag(p);
		i = getplen(p);
		nlen = getnlen(p);
	        j = (nlen != 0) ? nlen+1: 0;
		p += DOUONBLKSIZENUMBER;
		while (j-- > 0)
			yomi[i++] = *p++;
	}

	nlen = getnlen(pos);
        ylen = (i = getplen(pos)) + (j = nlen);

	apnd_uidx(seg, yomi, ylen);

        set_size(segtop(), getsize(pos) + i, 0, ylen);

	mvmemi(yomi, (p = segtop() + DOUONBLKSIZENUMBER), ylen);

	q = pos + DOUONBLKSIZENUMBER + j;
	i = dicbuf + curdict->seglen - q;
	mvmemi(q, p += ylen, i);
	j = q - p;

	p += i;
	memset(p, DICSEGTERM, (dicbuf + curdict->seglen - p));

	(*curdict->putdic)(curdict, seg + 1);

	if (StudyExist()) {
		dicid = curdict -> dicid;
		for (i = STUDYCOUNT, stdy = STUDYDICT ; i-- > 0 ; stdy++) {
			if (stdy -> dicid != dicid)
				continue;
			else if (stdy -> seg < seg)
				continue;
			else if (stdy -> seg > seg)
				stdy -> seg += 1;
			else if (stdy -> offset >= ofs) {
				stdy -> seg += 1;
				stdy -> offset -= j;
			}
		}
	}

	(*curdict->getdic)(curdict, seg);
	memset(dicbuf + ofs, DICSEGTERM, (int)(curdict->seglen - ofs));
	(*curdict->putdic)(curdict, seg);
}



static void
apnd_uidx(TypeDicSeg seg, u_char *yomi, int len)
{
	u_char	*p;
	u_char	*q;

	p = get_idxptr(seg);
	while (*p++)
		;

	q = idxbuf + curdict->idxlen;
	mvmemd(q - (len + 1), q, (int)(q - (len + 1) - p));

	while (len--)
		*p++ = *yomi++;
	*p = 0;

	(*curdict->putidx)(curdict, 0);

	mkidxtbl(curdict);
}