int MORF0::kchk33(
VARIANTIDE_AHEL **variandid,
VARIANTIDE_AHEL **sobivad_variandid,
char *paha_koht,
const int paha_koha_suurus)
{
int res;
CVARIANTIDE_AHEL cvahe_variant;
KOMPONENT *pref, *tyvi, *suff, *lopp, *essa;
/* ts�kkel �le prefiksite, alates l�himast; 0-pref ja 0-suff pole lubat. */
for (VARIANTIDE_AHEL *variant=*variandid; variant; variant=variant->jargmine_variant)
{
essa = esimene_komp(variant);
if (essa->k_tyyp != K_PREF) /* ei algagi prefiksiga */
continue;
pref = essa;
tyvi = pref->komp_jargmine;
suff = tyvi->komp_jargmine;
if (suff->k_tyyp != K_SUFF)
continue;
lopp = suff->komp_jargmine;
if (lopp->k_tyyp != K_LOPP)
continue;
res = ty_suf(suff, tyvi->nihe, tyvi->k_pikkus, &cvahe_variant.ptr, paha_koht, paha_koha_suurus);
if (res > ALL_RIGHT)
return res; /* viga! */
if (!cvahe_variant.ptr)
continue; /* tyve polnud */
for (VARIANTIDE_AHEL *tmp=cvahe_variant.ptr; tmp; tmp=tmp->jargmine_variant) /* vt neid juhte, kus ty+suf juba sobivad */
{ /* kopeeri sobivate hulka koik tyved, mis selle pref-ga sobivad */
if (sobib_p_t_s(pref, esimene_komp(tmp), suff))
{
kopeeri_komp(tyvi, esimene_komp(tmp));
//VARIANTIDE_AHEL *sobiv_variant; //ok
//sobiv_variant = lisa_ahel(sobivad_variandid, variant);
//if (!sobiv_variant)
if(lisa_ahel(sobivad_variandid, variant)==NULL)
return CRASH;
if(mrfFlags.Chk(MF_SPELL))
{
ahelad_vabaks(&cvahe_variant.ptr);
return ALL_RIGHT; /* 1. sobiv variant k�lbab */
}
}
}
ahelad_vabaks(&cvahe_variant.ptr);
}
return ALL_RIGHT;
}
int MORF0::kchk1(
VARIANTIDE_AHEL **variandid,
FSXSTRING *word,
int S6naPikkus,
VARIANTIDE_AHEL **sobivad_variandid,
char *paha_koht,
const int paha_koha_suurus)
{
int i, tyvepik;
int res;
int algp;
FSXSTRING sona, end;
signed char lnr;
VARIANTIDE_AHEL **mille_taha, *variant, *sobiv_variant, **sobiva_taha, *tmp; //ok
CVARIANTIDE_AHEL cvahe_variant;
KOMPONENT *tyvi, *lopp;
sona = *word;
mille_taha = variandid; /* kuhu uus komponentide ahel paigutada */
sobiva_taha = sobivad_variandid;
if ( S6naPikkus > ENDLEN )
algp = ENDLEN - 1; /* v�imalik max pikkusega l�pp */
else
{
if (sona[0] == (FSxCHAR)'e' || sona[0] == V_O_UML)
algp = S6naPikkus - 1; /* tyvi v�ib olla 1 t�heline */
else
algp = S6naPikkus - 2; /* tyvi olgu v�hemalt 2 t�heline */
}
for (i = 0; i <= algp; i++)
{
if (i)
{
tyvepik = S6naPikkus - i;
end = (const FSxCHAR *)(sona.Mid(tyvepik));
if(mrfFlags.Chk(MF_GENE)) /* vt ainult algv. loppe */
{
if (loend.head_gene_lopud.Get((FSxCHAR *)(const FSxCHAR *)end))
lnr = lpnr( (const FSxCHAR *)end );
else
continue; /* vt 1 t�he v�rra l�hemat l�ppu */
}
else /* vt. koiki loppe */
{
lnr = lpnr( (const FSxCHAR *)end );
if (lnr == -1) /* sellist l�ppu pole olemas */
continue; /* vt 1 t�he v�rra l�hemat l�ppu */
}
}
else /* null-l�pp */
{
tyvepik = S6naPikkus;
lnr = null_lopp;
}
/* mingi lopp leitud */
variant = lisa_1ahel(mille_taha);
mille_taha = &variant;
tyvi = lisa_esimene(variant);
if (!tyvi)
{
return CRASH;
}
lisa_min_info(tyvi, word, 0, tyvepik);
lopp = lisa_1komp(&tyvi);
if (!lopp)
{
return CRASH;
}
lisa_min_info(lopp, word, tyvepik, i);
lisa_psl_info(lopp, K_LOPP, lnr);
/* otsi ty ja kontrolli ta sobivust lopuga */
res = ty_lp(lopp, 0, tyvepik, &cvahe_variant.ptr, paha_koht,paha_koha_suurus);
if (res > ALL_RIGHT)
{
return res; /* viga! */
}
if (!cvahe_variant.ptr)
continue; /* tyve polnud */
for (tmp=cvahe_variant.ptr; tmp; tmp=tmp->jargmine_variant)
{ /* kopeeri sobivate hulka koik tyved, mis selle lopuga sobivad */
sobiv_variant = lisa_ahel(sobiva_taha, tmp);
if (!sobiv_variant)
{
return CRASH;
}
if(mrfFlags.Chk(MF_SPELL)) // aitab 1 tyvest kyll
break;
sobiva_taha = &sobiv_variant;
}
ahelad_vabaks(&cvahe_variant.ptr);
if(mrfFlags.Chk(MF_SPELL))
{
return ALL_RIGHT; /* rohkem variante ei vt. */
}
}
return ALL_RIGHT;
}
int MORF0::kchk6(
VARIANTIDE_AHEL **variandid,
FSXSTRING *S6na,
int S6naPikkus,
VARIANTIDE_AHEL **sobivad_variandid,
char *paha_koht,
const int paha_koha_pikkus
)
{
int res;
int pik;
int kk;
VARIANTIDE_AHEL *variant, *tmp, *sobiv_variant; //ok
CVARIANTIDE_AHEL cvahe_variant, cls_variant;
KOMPONENT *tyvi, *tyvi1, *sobivty, *sobivlp;
KOMPONENT *tmpkomp1, *tmpkomp2;
KOMPONENT *essa, **esi;
int ty1_tyyp;
//char *u_paha_koht=0; TV080723
FSXSTRING u_S6na, vt_tyvi;
int u_S6naPikkus;
for (variant=*variandid; variant; variant=variant->jargmine_variant)
{
char u_paha_koht[(STEMLEN+1)*(STEMLEN+1)];
tyvi1 = esimene_komp(variant);
ty1_tyyp = 0;
if (tyvi1->k_tyyp == K_PREF)
{
FSXSTRING tl;
tl = taandliik[ prfix[tyvi1->jrk_nr].sl ];
if ( tl.Find((FSxCHAR) 'V') !=-1 )
ty1_tyyp = 13;
else if (tl.Find((FSxCHAR) 'S') != -1)
ty1_tyyp = 12;
}
else
ty1_tyyp = ty11tyyp(tyvi1->liitumistyyp);
if (!ty1_tyyp) /* ty1 ei sobi nii keerulise liitsona algusse */
continue;
tyvi = tyvi1->komp_jargmine;
if (!(tyvi->komp_jargmine))
continue;
if (tyvi->k_tyyp == K_LOPP)
continue;
if (tyvi->k_tyyp == K_SUFF)
continue;
if (tyvi->k_pikkus < 5) /* ty2+ty3 ei mahu */
continue;
if (tyvi1->k_pikkus + tyvi->k_pikkus < 9) /* ty1+ty2+ty3 ei mahu */
continue;
/* keerulisemat struktuuri ei vt; ka mitut erin sufiksit ei luba, v.a. lt puhul; ??? */
if (*sobivad_variandid &&
tyvi->komp_jargmine->k_tyyp == K_SUFF)
{
FSXSTRING sona;
sona = (const FSxCHAR *)(S6na->Left(S6naPikkus));
if (!TaheHulgad::OnLopus(&(sona), FSxSTR("lt")))
break;
}
pik = minipik(&(tyvi->k_algus));
if (tyvi->k_pikkus < pik + 2)
continue;
//int sty = tyvi->k_pikkus-2;
/* otsi sellest kohast algavat liitsona ty1+ty2 */
/* uue liitsona jaoks andmed paika */
u_S6naPikkus = S6naPikkus - tyvi1->k_pikkus;
//TV080723 u_paha_koht = init_hjk_cxx(u_S6naPikkus,
// u_paha_koht, sizeof(u_paha_koht));
//if (!u_paha_koht)
// return CRASH;
//TV080723 u_paha_koht = uus_paha(S6naPikkus,paha_koht,u_S6naPikkus,u_paha_koht);
//if (!u_paha_koht)
// return CRASH;
init_hjk_cxx(u_S6naPikkus,
u_paha_koht, sizeof(u_paha_koht));
uus_paha(S6naPikkus,paha_koht,u_S6naPikkus,
u_paha_koht, sizeof(u_paha_koht));
u_S6na = (const FSxCHAR *)(S6na->Mid(tyvi1->k_pikkus));
cls_variant.ptr = lisa_1ahel(&cls_variant.ptr);
if (!cls_variant.ptr)
return CRASH;
esi = &(cls_variant.ptr->variant);
tmpkomp2 = kop_kompid(esi, tyvi);
if (!tmpkomp2)
return CRASH;
for (tmpkomp1=*esi; tmpkomp1; tmpkomp1=tmpkomp1->komp_jargmine)
{
tmpkomp1->algsona = u_S6na;
tmpkomp1->nihe -= tyvi1->k_pikkus;
}
if (ty1_tyyp == 12 && !TaheHulgad::OnAlguses(&u_S6na, FSxSTR("ise"))) /* prefiks; "ise" ei sobi */
{
res = kchk30(&cls_variant.ptr, &u_S6na, u_S6naPikkus, &cvahe_variant.ptr, u_paha_koht,sizeof(u_paha_koht));
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!cvahe_variant.ptr)
{
res = kchk4(&cls_variant.ptr, &u_S6na, u_S6naPikkus, &cvahe_variant.ptr,
u_paha_koht,sizeof(u_paha_koht));
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!cvahe_variant.ptr)
{
if (ty1_tyyp == 12 && !TaheHulgad::OnAlguses(&u_S6na, FSxSTR("ise"))) /* prefiks */
{
res = kchk33(&cls_variant.ptr, &cvahe_variant.ptr, u_paha_koht, sizeof(u_paha_koht));
if (res > ALL_RIGHT)
return res; /* viga! */
}
}
if (!cvahe_variant.ptr)
{
res = kchk5(&cls_variant.ptr, &u_S6na, u_S6naPikkus, &cvahe_variant.ptr, u_paha_koht, sizeof(u_paha_koht));
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (cvahe_variant.ptr) /* ty1 taga v�ibki olla liits�na */
{
for (tmp=cvahe_variant.ptr; tmp; tmp=tmp->jargmine_variant)
{
esi = &(tmp->variant);
if ((*esi)->liitumistyyp == L_TYVE_TYYP) /* liitsona on S suva-vorm */
if ((*esi)->komp_jargmine->liitumistyyp != L_TYVE_TYYP + 3) /* polegi S pl g */
continue;
if ((*esi)->k_tyyp == K_PREF && /* ... + pref */
(ty1_tyyp == 12 || ty1_tyyp == 4)) /* ty1 on pref v�i S sg g */
; /* pref + pref/S sg g sobivad alati */
else
{
kk = ty11ty11(ty1_tyyp, ty11tyyp((*esi)->liitumistyyp));
if (!kk) /* liitsona ei sobi ty1-ga */
continue;
}
// kontrolli s�nastikust saadud info abil, kas v�ib olla liits�na tagumine ots
// HJK juuni 2006
if (((*esi)->liitumisinfo).Find(L_MITTELIITUV_SL) != -1) // HJK 6.06.2006 et igasugu l�his�nad ei saaks osaleda
continue;
vt_tyvi = tyvi1->k_algus;
vt_tyvi += (*esi)->k_algus;
if (viletsls(&vt_tyvi)) /* lubamatu liitsona */
continue;
for (tmpkomp1=*esi; tmpkomp1; tmpkomp1=tmpkomp1->komp_jargmine)
{ /* teisenda tagasi esialgse s�na taoliseks */
tmpkomp1->algsona = *S6na;
tmpkomp1->nihe += tyvi1->k_pikkus;
}
/* vt et juba leitud analyysi ei lisataks uuesti */
for (tmpkomp1=*esi; tmpkomp1->komp_jargmine; tmpkomp1=tmpkomp1->komp_jargmine);
sobivlp = tmpkomp1;
sobivty = tmpkomp1->komp_eelmine;
if (on_tylopuga(*sobivad_variandid, sobivty, sobivlp)) /* selline tyvi/suf+lp juba sobivate hulgas */
continue;
/* s�na anal��situd! */
sobiv_variant = lisa_1ahel(sobivad_variandid);
if (!sobiv_variant)
return CRASH;
essa = lisa_esimene(sobiv_variant);
kopeeri_komp(essa, tyvi1);
tmpkomp2 = kop_kompid(&essa, *esi);
if (!tmpkomp2)
return CRASH;
}
}
ahelad_vabaks(&cvahe_variant.ptr);
ahelad_vabaks(&cls_variant.ptr);
/* s�nainfo tagasi �igeks */
// TV080723 paha_koht = uus_paha(u_S6naPikkus, u_paha_koht, S6naPikkus, paha_koht);
//if (!paha_koht)
// return CRASH;
uus_paha(u_S6naPikkus, u_paha_koht, S6naPikkus,
paha_koht, paha_koha_pikkus);
//close_hjk_cxx(u_paha_koht);
}
return ALL_RIGHT;
}
int MORF0::arvans1(MRFTULEMUSED *tulemus, FSXSTRING *S6na, int S6naPikkus, VARIANTIDE_AHEL **variandid)
{
int res;
int cnt, ty2pik;
CVARIANTIDE_AHEL ctyvi2_variant, cvahe_variant, csobivad_variandid;
KOMPONENT komp, *k_tyvi, *tyvi1;
FSXSTRING ema = FSxSTR("ema");
FSXSTRING tyvi2;
//int tugevus;
int maxty2, minty;
// et saaks ty2lp() kasutada
tyvi1 = &komp;
res = cXXfirst(ema, 3, &cnt);
if (res == POLE_SEDA || res == POLE_YLDSE) // sellist tyve pole olemas
return CRASH; // sellist asja ei saa olla
nulli_1komp(tyvi1);
lisa_min_info(tyvi1, &ema, 0, 3);
lisa_psl_info(tyvi1, K_TYVI, 0);
// leiame tyvi1 liitumis-liigid
res = juht1(tyvi1, dptr, cnt, &cvahe_variant.ptr);
if (res > ALL_RIGHT)
return res;
maxty2 = S6naPikkus > 20 ? 20 : S6naPikkus-3;
if (TaheHulgad::OnSuur(S6na, 0)) // oletatavatele nimedele luban �sna pikki j�relkomponente
minty = 5;
else
minty = 2;
// vt ko'iki v�imalikke l�ppe
for (VARIANTIDE_AHEL *variant=*variandid; variant; variant=variant->jargmine_variant)
{
k_tyvi = esimene_komp(variant);
if (k_tyvi->komp_jargmine->k_tyyp != K_LOPP)
continue;
maxty2 = k_tyvi->k_pikkus > 20 ? 20 : k_tyvi->k_pikkus-3;
for (ty2pik=maxty2; ty2pik >= minty; ty2pik--)
{
tyvi2 = k_tyvi->k_algus.Right(ty2pik);
if (ty2pik < 4)
{
if (!oletajaDct.sobivad_tyved2.Get((const FSxCHAR *)tyvi2))
continue; // pole lyhike kuid sobiv
}
else
{
if (oletajaDct.pahad_tyved2.Get((const FSxCHAR *)tyvi2))
continue; // on paha
}
// leiame tyvi2
res = ty_lp(k_tyvi->komp_jargmine, k_tyvi->k_pikkus - ty2pik, ty2pik, &ctyvi2_variant.ptr, NULL, 0);
if (res > ALL_RIGHT)
return res;
for (VARIANTIDE_AHEL *tmp=ctyvi2_variant.ptr; tmp; tmp=tmp->jargmine_variant) // leia tyvi2 tyybid
{
juht2(esimene_komp(tmp));
}
for (VARIANTIDE_AHEL *tmp=cvahe_variant.ptr; tmp; tmp=tmp->jargmine_variant) // tyvi1 tyvepikkus paika
{
lisa_min_info(esimene_komp(tmp), S6na, 0, k_tyvi->k_pikkus - ty2pik); // tyvele uus pikkus
esimene_komp(tmp)->sonastikust = 0; // tyvi1 pole s�nastikust HJK 17.05.2004
}
// int tugevus =
tyvi1tyvi2(&cvahe_variant.ptr, &ctyvi2_variant.ptr, &csobivad_variandid.ptr);
// siin vo'iks kunagi veel kontrollida tugevus va'a'rtust, et mitte liiga kahtlasi lubada ...
ahelad_vabaks(&ctyvi2_variant.ptr);
if (csobivad_variandid.ptr) // mingi ty1-ga leidub sobiv kombinatsioon
{
ahelad_vabaks(&cvahe_variant.ptr);
ahelad_vabaks(&ctyvi2_variant.ptr);
break; // lyhemaid tyvesid selle lopu puhul ei vt
}
}
}
//ahelad_vabaks(&cvahe_variant.ptr); //destruktoris
//ahelad_vabaks(&ctyvi2_variant.ptr); //destruktoris
if (csobivad_variandid.ptr)
{
if (TaheHulgad::OnSuur(S6na, 0))
{
variandid_tulemuseks(tulemus, LIIK_YLDNIMI, &csobivad_variandid.ptr);
if (tulemus->on_tulem())
tulemus->TulemidNimeks(LIIK_KAANDSONA);
}
else
variandid_tulemuseks(tulemus, KOIK_LIIGID, &csobivad_variandid.ptr);
//ahelad_vabaks(&csobivad_variandid.ptr); //destruktoris
}
return ALL_RIGHT;
}
int MORF0::chkhy2(MRFTULEMUSED *tulemus, FSXSTRING *S6nna, int maxtasand, int *tagasi)
{
int i, j;
int res=0;
char rezz, rezz1;
struct lisa {
const FSxCHAR *lubatud_lopp;
const FSxCHAR *lubatud_sl;
const int mitu_eemaldada;
const FSxCHAR *otsa_panna;
} lisakatse[3] = {
{ FSxSTR("0"), FSxSTR("A"), 2, FSxSTR("ne") }, /* +ne */
{ FSxSTR("t"), FSxSTR("AS"), 0, FSxSTR("t") }, /* is+t */
{ FSxSTR("d"), FSxSTR("AS"), 0, FSxSTR("d") } }; /* +d */
int katsenr;
const FSxCHAR *lubatud_liik;
int viimane, lopus_kriips;
int tmp;
int mitu;
int sobiv_an;
CVARIANTIDE_AHEL ctoo_variandid, csobivad_variandid;
FSXSTRING S6na = *S6nna;
int k;
FSXSTRING algus;
FSXSTRING kriips;
FSXSTRING lopp;
FSXSTRING pisialgus;
MRFTULEMUSED ette;
FSXSTRING ettestr;
k = S6na.Find((FSxCHAR)'-');
if (k == -1)
k = S6na.Find((FSxCHAR)'/');
if (k == -1)
return ALL_RIGHT; // ei sisalda '-' ega '/'
algus = S6na.Left(k);
kriips = S6na.Mid(k, 1);
lopp = S6na.Mid(k+1);
if (k==0 && kriips == FSxSTR("-") ) // -sona
{
if (lopp.GetLength()<1)
return ALL_RIGHT;
res = chkwrd(tulemus, &lopp, lopp.GetLength(), maxtasand, tagasi, KOIK_LIIGID/*MITTE_VERB*/);
if (res > ALL_RIGHT)
return res; /* viga! */
if (!tulemus->on_tulem())
{
FSXSTRING pisilopp;
pisilopp = lopp;
pisilopp.MakeLower();
res = chkwrd(tulemus, &pisilopp, pisilopp.GetLength(), maxtasand, tagasi, KOIK_LIIGID);
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (maxtasand < 4) // soovitaja pärast HJK 10.06.2005
return ALL_RIGHT;
if (!tulemus->on_tulem()) /* polnud -sona */
{
*tagasi = 4;
res = chklyh4(tulemus, &lopp, lopp.GetLength()); /* nt. -E */
if (res > ALL_RIGHT)
return res; /* viga! */
}
return ALL_RIGHT;
}
if (maxtasand < 4) // soovitaja p�rast HJK 10.06.2005
return ALL_RIGHT;
if (S6na.GetLength() == 2 && k == 1 && kriips == FSxSTR("-") && TaheHulgad::eestitht.Find(S6na[0])!=-1) // a-
{
tulemus->Add( (const FSxCHAR *)algus, FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, ")); /* parema puudusel */
*tagasi = 4;
return ALL_RIGHT;
}
/* sona-sona-sona-sona... */
viimane = 0;
lopus_kriips = 0;
lopp = S6na;
rezz = mrfFlags.Chk(MF_ALGV); /* algvormi rezhiimi lipp */
rezz1 = mrfFlags.Chk(MF_GENE); /* gene rezhiimi lipp */
for (mitu=0 ;; mitu++)
{
MRFTULEMUSED ajutine_tulemus;
MRFTUL t;
sobiv_an = -1;
k = lopp.Find(kriips);
if ( k==-1 ) /* viimane sonaosa */
{
algus = lopp;
lopp = FSxSTR("");
viimane = 1;
}
else
{
algus = lopp.Left(k);
lopp = lopp.Mid(k+1);
if (lopp.GetLength()==0) // viimane sonaosa; sona-
{
viimane = 1;
lopus_kriips = 1;
}
}
if (algus.GetLength() > STEMLEN || algus.GetLength() < 1)
{
mrfFlags.OnOff(MF_ALGV, rezz); /* analyys nagu korgemalt ette antud */
mrfFlags.OnOff(MF_GENE, rezz1); /* analyys nagu korgemalt ette antud */
return ALL_RIGHT; // tulemust pole vaja vabastada
}
pisialgus = algus;
pisialgus.MakeLower();
if (algus == FSxSTR("ist")
|| algus == FSxSTR("lase")
|| algus == FSxSTR("lise")
|| algus == FSxSTR("na")
|| algus == FSxSTR("st")) // need ei sobi s�naks
{
mrfFlags.OnOff(MF_ALGV, rezz); /* analyys nagu korgemalt ette antud */
mrfFlags.OnOff(MF_GENE, rezz1); /* analyys nagu korgemalt ette antud */
return ALL_RIGHT; // tulemust pole vaja vabastada
}
lubatud_liik = KOIK_LIIGID;
if (viimane)
{
mrfFlags.OnOff(MF_ALGV, rezz); /* analyys nagu korgemalt ette antud */
mrfFlags.OnOff(MF_GENE, rezz1); /* analyys nagu korgemalt ette antud */
// if ( ChIsUpper(*s) && !ChIsUpper(*(s+1))) /* viimane so'na suurta'heline */
if (TaheHulgad::SuurAlgustaht(&algus))
lubatud_liik = FSxSTR("SABCUNOPHGY"); /* juhuks, kui viimane algab suure ta'hega */
if (lopus_kriips) /* viimase lopus -, nt. nais- */
{
if (pisialgus == FSxSTR("kesk") || pisialgus == FSxSTR("puhke") || pisialgus == FSxSTR("inglis"))
{
ajutine_tulemus.Add((const FSxCHAR *)pisialgus, FSxSTR(""), FSxSTR(""), FSxSTR("S"), FSxSTR("?, "));
}
lubatud_liik = FSxSTR("SABCUNOPHGDK");
}
}
else
{
mrfFlags.Off(MF_ALGV); /* on vaja, et analu"u"siks nagu ilma algvormita */
mrfFlags.Off(MF_GENE); /* eemaldame GENE piirangud sonavormide valikule */
}
if (!ajutine_tulemus.on_tulem()
&& nLopud.otsi_lyh_vorm((const FSxCHAR *)lopp) == NULL)
{
res = kchk1(&ctoo_variandid.ptr, &algus, algus.GetLength(), &csobivad_variandid.ptr, NULL,0); /* ty+lp */
if (res > ALL_RIGHT)
return res; /* viga! */
ahelad_vabaks(&ctoo_variandid.ptr);
if (csobivad_variandid.ptr)
{
variandid_tulemuseks(&ajutine_tulemus, lubatud_liik, &csobivad_variandid.ptr);
ahelad_vabaks(&csobivad_variandid.ptr);
}
if (!ajutine_tulemus.on_tulem())
{
if (TaheHulgad::AintSuured(&algus))
{
FSXSTRING suuralgus;
suuralgus = pisialgus;
TaheHulgad::AlgusSuureks(&suuralgus);
res = chkwrd(&ajutine_tulemus, &suuralgus, suuralgus.GetLength(), 1, tagasi, LIIK_PARISNIMI);
if (res > ALL_RIGHT)
return res; // viga!
}
}
if (!ajutine_tulemus.on_tulem())
{
res = chkwrd(&ajutine_tulemus, &pisialgus, pisialgus.GetLength(), 6, tagasi, lubatud_liik);
if (res > ALL_RIGHT)
return res; /* viga! */
}
}
if (viimane && ajutine_tulemus.on_tulem() && ette.on_tulem())
{
if (TaheHulgad::SuurAlgustaht(&algus))
{
ajutine_tulemus.TulemidNimeks(KOIK_LIIGID);
}
}
if ( ( !ajutine_tulemus.on_tulem() && !viimane ) || /* ei saanud veel analyysitud */
( mitu==0 && ajutine_tulemus.Get_lopp(FSxSTR("0")) == -1
&& ajutine_tulemus.Get_vormid(FSxSTR("?, ")) == -1) ) /* v�i leia veel variante*/
{
*tagasi = 1;
if (pisialgus.GetLength() < PREFLEN)
{
i = preffnr((FSxCHAR *)(const FSxCHAR *)pisialgus);
if ( i != -1 ) // selline prefiks on olemas
ajutine_tulemus.Add((const FSxCHAR *)pisialgus, FSxSTR(""), FSxSTR(""), FSxSTR("S"), FSxSTR("?, ")); // parema puudusel
}
}
if (ajutine_tulemus.on_tulem())
{
sobiv_an = ajutine_tulemus.Get_vormid(FSxSTR("sg g,")); /* eelistame sg g tyve */
}
if (!ajutine_tulemus.on_tulem()) /* ikka ei saanud veel analyysitud */
{ /* kas on LYH-LYH... */
if ( !viimane ) /* */
{
mrfFlags.OnOff(MF_ALGV, rezz); /* analyys nagu korgemalt ette antud */
mrfFlags.OnOff(MF_GENE, rezz1); /* analyys nagu korgemalt ette antud */
FSXSTRING pisilopp;
pisilopp = algus;
pisilopp += kriips;
pisilopp += lopp;
res = chklyh2(&ajutine_tulemus, &pisilopp); /* nt. MM-il */
if (res > ALL_RIGHT)
return res; /* viga! */
if (!ajutine_tulemus.on_tulem()) /* ikka ei saanud veel analyysitud */
{
res = chknr2(&ajutine_tulemus, &pisilopp); /* nt. uraan-253-s */
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!ajutine_tulemus.on_tulem()) /* ikka ei saanud veel analyysitud */
{
res = chklyh3(&ajutine_tulemus, &pisilopp, 1, &tmp);
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (ajutine_tulemus.on_tulem())
viimane = 1;
else
mrfFlags.Off(MF_ALGV); /* on vaja, et analu"u"siks nagu ilma algvormita */
mrfFlags.Off(MF_GENE); /* eemaldame GENE piirangud sonavormide valikule */
}
}
if (!ajutine_tulemus.on_tulem())
{
res = chklyh3(&ajutine_tulemus, &algus, 1, &tmp); /* nt. MMil */
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!ajutine_tulemus.on_tulem())
{
res = chklyh4(&ajutine_tulemus, &algus, algus.GetLength()); /* nt. MM */
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!ajutine_tulemus.on_tulem() && algus.GetLength()==1)
{
res = chklyh0(&ajutine_tulemus, &algus, algus.GetLength()); // nt. b; teeb valesti DV-d
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!ajutine_tulemus.on_tulem()) /* ikka ei saanud veel analyysitud */
{
if (mitu > 0) // et v�ltida juhtumeid nagu 253-uraan
res = chknr2(&ajutine_tulemus, &algus); /* nt. uraan-253 */
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (ajutine_tulemus.on_tulem() && !viimane)
{
if (sobiv_an == -1)
sobiv_an = 0; /* v�tame suvaliselt esimese tyve */
// parandada
// if ( ajutine_tulemus.Get(tul_tyvi, tul_lopp, tul_sl, tul_vorm, &sobiv_an) == NULL )
// return ILL_LINE_LEN; // seda ei saa olla; suvaline veateade
t.Start(*(ajutine_tulemus[sobiv_an]));
}
if (!ajutine_tulemus.on_tulem() /* ikka ei saanud veel analyysitud */
|| (TaheHulgad::OnLopus(&pisialgus, FSxSTR("is")) /*(!strcmp(s1+s1_pik-2, "is")*/ && viimane && lopus_kriips)) /* voi on see nagu kahtlane */
{
mrfFlags.Off(MF_ALGV); /* on vaja, et analu"u"siks nagu ilma algvormita */
mrfFlags.Off(MF_GENE); /* eemaldame GENE piirangud sonavormide valikule */
if (sobiks_ne(&pisialgus, pisialgus.GetLength()))
katsenr = 0;
else if (pisialgus.GetLength() > 4 &&
(TaheHulgad::OnLopus(&pisialgus, FSxSTR("is")) || TaheHulgad::OnLopus(&pisialgus, FSxSTR("las"))))
katsenr = 1;
else
katsenr = 2;
///////////////////////////////// pooleli
MRFTULEMUSED ajutine_tulemus1;
FSXSTRING katse;
katse = pisialgus;
katse += lisakatse[katsenr].otsa_panna;
res = chkwrd(&ajutine_tulemus1, &katse, katse.GetLength(), 6, tagasi, lisakatse[katsenr].lubatud_sl);
if (res > ALL_RIGHT)
return res; /* viga! */
if (ajutine_tulemus1.on_tulem()) /* oli sona_ne, sona_is+t v sona+d */
{
j = ajutine_tulemus1.Get_lopp(lisakatse[katsenr].lubatud_lopp);
if (j != -1 ) /* analyys sobis */
{
t.Start(*(ajutine_tulemus1[j]));
t.tyvi = (const FSxCHAR *)(t.tyvi.Left(t.tyvi.GetLength()-lisakatse[katsenr].mitu_eemaldada));
t.lopp = FSxSTR("0");
ajutine_tulemus.Add((t.tyvi), FSxSTR(""), FSxSTR(""), (const FSxCHAR *)t.sl, FSxSTR("?, "));
}
}
}
if (!ajutine_tulemus.on_tulem())
{
mrfFlags.OnOff(MF_ALGV, rezz); /* analyys nagu korgemalt ette antud */
mrfFlags.OnOff(MF_GENE, rezz1); /* analyys nagu korgemalt ette antud */
return ALL_RIGHT;
}
if (!viimane)
{
ette.AddClone(t);
}
else
{
tulemus->Move2Tail(&ajutine_tulemus);
break;
}
}
mrfFlags.OnOff(MF_ALGV, rezz); /* analyys nagu korgemalt ette antud */
mrfFlags.OnOff(MF_GENE, rezz1); /* analyys nagu korgemalt ette antud */
if (tulemus->Get_sl( FSxSTR("H") ) != -1
&& TaheHulgad::OnSuur(S6nna, 0)) /* vaja panna va'ljundisse suured ta'hed tagasi */
{
ette.AlgusedSuureks();
}
if (ette.on_tulem())
tulemus->PlakerdaKokku(&ette, (const FSxCHAR *)kriips, &mrfFlags);
if (*tagasi < 4)
*tagasi = 4;
return ALL_RIGHT;
}
