int eemalda_ainsus( void )
{
int i,r;
FSXSTRING tmp1;
for (i=0; i < 11; i++) /* eemalda kõik gen-st tulenevad ainsuse vormid */
{
tmp1 = (const FSxCHAR *)ains_vorm;
tmp1 += analog_v[i];
r = eemalda( (FSxCHAR *)(const FSxCHAR *)tmp1 );
if ( !r )
return( 0 );
}
r = eemalda( FSxSTR("sg n") ); /* eemalda ainsuse nimetav */
if ( !r )
return( 0 );
r = eemalda( FSxSTR("sg g") ); /* eemalda ainsuse omastav */
if ( !r )
return( 0 );
r = eemalda( FSxSTR("sg p") ); /* eemalda ainsuse osastav */
if ( !r )
return( 0 );
r = eemalda( FSxSTR("adt") ); /* eemalda aditiiv */
r = eemalda( FSxSTR("(adt)") ); /* eemalda aditiiv */
return(1);
}
void MORF0::arvamin(
const FSXSTRING *sisse, // sisends6na
MRFTULEMUSED *tul)
{
if (!mrfFlags.Chk(MF_OLETA)) // ei tulegi oletada
return;
int res;
FSXSTRING sona= *sisse;
TaheHulgad::AsendaMitu(&sona, TaheHulgad::uni_kriipsud, TaheHulgad::amor_kriipsud);
tul->tagasiTasand=0;
tul->mitmeS6naline = 1; // s.t. oletame 1 s�na, mitte v�ljendeid
tul->keeraYmber = false;
tul->eKustTulemused=eMRF_AO; // anal��sid oletajast
tul->DelAll();
if (sisse->GetLength() >= STEMLEN) // tegelt seda juba chkmin() kontrollis
{
tul->Add((const FSxCHAR *)*sisse, FSxSTR(""), FSxSTR(""), FSxSTR("Z"), FSxSTR("")); // parema puudusel
return;
}
res = arvax( tul, &sona );
if (res != ALL_RIGHT)
{
tul->eKustTulemused=eMRF_XX;
tul->s6na = FSxSTR("");
throw(VEAD(ERR_MG_MOOTOR, ERR_MINGIJAMA, __FILE__, __LINE__, "$Revision: 542 $")); //jama!
}
}
int Xstr_2_int // ==0:pole numbrit; >0: niimitmest baidist tehti m�rgiga t�isarv;
(
int *i, // saadud m�rgiga t�isarv
const FSxCHAR *xstr // l�htestring
)
{
int n=0, x;
bool miinus;
if(*xstr == (FSxSTR("-"))[0])
{
miinus = true;
n++;
}
else
{
miinus = false;
if(*xstr == (FSxSTR("+"))[0])
{
n++;
}
}
if(TaheHulgad::number.Find(xstr[n]) == -1)
{
return 0; // pole number
}
for(x=0; xstr[n] && TaheHulgad::number.Find(xstr[n]) >= 0; n++)
{
x = 10 * x + (xstr[n]-(FSxSTR("0"))[0]);
}
*i = miinus ? -x : x;
return n; // n baiti teisendasime t�isarvuks
}
LYLI *ETMRFAS::Flush(void)
{
if(mrfFlags->ChkB(MF_GENE)==false)
return ETMRFA::Flush(); //analüüs
// läheb sünteesiks
FSXSTRING gTyvi, gKigi, gSl, gVormid;
FSXSTRING gnaidis; // sõna, mis peaks genetavas paradigmas olema, nt palk puhul palgi või palga
int pos3;
int pos1, pos2;
MRFTULEMUSED geneOut;
int idx;
LYLI* tmpGeneLyliPtr=aGene.Lyli(0,A2_SUVALINE_LYLI,&idx);
if(tmpGeneLyliPtr==NULL)
return NULL; // ei saanud ahelast midagi
// saime ahelast midagi...
if((tmpGeneLyliPtr->lipp & PRMS_SONA)!=PRMS_SONA)// Kui pole lemme+vorm (on TAG vms)...
return aGene.LyliPtrOut(idx); //...tõstame mälu vabastamata ahelast välja
// ja anname genemata tagasi
// lemma+vorm, tuleb geneda
// jätame ta esialgu sünteesiahelasse ja teeme seal mida vaja
geneStr=*(tmpGeneLyliPtr->ptr.pStr); //seda hakkame genema: 'tüvi' //_sl_ vormid//kigi'
if(geneStr.GetLength() <= 0)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
geneStr.Trim();
if((pos1=geneStr.Find(FSxSTR(" //_"))) <= 0)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
gTyvi=geneStr.Left(pos1);
// näidise olemasolu puhuks
pos2 = gTyvi.Find(FSxSTR(" ("));
pos3 = gTyvi.Find(FSxSTR(")"));
if (pos2 != -1 && pos3 > pos2+4 && pos3==gTyvi.GetLength()-1) // näidis leitigi
{
gnaidis = gTyvi.Mid(pos2+2, pos3-pos2-2);
gTyvi=geneStr.Left(pos2);
}
if(geneStr.GetLength() < pos1+5 || geneStr[pos1+5]!=(FSxCHAR)'_')
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
gSl=geneStr.Mid(pos1+4,1);
if((pos2=geneStr.Find(FSxSTR(" //"), pos1+5))<=0)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
if(pos1+5 < pos2)
{
gVormid=geneStr.Mid(pos1+6, pos2-pos1-6);
gVormid.Trim();
}
// else vormid==""
gKigi=geneStr.Mid(pos2+3, geneStr.GetLength()-pos2-3);
gKigi.Trim();
//if(Synt1(geneOut, &gTyvi, &gSl, &gVormid, &gKigi)==false)
if(SyntDetailne(geneOut, &gTyvi, &gnaidis, &gSl, &gVormid, &gKigi)==false)
{
// jama või ei õnnestunud sünteesida
}
tmpGeneLyliPtr->Start(geneOut, PRMS_MRF);
geneStr=FSxSTR("\0");
return aGene.LyliPtrOut(idx); // tõstame genetud asjaga lüli
// mälu vabastamata ahelast välja
}
// return true, kui s�na v�iks suurt�helisuse poolest olla p�risnimi
bool OLETAJA_DCT::sobiks_nimeks(FSXSTRING *sisendsona)
{
//FSXSTRING S6na;
int S6naPikkus, i;
if (!sobiks_sonaks(sisendsona))
return false;
S6naPikkus = sisendsona->GetLength();
// ei saa suurt�helisust niisama lihtsalt kontrollida,
// sest pole k�ikv�imalike ime-suurt�htede loendit
if (!TaheHulgad::OnSuur(sisendsona, 0) && !TaheHulgad::OnSuur(sisendsona, 1)) // pole Nimi ega eNimi
return false; // 1. v�i ��rmisel juhul 2. t�ht oli v�ike
for (i=S6naPikkus-1; i > 0; i--)
{
if (!TaheHulgad::OnPisi(sisendsona, i))
break;
}
// S6na = *sisendsona;
// S6na.TrimRight(TaheHulgad::vaiketht);
// spik = S6na.GetLength();
if ( i > S6naPikkus-3 ) // liiga l�hike ots
{
if (TaheHulgad::OnAlguses(sisendsona, FSxSTR("Mc")) ||
TaheHulgad::OnAlguses(sisendsona, FSxSTR("Mac")))
return true;
if (!TaheHulgad::OnSuur(sisendsona, i-1)) // ja pole nt NoWe
return false;
}
return true;
}
int gu_lisa( void )
{
int r;
r = lisa( gu_tyvi, gu_format, FSxSTR("gu") );
if ( !r )
return(0);
if ( !FSxSTRCMP(gu_format, FSxSTR("GU")) ) /* lk 54 */
{
r = lisa( gu_tyvi, FSxSTR("GEM"), FSxSTR("gem") );
if ( !r )
return(0);
r = lisa( gu_tyvi, FSxSTR("GE"), FSxSTR("ge") );
if ( !r )
return(0);
}
else
{
r = lisa( gu_tyvi, FSxSTR("KEM"), FSxSTR("gem") );
if ( !r )
return(0);
r = lisa( gu_tyvi, FSxSTR("KE"), FSxSTR("ge") );
if ( !r )
return(0);
}
return(1);
}
int MORF0::arvamitte(MRFTULEMUSED *tulemus, FSXSTRING *S6na)
{
if ( TaheHulgad::PoleMuudKui(S6na, &(TaheHulgad::s_punktuatsioon))) /* ilmselt _Z_ */
{ /* korraldame va"ljatryki */
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR(""), FSxSTR(""), FSxSTR("Z"), FSxSTR(""));
}
return ALL_RIGHT;
}
// p�risnimele sobimatute muutumismallide elimineerimiseks
bool OLETAJA_DCT::pn_sobiv_kirje(void)
{
assert(ot_viimane_kirje.tyypsona);
if (!FSxSTRCMP(ot_viimane_kirje.tyypsona, FSxSTR("praene")))
return false;
if (!FSxSTRCMP(ot_viimane_kirje.tyypsona, FSxSTR("heeringas")))
return false;
if (!FSxSTRCMP(ot_viimane_kirje.tyypsona, FSxSTR("kreemjas")))
return false;
return true;
}
int ma_lisa( void )
{
int r;
r = lisa( ma_tyvi, ma_format, FSxSTR("ma") );
if ( !r )
return(0);
r = lisa( ma_tyvi, FSxSTR("VAT"), FSxSTR("vat") ); /* analoogiareegel (lk 53) */
if ( !r )
return(0);
return(1);
}
int me_lisa( void )
{
int r;
r = lisa( me_tyvi, me_format, FSxSTR("me") );
if ( !r )
return(0);
r = lisa( me_tyvi, FSxSTR("TE"), FSxSTR("te") );
if ( !r )
return(0);
r = lisa( me_tyvi, FSxSTR("VAD"), FSxSTR("vad") );
if ( !r )
return(0);
return(1);
}
/*
* return 1, kui ty-le vo~iks "ne" otsa kleepida, et saada omaduss. tu"ve
*/
int MORF0::sobiks_ne( FSXSTRING *ty, int pikkus )
{
int j;
int silpe, silp;
FSXSTRING tyvi;
silpe = 0;
silp = VANA_SILP;
tyvi = (const FSxCHAR *)(ty->Left(pikkus));
for (j=0; j < pikkus; j++)
{
if (TaheHulgad::OnTaishaalik(tyvi[j]))
{
if (silp == VANA_SILP)
silpe++;
silp = UUS_SILP;
}
else
{
silp = VANA_SILP;
}
}
if ( silpe < 2 ) /* liiga lu"hike so~na */
return 0;
if ( TaheHulgad::OnLopus(&tyvi, FSxSTR("akt")) )
return 1; /* na"it. "...iil" */
if ( TaheHulgad::OnTaishaalik(tyvi[pikkus-3]) &&
TaheHulgad::OnTaishaalik(tyvi[pikkus-2]) &&
!TaheHulgad::OnTaishaalik(tyvi[pikkus-1]) )
return 1; /* na"it. "...iil" */
return 0;
}
/*
* return minimaalne tyvepikkus, mida on m�tet otsida
*/
int MORF0::minipik(FSXSTRING *ty)
{
FSXSTRING ttt;
int pik=2;
ttt = (const FSxCHAR *)(ty->Left(3));
if ( ttt == FSxSTR("alu") || ttt == FSxSTR("ude") || ttt == FSxSTR("pan") )
pik = 4;
else
{
ttt = (const FSxCHAR *)(ttt.Left(2));
if ( ( (dctLoend[9])[(FSxCHAR *)(const FSxCHAR *)ttt] ) == -1 )
pik = 3;
}
return(pik);
}
int v_lisa( void )
{
int r;
r = lisa( v_tyvi, v_format, FSxSTR("v") );
return(r);
}
//
// 2.ring: indeksid asemele
//
void PaneIndeksidAsemele(
CFSFileName &inFileName,
CFSFileName &outFileName)
{
CPFSFile in, out;
CFSbaseSTRING rida, uusRida;
if(in.Open(inFileName, FSTSTR("rb"))==false)
{
printf(FSTSTR("%s: ei saa faili avatud\n"), (const FSTCHAR *)inFileName);
exit( EXIT_FAILURE );
}
printf(FSTSTR("%s "), (const FSTCHAR *)outFileName);
if(out.Open(outFileName, FSTSTR("wb+"))==false)
{
printf(FSTSTR("\n%s: ei saa faili luua\n"), (const FSTCHAR *)outFileName);
exit( EXIT_FAILURE );
}
while(in.ReadLine(&rida)==true)
{
int idx;
TeeSLL(&rida); // jupitame uuesti sisendrea
if((idx=sonaliikideMassiiv.GetIdx(&sonaLiigiString)) < 0)
{
printf(FSTSTR("Ei leia juba tehtud sõnaliigijärjendit\n"));
assert( false );
}
// paneme uue rea kokku
uusRida.Format(FSxSTR("%s %d=%s\n"), (const FSxCHAR*)tyvi, idx, (const FSxCHAR*)tyveInf);
out.WriteString((const FSxCHAR *)(uusRida), uusRida.GetLength());
}
in.Close();
out.Close();
}
int s_lisa( void )
{
int r;
r = lisa( s_tyvi, s_format, FSxSTR("s") );
return(r);
}
int takse_lisa( void )
{
int r;
r = lisa( takse_tyvi, takse_format, FSxSTR("takse") );
return(r);
}
void ETMRFAS::Clr(void)
{
ETMRFA::Clr();
aGene.DelAll();
geneStr=FSxSTR("\0");
//delete retGeneLyliPtr;
//retGeneLyliPtr=NULL;
}
// Muditud klassindust 2002.kevad
// KOtsi
// ==true: v6ti oli kahendtabelis element nr *idx
// ==false: v6ti polnud kahendtabelis, lisada *idx-indaks
//
bool cTYVEDETABEL::KOtsi
(
const BTABLE *kt,
const FSxCHAR *v6ti,
const int vPikkus,
int *idx) const
{
ASSERT( vPikkus >=0 && v6ti != NULL);
int i;
int v = 0,
p = kt->ktSuurus - 1,
k = (p - v) / 2,
n=0;
if(vPikkus<=0 || v6ti==NULL || *v6ti==FSxSTR("")[0])
{
*idx=0;
return false;
}
// Otsime kahendtabelist
//
while(v <= p)
{
const FSxCHAR *ptr = kt->v6tmed + kt->kTabel[k].s_nihe;
int l1=vPikkus;
int l2=kt->kTabel[k].len;
int ll=l1 < l2 ? l1 : l2;
ASSERT( l1 > 0 && l2 >= 0 && ll >= 0);
if(ll)
{
for(i=0; i < ll && (n=TaheHulgad::FSxCHCMP(v6ti[i], ptr[i]))==0; i++)
;
if(n==0)
n = l1 - l2;
}
else
{
n=1; // oli 2ndtabeli 1mene 0pikkusega element
ASSERT( k==0 && kt->kTabel[k].len==0 );
}
if(n < 0)
{
p = k - 1; // v6ti < kahendtabeli jooksvast v�tmest
}
else if(n > 0)
{
v = k + 1; // v6ti > kahendtabeli jooksvast v�tmest
}
else // n == 0 st oli kahendtabelis
{
*idx = k; // v6ti == kahendtabeli jooksva v�tmega
return true; // Leidsin kahendtabelist!
}
k = v + (p - v) / 2;
}
*idx = v; // Polnud kahendtabelis.
return false;
}
int lisa_ainsus( FSXSTRING *stem )
{
int i,r;
FSXSTRING tmp1;
for (i=0; i < 11; i++) /* lisa kõik gen-st tulenevad ainsuse vormid */
{
tmp1 = (const FSxCHAR *)ains_vorm;
tmp1 += analog_v[i];
r = lisa( stem, analog_l[i], (FSxCHAR *)(const FSxCHAR *)tmp1 );
if ( !r )
return( 0 );
}
r = lisa( stem, FSxSTR("D"), FSxSTR("pl n") ); /* lisa mitmuse nimetav */
if ( !r )
return( 0 );
return(1);
}
//
// Tükelda sisendfaili rida
//
void TeeSLL(CFSbaseSTRING *rida) // real alati 1 tühik lõpus
{
int tyveLopp, tykikeseAlgus, tykikeseLopp;
rida->TrimRight();
(*rida) += FSxSTR(" ");
if((tyveLopp=rida->Find((FSxSTR(" "))[0]))== -1)
{
printf(FSTSTR("Ei leia tüve lõppu\n"));
assert( false );
}
tyvi = rida->Left(tyveLopp);
tykikeseAlgus=tyveLopp+1;
sonaLiigiString=(const FSxCHAR*)(rida->Mid(tykikeseAlgus, 1));
if((*rida)[tykikeseAlgus+1] != (FSxSTR("="))[0])
{
printf(FSTSTR("Võrdusmärk puudu\n"));
assert( false );
}
if((tykikeseLopp=rida->Find((FSxSTR(" "))[0], tykikeseAlgus))== -1)
{
printf(FSTSTR("Jama\n"));
assert( false );
}
tyveInf=rida->Mid(tykikeseAlgus+2, tykikeseLopp-tykikeseAlgus-2);
tykikeseAlgus=tykikeseLopp+1;
tykikeseLopp=rida->Find((FSxSTR(" "))[0], tykikeseAlgus);
while((*rida)[tykikeseAlgus] != 0)
{
sonaLiigiString +=(const FSxCHAR*)(rida->Mid(tykikeseAlgus, 1));
if((*rida)[tykikeseAlgus+1] != (FSxSTR("="))[0])
{
printf(FSTSTR("Võrdusmärk puudu\n"));
assert( false );
}
if((tykikeseLopp=rida->Find((FSxSTR(" "))[0], tykikeseAlgus))== -1)
{
printf(FSTSTR("Jama\n"));
assert( false );
}
tyveInf += FSxSTR(" ");
tyveInf += rida->Mid(tykikeseAlgus+2, tykikeseLopp-tykikeseAlgus-2);
tykikeseAlgus=tykikeseLopp+1;
tykikeseLopp=rida->Find((FSxSTR(" "))[0], tykikeseAlgus);
}
}
int da_lisa( void )
{
int r;
r = lisa( da_tyvi, da_format, FSxSTR("da") );
if ( !r )
return(0);
if ( !FSxSTRCMP(da_format, FSxSTR("DA")) ) /* lk 54 */
r = lisa( da_tyvi, FSxSTR("DES"), FSxSTR("des") );
else if ( !FSxSTRCMP(da_format, FSxSTR("TA")) )
r = lisa( da_tyvi, FSxSTR("TES"), FSxSTR("des") );
else
r = lisa( da_tyvi, FSxSTR("ES"), FSxSTR("des") );
if ( !r )
return(0);
return(1);
}
int eemalda_mitmus( void )
{
int i,r;
FSXSTRING tmp1;
for (i=0; i < 11; i++) /* eemalda kõik gen-st tulenevad mitmuse vormid */
{
tmp1 = (const FSxCHAR *)mitm_vorm;
tmp1 += analog_v[i];
r = eemalda( (FSxCHAR *)(const FSxCHAR *)tmp1 );
if ( !r )
return( 0 );
}
r = eemalda( FSxSTR("pl n") ); /* eemalda mitmuse nimetav */
if ( !r )
return( 0 );
r = eemalda( FSxSTR("pl g") ); /* eemalda mitmuse omastav */
if ( !r )
return( 0 );
r = eemalda( FSxSTR("pl p") ); /* eemalda mitmuse osastav */
if ( !r )
return( 0 );
return(1);
}
int MORF0::arvapn2(MRFTULEMUSED *tulemus, FSXSTRING *S6na, int S6naPikkus)
{
int i;
int maha;
FSXSTRING tyvi;
FSXSTRING lopp;
FSXSTRING sl;
FSXSTRING vormid;
const FSxC5I1 *lopu_info;
i = S6na->ReverseFind(APOSTROOF);
if (i == -1)
return ALL_RIGHT;
if (S6naPikkus - i > PN_ENDLEN) // O'Connorist
return ALL_RIGHT;
if (i < S6naPikkus-1 && TaheHulgad::OnAeiu((*S6na)[i+1]))
maha=1; // Paige'iks tyvi=Paige lopp=ks
else
maha=0;
if (mrfFlags.Chk(MF_ALGV))
tyvi = S6na->Left(i);
else
tyvi = S6na->Left(i+1);
lopp = S6na->Mid(i+1+maha);
if (TaheHulgad::SuurAlgustaht(S6na))
sl = LIIK_PARISNIMI;
else
sl = LIIK_YLDNIMI;
// if (lopp == FSxSTR("d")) // d-loppu vt eraldi
// vormid = FSxSTR("pl n, sg p, ");
if (lopp.GetLength() == 0) // 0-loppu vt eraldi
{
if (maha == 0 && sl == LIIK_YLDNIMI) // nt f****n', tolgend'
return ALL_RIGHT;
lopp = FSxSTR("0");
tulemus->Add(tyvi, lopp, FSxSTR(""), sl, FSxSTR("sg g, "));
if (maha)
tulemus->Add(tyvi, lopp, FSxSTR(""), sl, FSxSTR("sg p, "));
}
else // muud lopud
{
for (lopu_info = oletajaDct.pn_lopud_jm.Get((const FSxCHAR *)lopp); lopu_info;
lopu_info = oletajaDct.pn_lopud_jm.GetNext())
{
if (lopu_info->tyyp == 1) // sobib p�risnimele
tulemus->Add(tyvi, lopp, FSxSTR(""), sl, lopu_info->vorm);
}
}
return ALL_RIGHT;
}
int mata_lisa( void )
{
int r;
r = lisa( mata_tyvi, mata_format, FSxSTR("mata") );
if ( !r )
return(0);
r = lisa( mata_tyvi, FSxSTR("MAS"), FSxSTR("mas") );
if ( !r )
return(0);
r = lisa( mata_tyvi, FSxSTR("MAST"), FSxSTR("mast") );
if ( !r )
return(0);
r = lisa( mata_tyvi, FSxSTR("MAKS"), FSxSTR("maks") );
if ( !r )
return(0);
return(1);
}
int sime_lisa( void )
{
int r;
r = lisa( sime_tyvi, sime_format, FSxSTR("sime") );
if ( !r )
return(0);
if ( !FSxSTRCMP(sime_format, FSxSTR("IME")) ) /* lk 54 */
r = lisa( sime_tyvi, FSxSTR("ITE"), FSxSTR("site") );
else
r = lisa( sime_tyvi, FSxSTR("SITE"), FSxSTR("site") );
if ( !r )
return(0);
return(1);
}
int sin_lisa( void )
{
int r;
r = lisa( sin_tyvi, sin_format, FSxSTR("sin") );
if ( !r )
return(0);
if ( !FSxSTRCMP(sin_format, FSxSTR("IN")) ) /* lk 54 */
r = lisa( sin_tyvi, FSxSTR("ID"), FSxSTR("sid") );
else
r = lisa( sin_tyvi, FSxSTR("SID"), FSxSTR("sid") );
if ( !r )
return(0);
return(1);
}
bool ETMRFAS::ArvaGene2( // -1==siiber; 0==ok
MRFTULEMUSED *pValja,
MRFTULEMUSED *pMrfTul,
const FSXSTRING *pGeneLiik,
const FSXSTRING *pGeneVormid,
const FSXSTRING *pGeneKigi)
{
//char algv_lopp;
//int algv_vorm,
int viimne;
FSXSTRING gene_liik = KOIK_LIIGID; // igaks juhuks
FSXSTRING genetud_tyvi, gene_t1, gene_t2, ette, kigi;
int i, sgn=0;
FSxCHAR vi;
if (pMrfTul->Get_vormid(FSxSTR("sg n,")) != -1)
sgn = 1; // analyyside hulgas leidub sg n
i = pMrfTul->Get_vormid(FSxSTR("ma,"));
if (i != -1 && pMrfTul->Get_vormid(FSxSTR("tama,")) != i)
sgn = 1; // analyyside hulgas leidub ma
if (*pGeneLiik == FSxSTR("*"))
gene_liik = KOIK_LIIGID;
else
gene_liik = (const FSxCHAR*)*pGeneLiik;
// vt kõiki algvorme
//
kigi = FSxSTR("");
viimne = pValja->idxLast;
for (i=0; i < pMrfTul->idxLast; i++)
{
if ((*pMrfTul)[i]->vormid.Find(FSxSTR("?")) != -1 || (*pMrfTul)[i]->vormid.Find(FSxSTR(",")) == -1) // muutumatu s�na
{
if (gene_liik.Find((*pMrfTul)[i]->sl) == -1)
continue; // polnud sobiv sõnaliik
if (sgn == 0 || // analyyside hulgas polegi käänduvat sõna või ...
pGeneVormid->GetLength() == 0 || // tahetaksegi muutumatut sõna
pGeneVormid->Find(FSxSTR("sg n")) >=0 ) // küsitaksegi ainsuse nimetavat
{ // et enne //_*_ // ja enne //_*_ sg n, // enne //_*_ sg g, // oleks kooskõlas
genetud_tyvi = pMrfTul->rec[i]->tyvi;
genetud_tyvi.Remove((FSxCHAR)'_');
genetud_tyvi.Remove((FSxCHAR)'=');
genetud_tyvi.Remove((FSxCHAR)'+');
vi = genetud_tyvi[genetud_tyvi.GetLength()-1];
if (pGeneKigi->GetLength()>0)
{
if (!TaheHulgad::OnHelitu(vi))
kigi = FSxSTR("gi");
else
kigi = FSxSTR("ki");
}
pValja->Add(
(const FSxCHAR *)genetud_tyvi,
FSxSTR(""), // 0-lõpu puhul 0 ei lisa
(const FSxCHAR *)kigi, //
(*pMrfTul)[i]->sl,
(*pMrfTul)[i]->vormid);
continue;
}
}
if ( (*pMrfTul)[i]->vormid.Find(FSxSTR("sg n,"))!= -1 )
{
sgn=1; //* on leitud lihtsaim algvorm *
//algv_lopp = null_lopp;
//algv_vorm = sg_n;
}
else if ((*pMrfTul)[i]->vormid.Left(3) == FSxSTR("ma,"))
{
sgn=1; //* on leitud lihtsaim algvorm *
//algv_lopp = lopp_ma;
//algv_vorm = ma;
}
else if ( omastavanr(&((*pMrfTul)[i]->tyvi)) != -1 )
{
sgn=1; //* on leitud lihtsaim algvorm *
//algv_lopp = null_lopp;
//algv_vorm = sg_g;
}
else if (!sgn && (*pMrfTul)[i]->vormid.Find(FSxSTR("pl n,"))!= -1) //* votan d lopust maha *
{
if ((*pMrfTul)[i]->tyvi.Right(2) == FSxSTR("nu") ||
(*pMrfTul)[i]->tyvi.Right(2) == FSxSTR("tu") ||
(*pMrfTul)[i]->tyvi.Right(2) == FSxSTR("du"))
{ // nt vastsündinu+d
(*pMrfTul)[i]->tyvi += FSxSTR("d");
(*pMrfTul)[i]->lopp = FSxSTR("");
(*pMrfTul)[i]->sl = LIIK_A;
sgn=1; // vastsündinud+0 on lihtsaim algvorm
}
else
{
//algv_lopp = lopp_d;
//algv_vorm = pl_n;
}
}
else
{
continue; // seda rohkem ei vt, sest pole algvorm
}
if (gene_liik.Find((*pMrfTul)[i]->sl) == -1)
continue; // polnud sobiv sõnaliik
gene_t1 = (*pMrfTul)[i]->tyvi;
// siia tuleb oletamine ise
FSXSTRING analoogvorm, v_analoogvorm;
FSXSTRING tyhi;
bool rs;
for (analoogvorm=oletajaDct.sobiv_analoog(&gene_t1, &(*pMrfTul)[i]->sl);; analoogvorm=oletajaDct.jargmine_sobiv_analoog())
{
int mitu;
int a_pikkus, g_pikkus, pikkus;
int res;
MRFTULEMUSED tulemus, analoog_tulemus;
int tagasi;
a_pikkus = analoogvorm.GetLength();
if (a_pikkus == 0) // polnud rohkem sobivaid analooge
break;
g_pikkus = gene_t1.GetLength();
pikkus = a_pikkus > g_pikkus ? g_pikkus : a_pikkus;
// leia, kui pikk jupp on sõnadel lõpus ühesugune
for (mitu = 1; mitu <= pikkus; mitu++)
{
if (analoogvorm[a_pikkus-mitu] != gene_t1[g_pikkus-mitu])
break;
}
mitu--;
if ((*pMrfTul)[i]->sl == LIIK_VERB)
{
v_analoogvorm = analoogvorm;
v_analoogvorm += FSxSTR("ma");
res = chkwrd(&tulemus, &v_analoogvorm, a_pikkus+2, 1, &tagasi, ALGV_LIIK);
}
else
res = chkwrd(&tulemus, &analoogvorm, a_pikkus, 1, &tagasi, ALGV_LIIK);
assert(res <= ALL_RIGHT);
if (res > ALL_RIGHT)
return false; // viga; ei saa olla
if (!tulemus.on_tulem())
{
assert(tulemus.on_tulem());
}
assert(tagasi==1);
if (!tulemus.on_tulem()) // polnud norm. eesti k. sõna
return false; // viga; ei saa olla
rs = Gene2Detailne(&analoog_tulemus, &tulemus, &tyhi, pGeneLiik, pGeneVormid, pGeneKigi);
if (rs == false)
return false;
analoog_tulemus.VotaTyvedeltEest(a_pikkus-mitu);
analoog_tulemus.LisaTyvedeleEtte(gene_t1.Left(g_pikkus-mitu));
pValja->Move2Tail(&analoog_tulemus);
}
}
if (pValja->idxLast > viimne) // midagi leitigi
{
pValja->eKustTulemused = eMRF_SO; // tulemused tulid sünteesi-oletajast
}
pValja->SortUniq();
return true;
}
bool ETMRFAS::GeneSTV(
MRFTULEMUSED *pValja,
const FSXSTRING *gPrf, // käib tüve ette
const FSXSTRING *gSuffiks, // suffiks morf analüüsija väljundist
//const FSXSTRING *gSufSl, // suffiksi son liik morf anal väljundist
const FSXSTRING *sl, // sõnaliigid, millesse kuuluvaid sonu tahetakse
const FSXSTRING *geneVormid, // genetavate vormide loend
const int algv_lopp, // 0, -ma voi -d
const int algv_vorm, // sg_g[0], sg_n[0], ma voi pl_n[0]
const FSXSTRING *pGeneKigi)
{
FSUNUSED(sl);
int sufNr; // sufiksi nr sufiksite tabelis
int i, j;
FSXSTRING tmpSuf, tmpSuf1, tmpSuf2;
FSXSTRING *sonaLiigid;
FSxCHAR sl1;
//FSXSTRING *sssl;
int nSonaLiiki;
FSXSTRING gTyviUus;
//FSXSTRING gene_t2;
FSXSTRING styvi;
FSXSTRING skronksutyvi;
int adhocnu = 0; // ad hoc nud, tud, dud jaoks
if (gSuffiks->GetLength() >= SUFLEN)
return true; //* ei saa olla sufiks *
tmpSuf = (const FSxCHAR *)*gSuffiks;
//* otsime välja sufiksi indeksi sufiksite tabelist *
sufNr=suffnr((const FSxCHAR *)tmpSuf);
if (sufNr == -1)
{
//* sellist sufiksit pole olemas, *
//* see juhtub nt siis, kui suf loendis on pikem sufiks, *
//* aga lingv ilu pa'rast na'idat. teda lu'hemana *
//* nt =umuslik asemel =muslik *
//* mingi kombineerimine *
int mitu_maha = gPrf->GetLength();
if (mitu_maha > 3)
mitu_maha = 3;
tmpSuf1 = gPrf->Right(mitu_maha);
tmpSuf1 += (const FSxCHAR *)*gSuffiks;
for (i=0; i < mitu_maha; i++)
{
tmpSuf = tmpSuf1.Mid(i);
if ((sufNr=suffnr((const FSxCHAR *)tmpSuf)) > -1)
break; //* suffiks käes *
}
if (i == mitu_maha) // tavaliselt seda ei saa olla, et ei leia sobivat suffiksit
{
if(*gSuffiks == FSxSTR("nud") || *gSuffiks == FSxSTR("tud") || *gSuffiks == FSxSTR("dud"))
{ // ... aga vahel ikka saab: leksikonis on ainult S nu, tu ja du, mitte A nud, tud ja dud...
tmpSuf = gSuffiks->Left(2);
sufNr=suffnr((const FSxCHAR *)tmpSuf);
adhocnu = 1; // lipp püsti
}
else
return true;
}
tmpSuf1 = tmpSuf.Mid((int)(sufix[sufNr].mitutht));
}
else
tmpSuf1 = tmpSuf;
sonaLiigid = sonaliik[(unsigned char) sufix[sufNr].ssl];
nSonaLiiki = sonaLiigid->GetLength();
for(i=0; i < nSonaLiiki; i++) // vt sufiksi homonüüme (s.h. lik ja l<ik on homonüümid)
{
sl1 = (*sonaLiigid)[i];
if ( sl->Find(sl1) == -1) // see sõnaliik pole siin lubatud
if (adhocnu == 1); // ... aga teatud juhtudel ikkagi võiks
else if (sl->Find((FSxCHAR)'A') != -1 && // tahetakse A, aga sufiks on leksikonis S
(tmpSuf1 == FSxSTR("tu") ||
tmpSuf1.Right(2) == FSxSTR("ke") ||
tmpSuf1.Right(4) == FSxSTR("kene"))); // ... aga teatud juhtudel ikkagi võiks
else
continue;
// vaja kontrollida, kas on ikka vajaliku algvormi tüvi
gTyviUus = tmpSuf1;
if(OtsiTyvi(&(sufix[sufNr].suftyinf[i].idx),
algv_lopp, algv_vorm, &gTyviUus)==false)
continue; //polnud sobiv tüvi
if(gTyviUus != tmpSuf1) // pole õige algvormi tüvi
continue;
if(sl1==W_SL) // nagunii on ka S liigiline sõna leitud
continue;
if(sl1==(FSxCHAR)'B' && sl->Find((FSxCHAR)'A') >=0)
sl1 = 'A'; // kah õige sõnaliik: tahad A-d saad B, aga ütleme, et said A
MKT1c *rec1; // siia pannakse gTyvi (nt piksel) lgNr ja tyMuut
MKTc *rec; // {lgNr, tyMuut} massiiv, mis on seotud ühe sõnaga; nt tyvedele piksel, piksli, piksle
int muutumatu; // muutumatu tüveosa (nt piks)
tmpSuf2 = tmpSuf1;
if((rec1=tyveMuutused.Get(sufix[sufNr].suftyinf[i].idx.tab_idx,sufix[sufNr].suftyinf[i].idx.blk_idx))==NULL)
{
return false;
}
// leia muutumatu tüveosa
if((muutumatu=tmpSuf1.GetLength()-rec1->tyMuut.GetLength()) < 0)
{
return false;
}
if((rec=tyveMuutused[sufix[sufNr].suftyinf[i].idx.tab_idx])==NULL)
{
return false;
}
int tmpsufnr, jj, jjnSonaLiiki;
FSXSTRING vormityvi;
FSXSTRING tyvi, utyvi;
for (j=0; j < rec->n; j++) // vt selle sufiksi paradigma kõiki "tüvesid"
{
utyvi = gPrf->Right(sufix[sufNr].mitutht); // tavaliselt "", aga umuslik puhul u
tyvi = tmpSuf1.Left(muutumatu) + rec->mkt1c[j].tyMuut;
utyvi += tyvi;
tmpsufnr=suffnr((const FSxCHAR *)utyvi);
FSXSTRING *jjsonaLiigid = sonaliik[(unsigned char) sufix[tmpsufnr].ssl];
jjnSonaLiiki = jjsonaLiigid->GetLength();
for (jj=0; jj < jjnSonaLiiki; jj++) // vt "tüve" kõiki homonüüme
{
if ((*sonaliik[(unsigned char) sufix[tmpsufnr].ssl])[jj] != sl1)
continue; // pole sama sõnaliik ...
//if (sufix[sufNr].suftyinf[i].idx.tab_idx != sufix[tmpsufnr].suftyinf[jj].idx.tab_idx)
//continue; // pole sama paradigma
// kole asi üksikute juhtumite filtreerimiseks, nt l<ik ja lik eristamiseks
// tundl<ik+0 vs tundlik+el
MKT1c *rec2 = tyveMuutused.Get(sufix[tmpsufnr].suftyinf[jj].idx.tab_idx,sufix[tmpsufnr].suftyinf[jj].idx.blk_idx);
if (rec->mkt1c[j].lgNr != rec2->lgNr)
continue; // homonüümne tüvi (kui hääldust ei arvesta) ja samas paradigmas, aga tegelt sobimatu
LisaKdptr(sufix[tmpsufnr].suftyinf, &vormityvi, &tyvi, jj);
if (adhocnu == 1) // nu -> nud
{
int sgn_koht;
if ((sgn_koht=geneVormid->Find(FSxSTR("sg n"))) != -1)
{
FSXSTRING uustyvi = *gPrf;
uustyvi += tyvi;
uustyvi += FSxSTR("d");
pValja->Add(
(const FSxCHAR *) uustyvi,
FSxSTR(""),
(const FSxCHAR *)*pGeneKigi,
FSxSTR("A"),
FSxSTR("sg n, "));
FSXSTRING uusgeneVormid = geneVormid->Mid(0, sgn_koht);
uusgeneVormid += geneVormid->Mid(sgn_koht+5);
if (GeneL(pValja, gPrf, &vormityvi, (const FSxCHAR) 'A', rec->mkt1c[j].lgNr,
&uusgeneVormid, pGeneKigi)==false)
{
return false;
}
}
else
{
if (GeneL(pValja, gPrf, &vormityvi, (const FSxCHAR) 'A', rec->mkt1c[j].lgNr,
geneVormid, pGeneKigi)==false)
{
return false;
}
}
}
else
{
if(GeneL(pValja, gPrf, &vormityvi, (const FSxCHAR) sl1, rec->mkt1c[j].lgNr,
geneVormid, pGeneKigi)==false)
{
return false;
}
}
}
}
}
return true;
}
bool ETMRFAS::GeneL1(
MRFTULEMUSED *pValja,
const FSXSTRING *gPrf, // käib tüve ette
const FSXSTRING *gTyvi, // tüvi morf analüüsijast
const FSxCHAR sl,
const int lgNr,
const FSXSTRING *geneVorm, // genetav vorm
const FSXSTRING *pGeneKigi)
{
int i,j,l6ppudeAlgusNihe,l6ppudeArv,vormideAlgusNihe,ffnr;
int l6pujrknr;
FSxCHAR tmp[2]=FSxSTR("\0");
FSXSTRING l6pp, tyvi, liik, kigi;
FSxCHAR vi;
tmp[0]=sl;
liik=tmp;
kigi = FSxSTR("");
// sõnastiku kettalt sisselugemisel tuleks kohe need2 baiti
// intiks teisenda ja seda kasutadagi lõputu bitinikerdamise asemel
l6ppudeAlgusNihe= (((groups[lgNr].gr_algus)&0xFF)<<8)|
(groups[lgNr].gr_lopp&0xFF);
l6ppudeArv=(unsigned char)(groups[lgNr].cnt);
vormideAlgusNihe = homo_form * l6ppudeAlgusNihe;
ffnr = vormnr((const FSxCHAR *)*geneVorm);
assert( l6ppudeAlgusNihe >=0 && l6ppudeArv >=0 && vormideAlgusNihe >=0 );
if(ffnr <= 0)
return false; // sellist vormi pole üldse olemaski
for(i=0; i < l6ppudeArv; i++)
{
for(j=0; j < (int)homo_form; j++)
{
if( ffnr==(unsigned char)(fgr[vormideAlgusNihe+(i*homo_form) + j]) )
{
// otsitav vorm leitud
l6pujrknr=(unsigned char)(gr[l6ppudeAlgusNihe + i]);
l6pp=l6ppudeLoend[l6pujrknr];
//if(adHocString.GetLength() > 0 && ffnr==vormideLoend[FSxSTR("sg n"])) //Kuidas see sai kompileeruda?!
if(adHocString.GetLength() > 0 && ffnr==vormnr(FSxSTR("sg n")))
{
l6pp += adHocString;
}
tyvi= *gPrf + *gTyvi;
FSXSTRING geneVorm1 = *geneVorm;
geneVorm1 += FSxSTR(", ");
if (l6pp.GetLength() > 0)
vi = l6pp[l6pp.GetLength()-1];
else
vi = tyvi[tyvi.GetLength()-1];
if (pGeneKigi->GetLength()>0)
{
if (!TaheHulgad::OnHelitu(vi))
kigi = FSxSTR("gi");
else
kigi = FSxSTR("ki");
}
pValja->Add(
(const FSxCHAR *)tyvi,
(const FSxCHAR *)l6pp,
(const FSxCHAR *)kigi,
(const FSxCHAR *)liik,
(const FSxCHAR *)geneVorm1);
}
}
}
return true;
}
//bool ETMRFAS::GeneTLDetailne(
bool ETMRFAS::GeneTLDetailne(
MRFTULEMUSED *pValja,
const TYVE_INF *naidise_dptr,
const int mitu_naidise_homon,
const FSXSTRING *gPrf, // käib tüve ette
const FSXSTRING *gTyvi, // algvormi tüvi morf analüüsijast (nt piksel))
const FSxCHAR sl, // sõnaliik, millesse kuuluvaid sõnu tahetakse
TYVE_INF *tyveinf, // kõik gTyviga seotud info, mis sõnastikust on leitud
const FSXSTRING *geneVormid, // genetavate vormide loend
const FSXSTRING *pGeneKigi)
{
MKT1c *rec1; // siia pannakse gTyvi (nt piksel) lgNr ja tyMuut
MKTc *rec; // {lgNr, tyMuut} massiiv, mis on seotud ühe sõnaga; nt tyvedele piksel, piksli, piksle
int muutumatu; // muutumatu tüveosa (nt piks)
int i, j;
FSXSTRING vormityvi;
if((rec1=tyveMuutused.Get(tyveinf->idx.tab_idx,tyveinf->idx.blk_idx))==NULL)
{
return false;
}
// leia muutumatu tüveosa
if((muutumatu=gTyvi->GetLength()-rec1->tyMuut.GetLength()) < 0)
{
return false;
}
if((rec=tyveMuutused[tyveinf->idx.tab_idx])==NULL)
{
return false;
}
for(i=0; i < rec->n; i++) // vt selle sõna kõiki tüvesid
{
FSXSTRING tyvi= gTyvi->Left(muutumatu) + rec->mkt1c[i].tyMuut;
FSXSTRING tyvi_leksikonis=tyvi;
int slTabIdx;
int sliike;
if (tyvi_leksikonis.Find(FSxSTR(" "))!=-1)
tyvi_leksikonis.Replace(FSxSTR(" "), FSxSTR("="), 1);
if (cXXfirst(&tyvi_leksikonis, &slTabIdx)!=ALL_RIGHT)
{
return NULL;
}
sliike = sonaliik[slTabIdx]->GetLength();
// peab tsükeldama ja sõnaliike ja tab_idx kontrollima,
// sest sõnastik on niimoodi tehtud:
// homonüümsed tüved (s.h. mittevajalikud) on kuidagi üheskoos...
for (j=0; j < sliike; j++)
{
int jj;
for (jj=0; jj < mitu_naidise_homon; jj++)
{ // kas samas paradigmas on ka näidise tüvi ?
if (dptr[j].idx.tab_idx == naidise_dptr[jj].idx.tab_idx)
break;
}
if (mitu_naidise_homon > 0 && jj == mitu_naidise_homon)
continue; // ei vasta nõutud paradigmale; nt. tahetakse palgi, aga see on palga
if ((*sonaliik[slTabIdx])[j] == sl || // on sama sõnaliik ...
((*sonaliik[slTabIdx])[j] == (FSxCHAR)'B' && sl == (FSxCHAR)'A')) // või sobiv sõnalik
{
if (dptr[j].idx.tab_idx == tyveinf->idx.tab_idx)
{ // ... ja sama paradigma tüvi
LisaKdptr(dptr, &vormityvi, &tyvi, j);
if(GeneL(pValja, gPrf, &vormityvi, sl, dptr[j].lg_nr, geneVormid, pGeneKigi)==false)
{
return false;
}
}
}
}
//-----
}
return true;
}
