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;
}
/*
* kui s�naliik koos l�pugrupiga on sama, mis lubamatu liik oma l�pugrupiga, siis return(true); muidu return (false)
*/
bool MORF0::on_paha_sl( TYVE_INF *grupid, const int lg_nr, const FSxCHAR *sl,
const FSxCHAR lubamatu_liik )
{
FSXSTRING slsonalk;
int i;
slsonalk = sl;
for (i=0; i < slsonalk.GetLength(); i++)
{
if (slsonalk[i] == lubamatu_liik && lg_nr == GetLgNr(grupid, i))
return(true);
}
return(false);
}
/*
* 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);
}
const FSWCHAR* MRF2YH2MRF::Poore( // välja ühestajamärgend
const FSXSTRING* p_vorm) const
{
MRF2YH_LOEND* p_rec;
FSXSTRING vorm = *p_vorm;
vorm.TrimRight(FSWSTR(", "));
if(vorm[0]==(FSWCHAR)0 || vorm[0]==(FSWCHAR)'?')
{
return NULL;
}
p_rec=poorded.Get((FSWCHAR*)(const FSWCHAR*)vorm);
if(p_rec!=NULL)
{
return p_rec->p_yhTag;
}
return NULL;
}
const FSWCHAR* MRF2YH2MRF::Kaane( // välja ühestajamärgend
const FSXSTRING* p_vorm) const
{
MRF2YH_LOEND* p_rec;
FSXSTRING vorm = *p_vorm;
vorm.TrimRight(FSWSTR(", "));
int nihe=0;
if(TaheHulgad::OnAlguses(&vorm, FSWSTR("sg "))==true ||
TaheHulgad::OnAlguses(&vorm, FSWSTR("pl "))==true)
{
nihe += 3;
}
if(vorm[nihe]==(FSWCHAR)0 || vorm[nihe]==(FSWCHAR)'?')
{
return NULL; //TUNDMATU_P_YM
}
p_rec=kaanded.Get((FSWCHAR*)(const FSWCHAR*)vorm+nihe); // tabelist mrf2yhKaands
if(p_rec!=NULL) // igaks juhuks; peaks alati olema tõene
{
return p_rec->p_yhTag;
}
return NULL; //TUNDMATU_P_YM
}
int MORF0::chknr2(MRFTULEMUSED *tulemus, FSXSTRING *S6na)
{
int res;
//int tulem = -1; //FS_Failure;
int tagasi1;
const FSxCHAR *vn;
FSXSTRING s_algus, sona, s, ss;
FSXSTRING kriips, lopp;
FSXSTRING tmpsona, vorminimi, tmplopp;
int tyyp=0, s_pik;
#define PROTSENT 2
#define KELL 3
#define ARV 4
#define NUMBER 5
#define KRAAD 6
#define KRAADC 7
#define PARAGRAHV 8
FSxCHAR vi=0;
FSXSTRING kl;
kl = FSxSTR("CFK");
s_algus = (const FSxCHAR *)(S6na->Mid(0,1));
if (s_algus == FSxSTR("+") || s_algus == FSxSTR("-"))
sona = (const FSxCHAR *)(S6na->Mid(1));
else
{
sona = *S6na;
s_algus = FSxSTR("");
}
s = (const FSxCHAR *)(sona.SpanIncluding((const FSxCHAR *)(TaheHulgad::protsendinumber)));
if (s.GetLength() != 0)
if (TaheHulgad::OnLopus(&s, FSxSTR("%")) || TaheHulgad::OnLopus(&s, FSxSTR("%-")))
tyyp = PROTSENT;
if (!tyyp)
{
// vi = s[s.GetLength()-1];
s = (const FSxCHAR *)(sona.SpanIncluding((const FSxCHAR *)(TaheHulgad::kraadinrtht)));
if (s.GetLength() != 0)
{
if (TaheHulgad::OnLopus(&s, (const FSxCHAR *)(TaheHulgad::kraad))
|| TaheHulgad::OnLopus(&s, (const FSxCHAR *)(TaheHulgad::kraadjakriips)))
tyyp = KRAAD;
else
{
if (s.GetLength() > 2)
{
vi = s[s.GetLength()-1];
if (s.Find((const FSxCHAR *)(TaheHulgad::kraad)) == s.GetLength()-2 && kl.Find(vi)!=-1)
tyyp = KRAADC;
}
}
}
}
if (!tyyp)
{
s = (const FSxCHAR *)(S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::paranumber)));
if (s.GetLength() != 0)
if (TaheHulgad::OnAlguses(&s, (const FSxCHAR *)(TaheHulgad::para)))
tyyp = PARAGRAHV;
}
if (!tyyp)
{
if (sona.FindOneOf((const FSxCHAR *)(TaheHulgad::number)) == -1) // polegi numbrit kuskil...
return ALL_RIGHT;
s = (const FSxCHAR *)(sona.SpanIncluding((const FSxCHAR *)(TaheHulgad::kellanumber)));
ss = (const FSxCHAR *)(sona.SpanIncluding((const FSxCHAR *)(TaheHulgad::arv)));
if (s_algus.GetLength() == 0) // +- pole ees
{
if (s.GetLength() > ss.GetLength())
tyyp = KELL;
else if (ss.GetLength() != 0 && s.GetLength() <= ss.GetLength())
{
s = ss;
tyyp = ARV;
}
}
else // kellaajal ei tohi +- olla
{
if (ss.GetLength() !=0)
{
s = ss;
tyyp = ARV;
}
}
}
if (!tyyp) // ei saa olla...
return ALL_RIGHT;
/////
s_pik = s.GetLength();
lopp = (const FSxCHAR *)(S6na->Mid(s_pik+s_algus.GetLength()));
kriips = (const FSxCHAR *)(s.Mid(s_pik-1+s_algus.GetLength()));
if (kriips != FSxSTR("-"))
kriips = FSxSTR("");
s.TrimRight(FSxSTR("-"));
if (TaheHulgad::PoleMuudKui(&s, &(TaheHulgad::number)))
tyyp = NUMBER;
if (lopp.GetLength() == 0) // loppu pole
{
if (tyyp == NUMBER)
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("N"), FSxSTR("?, "));
else if (tyyp == ARV || tyyp == KELL)
{
if (TaheHulgad::OnLopus(&s, FSxSTR(".")) && kriips == FSxSTR(""))
{
FSXSTRING nn;
// nn = s;
nn = (const FSxCHAR *)(s.Mid(0, s.GetLength()-1));
if (TaheHulgad::PoleMuudKui(&nn, &TaheHulgad::number)) // ainult nr.
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("O"), FSxSTR("?, "));
else
{
int kr, kr_pik;
kr_pik = 2;
kr = nn.Find(FSxSTR(".-"));
if (kr == -1)
kr = nn.Find(FSxSTR("./"));
if (kr == -1)
{
kr_pik = 1;
kr = nn.Find(FSxSTR("-"));
}
if (kr == -1)
kr = nn.Find(FSxSTR("/"));
if (kr == -1)
{
kr_pik = 3;
kr = nn.Find(FSxSTR("..."));
}
if (kr != -1)
{ // 11.-12. v�i 11-12.
FSXSTRING nn1, nn2;
nn1 = (const FSxCHAR *)(nn.Left(kr));
nn2 = (const FSxCHAR *)(nn.Mid(kr+kr_pik));
if (TaheHulgad::PoleMuudKui(&nn1, &(TaheHulgad::number))
&& TaheHulgad::PoleMuudKui(&nn2, &(TaheHulgad::number)))
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("O"), FSxSTR("?, "));
}
else
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("N"), FSxSTR("?, "));
}
}
else
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("N"), FSxSTR("?, "));
}
else if (tyyp == KRAAD || tyyp == KRAADC)
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, "));
else if (tyyp == PROTSENT || tyyp == PARAGRAHV)
{
if (s_pik == 1) // %, paragrahv on lyhend
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, "));
else
{
if (tyyp==PARAGRAHV && s_pik==2 && s[0]==s[1]) // parapara
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, "));
else
{
if (s.FindOneOf((const FSxCHAR *)(TaheHulgad::number)) == -1) // polegi numbrit kuskil...
return ALL_RIGHT;
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("N"), FSxSTR("?, "));
}
}
}
return ALL_RIGHT;
}
if (s.GetLength() > 0)
{
vi = s[s.GetLength()-1];
if (!(TaheHulgad::number.Find(vi)!=-1 || vi==(FSxCHAR)'%' ||
TaheHulgad::kraad.Find(vi)!=-1 || kl.Find(vi)!=-1 || // ei l�ppe numbri, % ega kraadiga
(tyyp==PARAGRAHV && s.GetLength()==1) )) // ega ole lihtsalt paragrahvim�rk
return ALL_RIGHT; // pole korrektne number
}
if (TaheHulgad::AintSuured(&lopp))
lopp.MakeLower();
if (!TaheHulgad::PoleSuuri(&lopp))
return ALL_RIGHT; // oli suured-va"iksed segamini
if (loend.nr_lyh.Get((FSxCHAR *)(const FSxCHAR *)lopp))
{
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, "));
return ALL_RIGHT;
}
tmpsona = s_algus;
tmpsona += s;
if (s.GetLength()==1 && (tyyp==PARAGRAHV || tyyp == PROTSENT)) // %-des
{
vn = nLopud.otsi_nr_vorm((const FSxCHAR *)lopp);
if (vn == NULL && TaheHulgad::OnAlguses(&lopp, FSxSTR("de")))
vn = nLopud.otsi_lyh_vorm((const FSxCHAR *)lopp);
if (vn != NULL)
{
vorminimi = vn;
vorminimi += FSxSTR(", ");
tulemus->Add((const FSxCHAR *)tmpsona,
(const FSxCHAR *)lopp, FSxSTR(""), FSxSTR("Y"), (const FSxCHAR *)vorminimi);
}
return ALL_RIGHT;
}
// if (lplen < 4) /* lihtne lopp */
if (lopp.GetLength() < 4)
{
vn = nLopud.otsi_nr_vorm((const FSxCHAR *)lopp);
if (vn != NULL)
{
vorminimi = vn;
vorminimi += FSxSTR(", ");
// if ( *(S6na+k-1) == '%' || !strncmp(S6na+k-2, "%-", 2) || !strncmp(S6na+k-2, "\260-", 2))
if (tyyp == PROTSENT || tyyp == KRAAD || tyyp == KRAADC ||
(tyyp==PARAGRAHV && (s.GetLength()==1 || s[0]==s[1])))
tulemus->Add((const FSxCHAR *)tmpsona,
(const FSxCHAR *)lopp, FSxSTR(""), FSxSTR("Y"), (const FSxCHAR *)vorminimi);
else
tulemus->Add((const FSxCHAR *)tmpsona,
(const FSxCHAR *)lopp, FSxSTR(""), FSxSTR("N"), (const FSxCHAR *)vorminimi);
return ALL_RIGHT;
}
}
// if ( *(S6na+k-1) == '\260' && strncmp(sisesona, "si", 2) ) // kraadima'rk; iga lopp ei sobi kah...
if (tyyp == KRAAD && !TaheHulgad::OnAlguses(&lopp, FSxSTR("si")))
{
vn = nLopud.otsi_ne_vorm((const FSxCHAR *)lopp);
// j = otsi(sisesona, (char **)ne_lopud, ne_loppe);
// if ( j != -1 )
if (vn != NULL)
{
vorminimi = vn;
vorminimi += FSxSTR(", ");
if (mrfFlags.Chk(MF_ALGV)) // algvormiks on kraadine
{
tmpsona += FSxSTR("=ne");
}
else
{
tmpsona += FSxSTR("=");
if (lopp==FSxSTR("ne") || lopp==FSxSTR("se"))
tmpsona += lopp;
else if (lopp==FSxSTR("st"))
tmpsona += FSxSTR("s");
else if (TaheHulgad::OnAlguses(&lopp, FSxSTR("se")))
tmpsona += FSxSTR("se");
else if (TaheHulgad::OnAlguses(&lopp, FSxSTR("ste")))
tmpsona += FSxSTR("s");
else // ei saa olla
return ALL_RIGHT;
}
if (lopp==FSxSTR("ne") || lopp==FSxSTR("se"))
tmplopp = FSxSTR("0");
else if (lopp==FSxSTR("st"))
tmplopp = FSxSTR("t");
else if (TaheHulgad::OnAlguses(&lopp, FSxSTR("se")))
tmplopp = (const FSxCHAR *)(lopp.Mid(2));
else if (TaheHulgad::OnAlguses(&lopp, FSxSTR("ste")))
tmplopp = (const FSxCHAR *)(lopp.Mid(1));
else // ei saa olla
return ALL_RIGHT;
tulemus->Add((const FSxCHAR *)tmpsona,
(const FSxCHAR *)tmplopp, FSxSTR(""), FSxSTR("A"), (const FSxCHAR *)vorminimi);
}
}
if (tulemus->on_tulem())
return ALL_RIGHT;
/*
if ( !strcmp(sisesona, "ne"))
if ( strchr(num, *(S6na+k-2))) // vahemalt 2-kohaline nr
*/
if (lopp == FSxSTR("ne")) // 115-ne 20-ne
{
if (s.GetLength()>1 && tyyp == NUMBER)
{
FSxCHAR elvi;
elvi = s[s.GetLength()-2];
if (vi==(FSxCHAR)'0' || elvi==(FSxCHAR)'1')
{
if ( !mrfFlags.Chk(MF_ALGV) ) // ei taheta algvormi
{
/*
if ( *(S6na+k) == '-' )
strcat( tmpsona, "-" );
strcat( tmpsona, sisesona );
*/
tmpsona += kriips;
tmpsona += lopp;
}
}
tulemus->Add((const FSxCHAR *)tmpsona, FSxSTR("0"), FSxSTR(""), FSxSTR("N"), FSxSTR("sg g, "));
}
return ALL_RIGHT;
}
// if (strchr("03456789", *(S6na+k-1)) && !strncmp(sisesona, "nda", 3)) // nda...
if (TaheHulgad::OnAlguses(&lopp, FSxSTR("nda")) && tyyp == NUMBER && s.GetLength()>0)
{
int nda = 0;
if (TaheHulgad::ndanumber.Find(vi)!=-1)
nda =1;
else
{
if (s.GetLength()>1)
{
FSxCHAR elvi;
elvi = s[s.GetLength()-2];
if (elvi==(FSxCHAR)'1') // 11-nda
nda = 1;
}
}
if (nda)
{
vorminimi = FSxSTR("");
if (lopp == FSxSTR("nda"))
{
vorminimi = FSxSTR("sg g");
tmplopp = FSxSTR("0");
}
else
{
FSXSTRING lopp_3;
lopp_3 = (const FSxCHAR *)lopp.Mid(3);
vn = nLopud.otsi_nda_vorm((const FSxCHAR *)lopp_3);
if (vn != NULL) // on mingi lopp
{
vorminimi = vn;
tmplopp = lopp_3;
}
}
}
if ( vorminimi.GetLength() !=0 ) // mingi vorm sobiski
{
if ( !mrfFlags.Chk(MF_ALGV) ) /* ei taheta algvormi */
{
tmpsona += kriips;
tmpsona += FSxSTR("nda");
}
else
tmpsona += FSxSTR("=s");
vorminimi += FSxSTR(", ");
tulemus->Add((const FSxCHAR *)tmpsona,
(const FSxCHAR *)tmplopp, FSxSTR(""), FSxSTR("O"), (const FSxCHAR *)vorminimi);
return ALL_RIGHT;
}
}
/* a"kki on hoopis nr-sona v�i 8aastane */
if (kriips.GetLength() == 1 || (kriips.GetLength()==0 && (tyyp==ARV || tyyp==NUMBER))) //kuni 8. aprill 2005 oli tyyp==NUMBER HJK
{
if (!TaheHulgad::OnAlguses(&lopp, FSxSTR("lise")) &&
!TaheHulgad::OnAlguses(&lopp, FSxSTR("lasi")) && lopp.GetLength() > 3)
{
res = chkwrd(tulemus, &lopp, lopp.GetLength(), 100, &tagasi1, LIIK_A);
if (res > ALL_RIGHT)
return res; /* viga! */
}
if (!tulemus->on_tulem()) /* analyys ebannestus */
if ( lopp == FSxSTR("kaupa") )
tulemus->Add((const FSxCHAR *)lopp, FSxSTR("0"), FSxSTR(""), FSxSTR("D"), FSxSTR("")); /* HJK 07.06.01; pole endas eriti kindel */
}
if (tulemus->on_tulem()) /* analyys �nnestus */
{
tmpsona += FSxSTR("_");
tulemus->LisaTyvedeleEtte((const FSxCHAR *)tmpsona);
return ALL_RIGHT;
}
if (lopp.GetLength() == 1 && TaheHulgad::eestitht.Find(lopp[0])!=-1 ) /* 1 taht voib ikka lopus olla */
{
tulemus->Add((const FSxCHAR *)(*S6na), FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, "));
return ALL_RIGHT;
}
return ALL_RIGHT;
}
int MORF0::chklyh3(MRFTULEMUSED *tulemus, FSXSTRING *S6na, int sygavus, int *tagasitasand)
{
int i;
int res;
FSXSTRING tmpsona, tmplopp, tmpliik, vorminimi;
//int tulem = -1; //FS_Failure;
const FSxCHAR *vn;
FSXSTRING s; // sona ise
FSXSTRING kriips(FSxSTR("")); // kriips (kui teda on)
FSXSTRING lopp; // l�pp ise
FSXSTRING ne_lopp; // line lane lopu jaoks
FSXSTRING lali; // line lane alguse jaoks
FSXSTRING ss; //
int s_pik;
int tyyp=0;
#define LYHEND 1
#define PROTSENT 2
#define KELL 3
#define PARAGRAHV 4
#define NUMBER 5
#define KRAAD 6
#define MATA 6
// if ( !ChIsUpper(*S6na) && *S6na != '%' && *S6na != para) /* ei alga suure t�hega */
// if (!TaheHulgad::OnSuur(S6na, 0) && (*S6na)[0] != (FSxCHAR)'%' && (*S6na)[0] != TaheHulgad::para[0]
if (TaheHulgad::AintSuuredjaNrjaKriipsud(S6na)) /* v�ib olla lihtsalt suuret�heline s�na */
return ALL_RIGHT; /* ei suru v�gisi l�hendiks */
s = (const FSxCHAR *)S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::protsendinumber));
if (s.GetLength() != 0)
if (TaheHulgad::OnLopus(&s, FSxSTR("%")) || TaheHulgad::OnLopus(&s, FSxSTR("%-")))
tyyp = PROTSENT;
if (!TaheHulgad::OnSuur(S6na, 0) && tyyp != PROTSENT && (*S6na)[0] != TaheHulgad::para[0] )
return ALL_RIGHT;
if (!tyyp)
{
s = (const FSxCHAR *)(S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::kraadinumber)));
if (s.GetLength() != 0)
if (TaheHulgad::OnLopus(&s, (const FSxCHAR *)(TaheHulgad::kraad))
|| TaheHulgad::OnLopus(&s, (const FSxCHAR *)(TaheHulgad::kraadjakriips)) )
tyyp = KRAAD;
}
if (!tyyp)
{
s = (const FSxCHAR *)(S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::paranumber)));
if (s.GetLength() != 0)
if (TaheHulgad::OnAlguses(&s, (const FSxCHAR *)(TaheHulgad::para)))
tyyp = PARAGRAHV;
}
if (!tyyp)
{
s = (const FSxCHAR *)(S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::matemaatika1)));
if (s.GetLength() == 2 && TaheHulgad::OnLopus(&s, FSxSTR("-")))
tyyp = MATA;
}
if (!tyyp)
{
s = (const FSxCHAR *)(S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::suurnrthtkriips)));
ss = (const FSxCHAR *)(S6na->SpanIncluding((const FSxCHAR *)(TaheHulgad::kellanumber)));
if (s.GetLength() > ss.GetLength())
tyyp = LYHEND;
else if (ss.GetLength() != 0 && s.GetLength() <= ss.GetLength())
{
s = ss;
tyyp = KELL;
}
}
if (!tyyp) // ei saa olla...
return ALL_RIGHT;
s_pik = s.GetLength();
lopp = (const FSxCHAR *)(S6na->Mid(s_pik));
if (lopp.GetLength()==0) // pole siin midagi vaadata
return ALL_RIGHT;
kriips = (const FSxCHAR *)(s.Mid(s_pik-1));
if (kriips != FSxSTR("-"))
kriips = FSxSTR("");
if (tyyp == LYHEND && kriips == FSxSTR("")) // ebakindel v�rk
{
if (s.GetLength()==1) // nt Arike
return ALL_RIGHT;
i = s.ReverseFind(FSxSTR("-"));
if (i == s.GetLength()-2)
return ALL_RIGHT; // nt CD-Romile
}
s.TrimRight(FSxSTR("-"));
if (s.GetLength()==0) // pole siin midagi vaadata
return ALL_RIGHT;
if (TaheHulgad::PoleMuudKui(&s, &TaheHulgad::number))
tyyp = NUMBER;
/* oletan, et on lyhend vm lubatud asi */
i = 1;
if (tyyp == LYHEND)
{
if(mrfFlags.Chk(MF_LYHREZH))
{
if (s.GetLength() == 1 || (!mrfFlags.Chk(MF_SPELL) && s.GetLength() < 7))
i = 1;
else
i = (dctLoend[3])[(FSxCHAR *)(const FSxCHAR *)s];
}
}
// *(S6na+k) = taht; /* taastan esialgse sona */
if (i==-1) /* pole lyhend */
return ALL_RIGHT;
if ((s.GetLength() > 1 && tyyp == LYHEND && (TaheHulgad::OnAlguses(&lopp, FSxSTR("la")) || TaheHulgad::OnAlguses(&lopp, FSxSTR("li"))) )
|| ((tyyp == NUMBER || tyyp == PROTSENT || tyyp == KRAAD) && TaheHulgad::OnAlguses(&lopp, FSxSTR("li"))) )
{
ne_lopp = (const FSxCHAR *)(lopp.Mid(2));
lali = (const FSxCHAR *)(lopp.Left(2));
vn = nLopud.otsi_ne_vorm((const FSxCHAR *)ne_lopp);
if (vn != NULL) /* ongi line lise ... voi lane lase ... */
{
vorminimi = vn;
vorminimi += FSxSTR(", ");
tmpsona = s;
if (kriips.GetLength() == 1 && !mrfFlags.Chk(MF_ALGV))
tmpsona += kriips;
else
tmpsona += FSxSTR("=");
tmpsona += lali;
if (mrfFlags.Chk(MF_ALGV) || vorminimi == FSxSTR("sg n, "))
tmpsona += FSxSTR("ne");
else
{
if (TaheHulgad::OnAlguses(&vorminimi, FSxSTR("pl")) || TaheHulgad::OnAlguses(&vorminimi, FSxSTR("sg p")))
tmpsona += FSxSTR("s");
else
tmpsona += FSxSTR("se");
}
if (ne_lopp == FSxSTR("ne") || ne_lopp == FSxSTR("se"))
tmplopp = FSxSTR("0");
else if (ne_lopp == FSxSTR("st"))
tmplopp = FSxSTR("t");
else if (TaheHulgad::OnAlguses(&vorminimi, FSxSTR("sg")))
tmplopp = (const FSxCHAR *)(ne_lopp.Mid(2));
else
tmplopp = (const FSxCHAR *)(ne_lopp.Mid(1));
if (lali == FSxSTR("la"))
tmpliik = FSxSTR("S");
else
tmpliik = FSxSTR("A");
tulemus->Add((const FSxCHAR *)tmpsona, (const FSxCHAR *)tmplopp, FSxSTR(""),
(const FSxCHAR *)tmpliik, (FSxCHAR *)(const FSxCHAR *)vorminimi);
*tagasitasand = 1;
return ALL_RIGHT;
}
}
vn = nLopud.otsi_lyh_vorm((const FSxCHAR *)lopp);
if (vn == NULL)
{
if (tyyp == LYHEND && (kriips.GetLength() != 0 || mrfFlags.Chk(MF_OLETA)) && // LYH-sona
!TaheHulgad::OnAlguses(&lopp, FSxSTR("lise")) && !TaheHulgad::OnAlguses(&lopp, FSxSTR("lasi")) )
{
res = chkwrd(tulemus, &lopp, lopp.GetLength(), sygavus, tagasitasand, LIIK_SACU);
if (res > ALL_RIGHT)
return res; /* viga! */
if ( tulemus->on_tulem() ) /* analyys �nnestus */
{
s += kriips;
tulemus->LisaTyvedeleEtte((const FSxCHAR *)s);
}
}
return ALL_RIGHT;
}
if (tyyp != LYHEND)
return ALL_RIGHT;
/* vist lihtne l�pp */
*tagasitasand = 1;
if (TaheHulgad::OnAlguses(&lopp, FSxSTR("te")) )// akronyymidele sellised lopud ei sobi
return ALL_RIGHT;
if (lopp == FSxSTR("i"))
vorminimi = FSxSTR("adt, sg g, sg p, ");
else if (lopp == FSxSTR("d"))
vorminimi = FSxSTR("pl n, sg p, ");
else
{
vorminimi = vn;
vorminimi += FSxSTR(", ");
}
FSxCHAR vi;
FSXSTRING fl;
vi = s[s.GetLength()-1];
fl = FSxSTR("FLMNRS");
if (vi == (FSxCHAR)'J'); // jott voi dzhei; iga lopp sobib...
else if (TaheHulgad::para.Find(vi) != -1 || vi == (FSxCHAR)'%')
{
if (lopp == FSxSTR("d"))
vorminimi = FSxSTR("pl n, ");
}
else if (fl.Find(vi) != -1)
{
if (!mrfFlags.Chk(MF_OLETA))
{
if (!TaheHulgad::OnAlguses(&lopp, FSxSTR("i")) && !TaheHulgad::OnAlguses(&lopp, FSxSTR("e")))
return ALL_RIGHT; // yldse ei sobinud
}
else if (lopp == FSxSTR("d"))
vorminimi = FSxSTR("pl n, ");
}
else
{
//vi = s.SuurPisiks(s.GetLength()-1); // tahan lihtsalt vi pisiks teha
vi = TaheHulgad::SuurPisiks(&s, s.GetLength()-1); // tahan lihtsalt vi pisiks teha
if (TaheHulgad::taish.Find(vi) != -1) // lyh lopus vokaal
{
if (TaheHulgad::OnAlguses(&lopp, FSxSTR("i")) || TaheHulgad::OnAlguses(&lopp, FSxSTR("e")))
return ALL_RIGHT; // yldse ei sobinud
}
if (!mrfFlags.Chk(MF_OLETA))
{
if (s.GetLength() == 1)
{
if (TaheHulgad::OnAlguses(&lopp, FSxSTR("i")) || TaheHulgad::OnAlguses(&lopp, FSxSTR("e")))
return ALL_RIGHT; // yldse ei sobinud
}
else
{
FSxCHAR eelvi;
eelvi = TaheHulgad::SuurPisiks(&s, s.GetLength()-2);
if (TaheHulgad::taish.Find(eelvi)==-1 &&
s != FSxSTR("GOST") && s != FSxSTR("GATT") && s != FSxSTR("SAPARD") && s != FSxSTR("SARS"))
if (TaheHulgad::OnAlguses(&lopp, FSxSTR("i")) || TaheHulgad::OnAlguses(&lopp, FSxSTR("e")))
return ALL_RIGHT; // yldse ei sobinud
}
}
}
tulemus->Add((const FSxCHAR *)s, (const FSxCHAR *)lopp, FSxSTR(""),
FSxSTR("Y"), (const FSxCHAR *)vorminimi);
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::chkgeon(MRFTULEMUSED *tul, FSXSTRING *sona, int *mitu)
{
int res;
FSXSTRING gsona;
FSXSTRING gsona3;
FSXSTRING lylist1Puhastatud, lylist2Puhastatud;
CVARIANTIDE_AHEL ctoo_variandid, csobivad_variandid;
gsona = *sona;
TaheHulgad::Puhasta(&gsona);
if (mrfFlags.ChkB(MF_V0TAKOKKU)==false) // ära võta sõnu üheks üksuseks kokku
return ALL_RIGHT; // ... siis siin pole midagi teha; 04.2015
if ( ( (dctLoend[5])[(FSxCHAR *)(const FSxCHAR *)gsona] ) == -1 )
return ALL_RIGHT; // pole mitmesonal. geogr. nime 1. osa
gsona += FSxSTR("=");
//gsona += (FSxCHAR *)(konveier->LyliInf0(1));
lylist1Puhastatud=konveier->LyliInf0(1);
PuhastaXMList<FSXSTRING, FSWCHAR>(lylist1Puhastatud, mrfFlags.ChkB(MF_XML));
gsona += lylist1Puhastatud;
if (gsona.GetLength() >= STEMLEN)
return ALL_RIGHT; // pole mitmesonal. geogr. nimi
*mitu = 2;
//if ( ( (dctLoend[6])[(FSxCHAR *)(konveier->LyliInf0(1))] ) != -1 )
if ( ( (dctLoend[6])[(FSxCHAR *)(const FSxCHAR *)lylist1Puhastatud] ) != -1 )
{ // voib olla mitmesonal. geogr. nime 2. osa
gsona3 = gsona;
gsona3 += FSxSTR("=");
//gsona3 += (FSxCHAR *)(konveier->LyliInf0(2));
lylist2Puhastatud=konveier->LyliInf0(2);
PuhastaXMList<FSXSTRING, FSWCHAR>(lylist2Puhastatud, mrfFlags.ChkB(MF_XML));
gsona3+=lylist2Puhastatud;
if (gsona3.GetLength() < STEMLEN)
{
gsona = gsona3;
*mitu = 3;
}
}
TaheHulgad::Puhasta(&gsona);
gsona.TrimRight(FSxSTR("."));
// kontr, kas s�na on mitmeosaline geograafiline nimi + lp
TaheHulgad::AsendaMitu(&gsona, TaheHulgad::uni_kriipsud, TaheHulgad::amor_kriipsud);
res = kchk1(&ctoo_variandid.ptr, &gsona, gsona.GetLength(), &csobivad_variandid.ptr, NULL, 0);
if (res > ALL_RIGHT)
{
return res; // viga!
}
if (csobivad_variandid.ptr)
{
asenda_tyves(&csobivad_variandid.ptr, FSxSTR("="), FSxSTR(" "));
variandid_tulemuseks(tul, LIIK_PARISNIMI, &csobivad_variandid.ptr);
}
//ahelad_vabaks(&ctoo_variandid.ptr); //destruktoris
//ahelad_vabaks(&csobivad_variandid.ptr); //destruktoris
return ALL_RIGHT;
}
void MRF2YH2MRF::FsTags2YmmTags(
const FSXSTRING* p_sona,
MRFTUL* p_mTul,
FSXSTRING& yhmarg1,
FSXSTRING& yhmarg2,
FSXSTRING& yhmarg3
) const
{
FSUNUSED(yhmarg3);
MRF2YH_LOEND* p_rec;
const FSWCHAR* p_yTag;
// punktuatsioon --> ühestajamärgendiks
if(p_mTul->sl==FSWSTR("Z")) // sõnaliik oli punktuatsioon
{
p_rec=punktuatsioon.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
if(p_rec!= NULL) // oli meie punktuatsiooni loendis
{
//p_mTul->mrg1st=p_rec->p_yhTag;
yhmarg1=p_rec->p_yhTag;
return;
}
// p_rec==NULL -- polnud loendis...
else // vt kas esimene m�rk oli loendis
{
FSXSTRING algustht = p_sona->Left(1);
p_rec=punktuatsioon.Get((FSWCHAR*)(const FSWCHAR*)algustht);
if(p_rec!= NULL) // oli meie punktuatsiooni loendis
{
//p_mTul->mrg1st=p_rec->p_yhTag;
yhmarg1=p_rec->p_yhTag;
return;
}
}
// p_rec==NULL -- polnud loendis...
//p_mTul->mrg1st=FSWSTR("WIE"); //...vaikimisi see
//p_mTul->mrg1st=FSWSTR("X"); //...vaikimisi see
yhmarg1=FSWSTR("X"); //...vaikimisi see
return;
}
// sõna --> ühestajamärgendiks
// if(sonaliik != "H")
if(p_mTul->sl[0]!=(FSWCHAR)'H')
{
p_rec=sona.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
if(p_rec!= NULL) // oli meie sõnade loendis
{
//p_mTul->mrg1st=p_rec->p_yhTag;
yhmarg1=p_rec->p_yhTag;
return;
}
}
// endif
// sõnaliik + sõna --> ühestajamärgendiks
// DXIG -> RR RR II ASG t��tlus
if(muut1.Find(p_mTul->sl[0]) >= 0) // sõnaliik oli 'muut1' loendis
{
p_rec=rr.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
if(p_rec!= NULL) //
{
//p_mTul->mrg1st=p_rec->p_yhTag;
yhmarg1=p_rec->p_yhTag;
return;
}
// p_rec==NULL -- polnud loendis...
if((p_rec=noomTags.Get((FSWCHAR*)(const FSWCHAR*)(p_mTul->sl)))!=NULL)
{ // märgendi 1. pool
//p_mTul->mrg1st=p_rec->p_yhTag; // tuleneb sõnaliigist
yhmarg1=p_rec->p_yhTag;
return;
}
//p_mTul->mrg1st=FSWSTR("RR"); //...vaikimisi see VALE!!!!
// return;
}
// sõnaliik + sõnalõpp --> ühestajamärgendiks
// nud-tud-dud lõpulised V, A -> VMAZ (partitsiip)
if(verb_v_adj.Find(p_mTul->sl[0]) >= 0) // sõnaliik oli 'verb_v_adj' loendis
{
// kas sõna "[ntd]ud" lõpuline
if(TaheHulgad::OnLopus(p_sona, FSWSTR("nud"))==true ||
TaheHulgad::OnLopus(p_sona, FSWSTR("tud"))==true ||
TaheHulgad::OnLopus(p_sona, FSWSTR("dud"))==true )
{
//p_mTul->mrg1st=FSWSTR("VMAZ");
yhmarg1=FSWSTR("VMAZ");
return; //??
}
//return; //??
}
// sõnaliik + sõnalõpp --> ühestajamärgendiks
// nud-tud lõpulised S -> VMAZ (partitsiip)
// if(p_mTul->sl[0] == (FSWCHAR)'S')
// {
// // kas sõna "[nt]ud" lõpuline
// if(TaheHulgad::OnLopus(p_sona, FSWSTR("nud"))==true ||
// TaheHulgad::OnLopus(p_sona, FSWSTR("tud"))==true )
// {
// p_mTul->mrg1st=FSWSTR("VMAZ");
// return; //??
// }
// // return; //??
// }
// yks ja teine -> YKS* ja TEINE*
if(yks_v_teine_sonaliik.Find(p_mTul->sl[0]) >= 0) // sõnaliik oli 'yks_v_teine_sonaliik' loendis
{
//p_rec=yksTeine.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
p_rec=yksTeine.Get((FSWCHAR*)(const FSWCHAR*)p_mTul->tyvi);
if(p_rec!= NULL) // oli loendis
{ // märgendi 1. pool
//p_mTul->mrg1st=p_rec->p_yhTag; // tuleneb sõnast
yhmarg1=p_rec->p_yhTag;
p_yTag=Kaane(&(p_mTul->vormid));
if(p_yTag==NULL) // seda ei tohiks olla
{
//p_mTul->mrg1st=FSWSTR("PSX"); // TUNDMATU_P_YM
yhmarg1=FSWSTR("PSX"); // TUNDMATU_P_YM
return;
}
//p_mTul->mrg1st +=p_yTag; // märgendi 2. pool,
yhmarg1 += p_yTag; // märgendi 2. pool,
return; // tuleneb käändevormist
}
// p_rec==NULL -- polnud loendis, ei tee midagi
}
// P -> PP1 PP2 PP3 juhtumi tõõtlus
if(p_mTul->sl[0] == (FSWCHAR)'P')
{
//p_rec=ase.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
p_rec=ase.Get((FSWCHAR*)(const FSWCHAR*)p_mTul->tyvi);
if(p_rec!= NULL)
{ // märgendi 1. pool
//p_mTul->mrg1st=p_rec->p_yhTag; // tuleneb sõnast
yhmarg1=p_rec->p_yhTag;
p_yTag=Kaane(&(p_mTul->vormid));
if(p_yTag==NULL) // seda ei tohiks olla
{
//p_mTul->mrg1st=FSWSTR("PSX"); // TUNDMATU_P_YM
yhmarg1=FSWSTR("PSX"); // TUNDMATU_P_YM
return;
} // märgendi 2. pool,
//p_mTul->mrg1st += p_yTag; // tuleneb käädevormist
yhmarg1 += p_yTag; // tuleneb käädevormist
if(*p_sona == FSWSTR("tema") && yhmarg1==FSWSTR("PP3SG")) // väga kole!!!
{
// mõhh???
//p_mTul->mrg1st=FSWSTR("M");
//yhmarg1=FSWSTR("PP3SN"); HJK 23.11.2004 prooviks ikka ühestada...
return;
}
return;
}
// p_rec==NULL -- polnud loendis, ei tee midagi
}
// ACUSHNOPY -> A, A, A, NC, NP, MC, MO, P, Y töötlus
if((p_rec=noomTags.Get((FSWCHAR*)(const FSWCHAR*)(p_mTul->sl)))!=NULL)
{ // märgendi 1. pool
//p_mTul->mrg1st=p_rec->p_yhTag; // tuleneb sõnaliigist
yhmarg1=p_rec->p_yhTag; // tuleneb sõnaliigist
p_yTag=Kaane(&(p_mTul->vormid));
if(p_yTag==NULL)
{
if(p_mTul->sl==FSWSTR("A"))
{
//
MRF2YH_LOEND* p_rec2;
if((p_rec2=asxrr.Get((FSWCHAR*)(const FSWCHAR*)
(p_mTul->sl)))!=NULL)
{
//p_mTul->mrg1st=p_rec2->p_yhTag; // ASXRR asemele
yhmarg1=p_rec2->p_yhTag; // ASXRR asemele
return;
}
//p_mTul->mrg1st += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
yhmarg1 += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
return; // sappa juurde
}
if(TaheHulgad::OnLopus(&yhmarg1, FSWSTR("NP"))==true)
{
// et ei tekiks NPSX keerame ...NP --> ...NC
//p_mTul->mrg1st.Delete(p_mTul->mrg1st.GetLength()-1);
if(p_mTul->mrg1st.GetLength()>0) //TV071109
yhmarg1.Delete(p_mTul->mrg1st.GetLength()-1);
//p_mTul->mrg1st += FSWSTR("C");
yhmarg1 += FSWSTR("C");
}
//p_mTul->mrg1st += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
yhmarg1 += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
return; // sappa juurde
}
//p_mTul->mrg1st += p_yTag; // märgendi 2. pool
yhmarg1 += p_yTag; // märgendi 2. pool
return; // tulenb käändevormist
}
// J -> CS ja CC töötlus
if(p_mTul->sl[0] == (FSWCHAR)'J')
{
p_rec=sidec.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
if(p_rec!= NULL)
{
//p_mTul->mrg1st=p_rec->p_yhTag;
yhmarg1=p_rec->p_yhTag;
return;
}
//p_mTul->mrg1st=FSWSTR("CS");
yhmarg1=FSWSTR("CS");
return;
}
// K -> SP ja ST töötlus
if(p_mTul->sl[0] == (FSWCHAR)'K')
{
// TODO::
Kaas2Yh(p_sona, yhmarg1, yhmarg2);
// if(p_yTag==NULL) // seda ei tohiks olla
// {
// p_mTul->mrg1st=FSWSTR("ST");
// return;
// }
//p_mTul->mrg1st=p_yTag;
return;
}
// V -> VM töötlus
if(p_mTul->sl[0] == (FSWCHAR)'V')
{
//p_mTul->mrg1st=FSWSTR("VM"); // VERBI_YM
yhmarg1=FSWSTR("VM"); // VERBI_YM
p_yTag=Poore(&(p_mTul->vormid));
if(p_yTag==NULL)
{
//p_mTul->mrg1st += FSWSTR("S"); // MUUTUMATU_VERBI_TUNNUS
yhmarg1 += FSWSTR("S"); // MUUTUMATU_VERBI_TUNNUS
return;
}
if(sid_variandid==p_yTag)
{
// siin toimub veel midagi segast
//p_mTul->mrg1st += FSWSTR("3"); // YM_MA_VAHE
yhmarg2 = yhmarg1;
yhmarg1 += FSWSTR("2"); // YM_MA_VAHE
yhmarg2 += FSWSTR("3"); // YM_MA_VAHE
return;
}
//p_mTul->mrg1st += p_yTag;
yhmarg1 += p_yTag;
return;
}
assert(false);
//p_mTul->mrg1st=FSWSTR("X"); // TUNDMATU_LOOM
yhmarg1=FSWSTR("X"); // TUNDMATU_LOOM
}
bool ETMRFAS::GeneMTVDetailne(
MRFTULEMUSED *pValja,
FSXSTRING *gPrf, // käib tüve ette
const FSXSTRING *gTyviAlgne,
const FSXSTRING *pnaidis,
const FSXSTRING *sl, // sonaliigid, millesse kuuluvaid sõnu tahetakse
const FSXSTRING *geneVormid, // genetavate vormide loend
const int algv_lopp, // 0, -ma voi -d
const int algv_vorm, // sg_g, sg_n, ma või pl_n
const FSXSTRING *pGeneKigi)
{
int i, idx, res, k1, k2, nSonaLiiki;
//bool suur=false;
FSXSTRING *sonaLiigid;
FSXSTRING gTyviUus;
FSXSTRING genetud_tyvi, gene_t1, gene_t2, ette, gTyvi;
TYVE_INF tmp_dptr[SONAL_MAX_PIK];
TYVE_INF naidise_dptr[SONAL_MAX_PIK];
int naidise_idx=0, mitu_naidise_homon=0;
// leia näidissõna muutumisviis
if (pnaidis->GetLength() > 0)
{
res=cXXfirst((const FSxCHAR*) *pnaidis, pnaidis->GetLength(), &naidise_idx);
if(res == 0) // s.t. leidis mis vaja
{
sonaLiigid = sonaliik[naidise_idx];
mitu_naidise_homon = sonaLiigid->GetLength();
memmove(naidise_dptr, dptr, SizeOfLg2(mitu_naidise_homon));
}
}
gTyvi = *gTyviAlgne;
gene_t2 = *gTyviAlgne;
if (gTyvi.Find(FSxSTR(" "))!=-1)
gTyvi.Replace(FSxSTR(" "), FSxSTR("="), 1);
res=cXXfirst(&gTyvi,&idx);
if(res == POLE_SEDA || res == POLE_YLDSE)
{
// - ja / sisald. sonade jaoks HJK 20.05.98
k1 = gTyviAlgne->ReverseFind((FSxCHAR)'-')+1;
k2 = gTyviAlgne->ReverseFind((FSxCHAR)'/')+1;
if (k2 > k1)
k1 = k2;
if (k1 > 0)
{
// Võtame tagumise otsa järgi
gene_t2 = gTyviAlgne->Mid(k1);
ette = gTyviAlgne->Mid(0, k1);
res=cXXfirst(((const FSxCHAR*)gene_t2), gene_t2.GetLength(), &idx);
if(res == POLE_SEDA || res == POLE_YLDSE)
{
if (TaheHulgad::SuurAlgustaht(&gene_t2))
{
// viimane sõna suurtäheline
// teeme v?ikseks ja proovime uuesti
gene_t2.MakeLower();
res = cXXfirst(&gene_t2, &idx);
}
}
if(res == 0)
{
*gPrf += ette;
gPrf->Remove((FSxCHAR)'+'); // eemaldame asjatud +_=
gPrf->Remove((FSxCHAR)'_');
gPrf->Remove((FSxCHAR)'=');
}
}
else // sellist tyve pole, ja sõnas polnud ka - ega /
{ // proovin jõuga analüüsida analoogiliselt sõnadega, millel on samasugune lõpp e sufiks
return GeneSTV(pValja, gPrf, gTyviAlgne, sl, geneVormid, algv_lopp, algv_vorm, pGeneKigi);
}
}
if(res == POLE_SEDA || res == POLE_YLDSE) // seda ei saa olla
return true;
sonaLiigid=sonaliik[idx];
nSonaLiiki=sonaLiigid->GetLength();
memmove(tmp_dptr, dptr, SizeOfLg2(nSonaLiiki)); // tõsta dptr kõrvale, sest ta soditakse mujal ära
for(i=0; i < nSonaLiiki; i++)
{
// vaja kontrollida, kas on ikka vajaliku algvormi tüvi
gTyviUus = gene_t2;
if(OtsiTyvi(&(tmp_dptr[i].idx),
algv_lopp, algv_vorm, &gTyviUus)==false)
continue; //polnud sobiv tüvi
if(gTyviUus == gene_t2) // õige algvormi tüvi
{
if((*sonaLiigid)[i]==W_SL) // nagunii on ka S liigiline sõna leitud
continue;
if((*sonaLiigid)[i]==(FSxCHAR)'B' &&
sl->Find((FSxCHAR)'A') >=0)
{
// kah õige sõnaliik,
// tahad A-d saad B,
// aga ütleme, et said A
if(GeneTLDetailne(pValja, naidise_dptr, mitu_naidise_homon, gPrf, &gTyviUus,
(FSxCHAR)'A',
&(tmp_dptr[i]),geneVormid, pGeneKigi)==false)
return false; // crash
}
else if(sl->Find((*sonaLiigid)[i]) >= 0)
//if((*sl)[0]==(*(mrf->sonaliik[idx]))[i])
{
if(GeneTLDetailne(pValja, naidise_dptr, mitu_naidise_homon, gPrf, &gTyviUus,
(*sonaLiigid)[i],
&(tmp_dptr[i]),geneVormid, pGeneKigi)==false)
return false; // crash
}
}
}
return true;
}
int main(int argc, FSTCHAR **argv)
{
CPFSFile infile; /* viit sisendfailile */
CPFSFile outf, errf; /* viidad v@ljundfailidele */
CPFSFile lgrf; /* viit lõpugruppide failile LGR*/
FSXSTRING inbuf; /* toodeldav rida */
FSXSTRING outbuf; /* toodeldav rida */
CFSFileName fn_0, fn_1, fn_2;
int total, converted, unknown;
int k;
int kk, era;
FSXSTRING inbuf_era, inbuf_para_ind;
total = converted = unknown = 0;
if (argc != 4)
{
printf("pane argumendid taha !\n");
return EXIT_FAILURE;
}
else
{
fn_0=argv[1];
fn_1=argv[2];
fn_2=argv[3];
}
if (infile.Open(fn_0, FSTSTR("rb" )) == false ||
outf.Open( fn_1, FSTSTR("wb" )) == false ||
errf.Open( fn_2, FSTSTR("wb" )) == false ||
lgrf.Open( FSTSTR("lgr"), FSTSTR("ab+")) == false)
{
printf( "Can't open files\n" );
return EXIT_FAILURE;
}
loe_lgr( &lgrf ); /* loe lõpugrupid mällu */
tyvi[0].tyv = FSxSTR("");
for (total=0; infile.ReadLine(&inbuf)==true; total++)
{
era = inbuf.Find(FSxSTR("**"));
if (era != -1)
{
tyybinr = 1; /* lihtsalt et poleks 0; vaja tee_rida() jaoks */
k = inbuf.Find(FSWSTR("!\\"));
if ( k == -1) /* polegi indeksit; ei saa olla... */
sliik = FSWSTR("V");
else
{
sliik = (const FSWCHAR *)inbuf.Mid(k+2);
k = sliik.Find(FSWSTR("\\"));
if ( k == -1)
{
printf("\nsonaliik sassis ");
return EXIT_FAILURE;
}
sliik = (const FSWCHAR *)sliik.Left(k);
}
k = verbera( &inbuf );
if (!k) /* oli mingi viga */
{
unknown++;
nullityv(); /* et saaks järgmist parad. teha */
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
converted++;
lisa_lgr( &lgrf ); /* leiab igale selle parad tyvele lgr nr */
tee_rida(&inbuf, &outbuf); /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
return EXIT_FAILURE;
}
nullityv(); /* et saaks järgmist parad. teha */
continue; /* vt järgmist kirjet */
}
kk = inbuf.Find(FSxSTR("&&"));
inbuf_para_ind = FSxSTR("");
if (kk != -1)
inbuf_para_ind = (const FSxCHAR *)inbuf.Mid(kk);
inbuf = (const FSxCHAR *)inbuf.Left(inbuf.GetLength()-inbuf_para_ind.GetLength());
k = era_ind( &inbuf );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = era_tyvi( &inbuf );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = vteepar( );
if (!k) /* oli mingi viga */
{
unknown++;
nullityv(); /* et saaks järgmist parad. teha */
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
if ( kk != -1 ) /* leidub parall. indeks */
{
inbuf_para_ind = (const FSxCHAR *)inbuf_para_ind.Mid(2);
k = era_ind( &inbuf_para_ind );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = vparpar( );
if (!k) /* oli mingi viga */
{
unknown++;
nullityv(); /* et saaks järgmist parad. teha */
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
}
converted++;
lisa_lgr( &lgrf ); /* leiab igale selle parad tyvele lgr nr */
tee_rida(&inbuf, &outbuf); /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
return EXIT_FAILURE;
}
nullityv(); /* et saaks järgmist parad. teha */
/*STAT:*/ /* tooseisu v@ljastamine ekraanile */
if ( total % 100 == 0 )
printf( "\r KOKKU: %6d KORRAS: %6d SEGASEID: %6d ",
total, converted, unknown );
}
/* FILE_END:*/
printf( "\r KOKKU: %6d KORRAS: %6d SEGASEID: %6d ",
total, converted, unknown );
Wprintf( FSTSTR("** VRB: %s\n"), (const FSTCHAR*)fn_0);
infile.Close();
outf.Close();
errf.Close();
lgrf.Close();
return EXIT_SUCCESS;
}
/*
* uus variant; hjk 02.05.01
* return mitu sobivat sõnaliiki oli, s.t. mitu 1-e on massiivis sobivad
* nt haige puhul võib olla sl=SA, sobivad=11
* kasutatakse m.h. selleks, et filtreerida välja liitsõna/tuletise komponendiks mittesobivaid tüvesid,
* nt. kääri SV puhul sobivad=10 või 01, sõltuvalt muude komponentide poolt esitatavatest nõuetest
* (kääri_terad või kääri=mine)
*/
int MORF0::ssobivus(
TYVE_INF *grupid, // sisend; lõpugrupid
const FSxCHAR *sl, // sisend; lõpugrupi sõnaliigid (stringina))
const int sl_pik, // sisend; massiivi sl pikkus
const char lopunr, // sisend; lubatav lõpp (õigemini jrk nr lõppude loendis)
const FSxCHAR *sonalk, // sisend; lubatavad sõnaliigid (stringina))
const int vorminr, // sisend; lubatav vorm (õigemini jrk nr vormide loendis)
char *sobivad, // väljund; 0 ja 1 joru
const int sobivatePikkus // sisend; massiivi 'sobivad' pikkus
)
{
if(sobivatePikkus<sl_pik)
throw VEAD(ERR_MORFI_MOOTOR,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 855 $");
register int i;
int j=0;
int k=0, llnr, ffnr, ok;
unsigned l;
FSxCHAR s;
FSXSTRING csonalk;
//FSXSTRING slsonalk;
csonalk = sonalk;
//slsonalk = sl;
memset(sobivad, 0, sobivatePikkus);
for (i=0; i < sl_pik; i++)
{
if ( csonalk != SUVA_LIIK )
{ /* kontr. sonaliigi sobivust */
s = sl[i];
if (csonalk.Find(s)==-1)
continue; // lopugrupp ei esinda sellist sonaliiki
}
if ((signed char)lopunr != SUVA_LP)
{ /* kontr. lopu olemasolu */
k = endingr( GetLgNr(grupid, i), lopunr );
if (k == -1) /* seda loppu pole selles lopugrupis */
continue; /* vt teisi lopugruppe */
}
if (vorminr == SUVA_VRM)
ok = 1;
else
{
ok = 0;
if ((signed char)lopunr != SUVA_LP)
{
llnr = KaksYheks(groups[GetLgNr(grupid, i)].gr_algus, groups[GetLgNr(grupid, i)].gr_lopp);
llnr = homo_form * (llnr + k);
for (l=0; l < homo_form; l++) /*vt lopu vormihomonyyme*/
{
ffnr = (unsigned char)(fgr[llnr + l]); /* vormi nr */
if (!ffnr)
break;
if (vorminr == ffnr)
{
ok = 1;
break;
}
}
}
}
if (!ok)
continue;
// HJK 5.05.2003; HJK 02.03.2005
if (mrfFlags.Chk(MF_EILUBATABU)) // nt soovitaja puhul tabus�nad pole lubatud
{
if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, TABU_SL))
continue;
}
/* hjk 04.2015: las need mitmesõnaliste nimede osad olla alati lubatud
if (!mrfFlags.Chk(MF_SPELL)) // aint spelleri puhul on m�ned s�nad lubatud, nt. Aires
{
if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, SPELL_SL))
continue;
}
*/
if (!mrfFlags.Chk(MF_LUBATESA)) // normaalse morfi puhul tesauruse algvormide staatuses s�navormid (aukudega) pole lubatud
{
if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, TESA_SL))
continue;
}
if(i>sobivatePikkus)
throw VEAD(ERR_MORFI_MOOTOR,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 855 $");
sobivad[i] = 1;
j++;
}
return(j);
}
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;
}
bool ETMRFAS::SyntDetailne(
MRFTULEMUSED &valja,
const FSXSTRING *pGeneSona,
const FSXSTRING *pnaidis,
const FSXSTRING *pGeneLiik,
const FSXSTRING *pGeneVormid,
const FSXSTRING *pGeneKigi)
{
assert(&valja!=NULL && pGeneSona!=NULL && pnaidis!=NULL && pGeneVormid!=NULL && pGeneKigi!=NULL);
//MRFTULEMUSED *mrfTul;
int n;
valja.Stop();
valja.Start(5,5);
valja.s6na = *pGeneSona;
if (pnaidis->GetLength() > 0)
{
valja.s6na += FSxSTR(" (");
valja.s6na += *pnaidis;
valja.s6na += FSxSTR(")");
}
valja.s6na += FSxSTR(" //_");
valja.s6na += *pGeneLiik;
valja.s6na += FSxSTR("_ ");
valja.s6na += *pGeneVormid;
valja.s6na += FSxSTR(" // ");
valja.s6na += *pGeneKigi;
adHocString=FSxSTR("");
valja.eKustTulemused = eMRF_XX; // see peaks tegelt olema pValja tekitamise kohas... HJK aprill 2005
// Ei. See ütleb, et vaikimisi me ei tea kust analüüs pärit.
// Seal, kus me tulemuse saime, asendame selle
// konstandiga, kust tulemus tegelikult tuli.
// Nii et päeva lõpuks peaks olema eMRF_XX asemel
// midagi muud. Aga igaks juhuks initsialiseerime
// ta selliselt.
MRF_FLAGS_BASE_TYPE geneLipud = mrfFlags->Get();
FSXSTRING mrfAnal;
// vaja morfida, kusjuures liiga pikad oleksid valed ja lühendeid üldse ei oleta
mrfFlags->On(MF_MRF|MF_PIKADVALED|MF_LYHREZH);
mrfFlags->Off(MF_KR6NKSA);
// tsükeldame üle tyhikuga eraldet sonade
// (ei tea kas seda tegelikult kunagi juhtub ka?)
int vasak=0, parem=0;
FSXSTRING GeneSona1, tmp;
n = 0;
tmp = *pGeneSona;
tmp.Trim();
for (; tmp.GetLength() > 0; tmp = tmp.Mid(vasak))
{
parem = tmp.Find((FSxCHAR)' ');
if (parem == -1)
parem = tmp.GetLength(); // viimase lõpus polnud tyhikut
GeneSona1=tmp.Left(parem);
GeneSona1.Trim(); // igaks juhuks, kes kurat teab
vasak=parem+1;
ETMRFA::Set1(GeneSona1); // morfi magasini
n++;
}
LYLI morfistLyli;
if(ETMRFA::Flush(morfistLyli)==false) // morfi magasinist
{
ETMRFA::Clr();
mrfFlags->Set(geneLipud); // taastame endised lipud
return false;
}
assert( morfistLyli.lipp & PRMS_MRF );
// mrfTul=morfistLyli.ptr.pMrfAnal;
if(morfistLyli.ptr.pMrfAnal->on_tulem()) // õnnestus analüüsida
{
if(morfistLyli.ptr.pMrfAnal->mitmeS6naline != n)
{
// pole õige mitmesõnaline
//delete pLyli;
ETMRFA::Clr();
mrfFlags->Set(geneLipud); // taastame endised lipud
return false;
}
}
if (a.idxLast != 0)
{
// nt. taheti geneda mitmesõnalist, aga seda ei õnnestunud analüüsida
//delete pLyli;
ETMRFA::Clr();
mrfFlags->Set(geneLipud); // taastame endised lipud
return false;
}
mrfFlags->Set(geneLipud); // taastame endised lipud
if(morfistLyli.ptr.pMrfAnal->on_tulem()) // õnnestus analüüda
{
bool rs;
//mrfTul=morfistLyli.ptr.pMrfAnal;
FSXSTRING gv = *pGeneVormid;
gv.Trim();
if(gv==FSWSTR("*,"))
{
gv= FSWSTR("adt, b, d, da, des, ge, gem, gu, ")
FSWSTR("ks, ksid, ksime, ksin, ksite, ")
FSWSTR("ma, maks, mas, mast, mata, me, ")
FSWSTR("n, neg, neg ge, neg gem, neg gu, neg ks, neg nud, neg nuks, neg o, neg vat, ")
FSWSTR("nud, nuks, nuksid, nuksime, nuksin, nuksite, nuvat, ")
FSWSTR("o, pl ab, pl abl, pl ad, pl all, pl el, pl es, ")
FSWSTR("pl g, pl ill, pl in, pl kom, pl n, pl p, pl ter, pl tr, ")
FSWSTR("s, sg ab, sg abl, sg ad, sg all, sg el, sg es, sg g, sg ill, sg in, sg kom, ")
FSWSTR("sg n, sg p, sg ter, sg tr, ")
FSWSTR("sid, sime, sin, site, ")
FSWSTR("ta, tagu, taks, takse, tama, tav, tavat, te, ti, tud, tuks, tuvat, v, vad, vat,");
}
rs = Gene2Detailne(&valja, morfistLyli.ptr.pMrfAnal, pnaidis, pGeneLiik, &gv, pGeneKigi);
if (rs == false)
return false;
if (valja.idxLast > 0) // õnnestus sünteesida
return true;
// ei suutnud sünteesida ...
if (morfistLyli.ptr.pMrfAnal->eKustTulemused == eMRF_AP) // tulemus põhisõnastikust
{ // ilmselt oli sisendsõna mingi tuntud sõna mitte-algvorm
if (morfistLyli.ptr.pMrfAnal->s6na.Right(3) == FSxSTR("nud") ||
morfistLyli.ptr.pMrfAnal->s6na.Right(3) == FSxSTR("tud") ||
morfistLyli.ptr.pMrfAnal->s6na.Right(3) == FSxSTR("dud"))
return ArvaGene2(&valja, morfistLyli.ptr.pMrfAnal, pGeneLiik, &gv, pGeneKigi);
else
return false;
}
// analüüs oletatud või abisõnastikust
if (mrfFlags->Chk(MF_OLETA))
{
// oli nt blabla-sõna, s.t. et lõpus on tavaline tuntud sõna
// või oli blablalik, s.t. lõpus on regulaarne sufiks
return ArvaGene2(&valja, morfistLyli.ptr.pMrfAnal, pGeneLiik, &gv, pGeneKigi);
}
}
// tundmatu sõna
return false;
}
FSXSTRING *OLETAJA_DCT::konstrui_tyvi(FSXSTRING *tyvi, FSXSTRING *vorm, const FSxOTAB *t)
{
int k;
FSXSTRING tmp1;
tmp1 = t->vorm;
if (tmp1 != *vorm)
return (NULL); // otsitav vorm ei sobi
if (!TaheHulgad::OnLopus(tyvi, t->u_tylp))
return (NULL); // algvormile lisatav t�vel�pp ei sobi
a_tyvi = *tyvi;
a_tyvi = a_tyvi.Left(a_tyvi.GetLength() - FSxSTRLEN(t->u_tylp));
tmp1 = t->a_tylp;
tmp1 = tmp1.Right(t->n);
a_tyvi += tmp1; // algvormi t�vi valmis
if (!TaheHulgad::OnLopus(&a_tyvi,t->a_tylp))
return (NULL); // algvormile lisatav t�vel�pp ei sobi
if (a_tyvi.GetLength() < 3)
return (NULL); // liiga l�hike
// kas algv tyvele h��likuklassid sobivad?
k = FSxSTRLEN(t->meta);
if (k)
{
FSXSTRING tmp;
int i;
tmp = a_tyvi.Left(a_tyvi.GetLength() - FSxSTRLEN(t->a_tylp));
tmp = tmp.Right(k);
if (tmp.GetLength() != k) // string liiga l�hike vms jama
return (NULL);
tmp.MakeLower();
for (i=0; i < k; i++)
{
if ((t->meta[i] == (FSxCHAR)'V' && TaheHulgad::OnTaishaalik(tmp[i])) || tmp[i] == (FSxCHAR)'y')
continue;
if (t->meta[i] == (FSxCHAR)'L' && TaheHulgad::OnLmnr(tmp[i]))
continue;
if (t->meta[i] == (FSxCHAR)'P' && TaheHulgad::OnKpt(tmp[i]))
continue;
if (t->meta[i] == (FSxCHAR)'D' && TaheHulgad::OnKaashaalik(tmp[i]) && (tmp[i]) != (FSxCHAR)'s')
continue;
if (t->meta[i] == (FSxCHAR)'C' && TaheHulgad::OnKaashaalik(tmp[i]))
continue;
if (t->meta[i] == (FSxCHAR)'B' && TaheHulgad::OnKaashaalik(tmp[i]) && !TaheHulgad::OnKpt(tmp[i]))
continue;
return NULL;
}
}
// silbita a_tyvi
SILP s;
s.silbita(&a_tyvi);
if (s.silpe() == 0) // liiga l�hike t�vi vm jama
return (NULL);
s.silbivalted();
k = s.silpe() - s.viimane_rohuline_silp();
ASSERT(k > 0);
// kas a_tyvi silbid sobivad?
if (k < t->min_silpe || k > t->max_silpe)
return (NULL); // vale silpide arv
if (FSxSTRCMP(t->sonaliik, LIIK_VERB)==0)
{
if (TaheHulgad::OnLopus(&a_tyvi, FSxSTR("ne")) && s.silpe() > 3)
return (NULL);
}
// teatud juhtudel v�lte arvestamine
if (!FSxSTRCMP(t->tyypsona, FSxSTR("ragin")))
{ // sobivad ainult 2-silbilised 1. v�ltes s�nad
if (s.silpe() == 2 && k == 2 && s.silbid[0]->valde == 1)
; // OK
else
return (NULL);
}
// et v�ltida asju nagu ��vli -> ��vl
if (k == 1 && TaheHulgad::OnLopus(&a_tyvi, FSxSTR("l")) &&
!TaheHulgad::OnLopus(&a_tyvi, FSxSTR("ll")) &&
!TaheHulgad::OnLopus(&a_tyvi, FSxSTR("rl")) &&
!TaheHulgad::OnLopus(&a_tyvi, FSxSTR("hl")))
{
if (s.silbid[s.viimane_rohuline_silp()]->valde == 3 &&
TaheHulgad::OnKaashaalik(a_tyvi[a_tyvi.GetLength()-2]))
return (NULL);
}
// itaalia nimed
if (TaheHulgad::OnLopus(&a_tyvi, FSxSTR("cc")) && TaheHulgad::OnLopus(tyvi, FSxSTR("cci")))
return (NULL);
return (&a_tyvi);
}
bool ETMRFAS::Gene2Detailne( // -1==siiber; 0==ok
MRFTULEMUSED *pValja,
MRFTULEMUSED *pMrfTul,
const FSXSTRING *pnaidis,
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, k1, k2;
bool r;
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("");
for (i=0; i < pMrfTul->idxLast; i++)
{
if (gene_liik.Find((*pMrfTul)[i]->sl) == -1)
continue; // polnud sobiv sõnaliik
if ((*pMrfTul)[i]->vormid.Find(FSxSTR("?")) != -1 || (*pMrfTul)[i]->vormid.Find(FSxSTR(",")) == -1) // muutumatu s�na
{
if (sgn == 0 || // analüüside 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 //_*_ // et //_*_ // 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)
{
algv_lopp = lopp_d;
algv_vorm = pl_n;
// HJK 2008: igaks juhuks (kui eelnenud analüüsil on tehtud tyve asemel lemma)
if ( (*pMrfTul)[i]->tyvi.Right(1) == FSxSTR("d") ) // nt Madalmaad; votad lopust maha
(*pMrfTul)[i]->tyvi = (*pMrfTul)[i]->tyvi.Left((*pMrfTul)[i]->tyvi.GetLength()-1);
}
else if (!sgn &&
// null-lopp !!!
(*pMrfTul)[i]->sl == LIIK_VERB &&
((*pMrfTul)[i]->tyvi == FSxSTR("ei") ||
(*pMrfTul)[i]->tyvi == FSxSTR("\x00E4ra"))) // ei, ära puhuks
{
algv_lopp = null_lopp;
FSXSTRING tmpstr;
tmpstr = (*pMrfTul)[i]->vormid;
if (TaheHulgad::OnLopus(&tmpstr, FSxSTR(", ")))
tmpstr = tmpstr.Left(tmpstr.GetLength()-2);
algv_vorm = vormnr((const FSxCHAR *)tmpstr);
}
else
{
continue; // seda rohkem ei vt, sest pole algvorm
}
gene_t1 = (*pMrfTul)[i]->tyvi;
// algul geneme terveid sõnu (lootes, et ka liitsõnad on sõnastikus sees)
gene_t2 = gene_t1;
gene_t2.Remove((FSxCHAR)'_');
gene_t2.Remove((FSxCHAR)'+');
gene_t2.Remove((FSxCHAR)'=');
ette = FSxSTR("");
viimne = pValja->idxLast;
r = GeneMTVDetailne(pValja, &ette, &gene_t2, pnaidis, &gene_liik, pGeneVormid, algv_lopp, algv_vorm, pGeneKigi );
if (r == false)
return false;
if (pValja->idxLast > viimne) // midagi leitigi
{
pValja->eKustTulemused = eMRF_SP; // tulemused põhisõnastikust
continue;
}
k1 = gene_t1.ReverseFind((FSxCHAR)'_')+1;
k2 = gene_t1.ReverseFind((FSxCHAR)'=')+1;
if (k1==k2) // pole ei _ ega =, seega oli lihtsõna
continue;
if (k2 < k1) // viimane komponent oli osasõna
{
if (mrfFlags->Chk(MF_EITULETALIIT)) // tuleb arvestada tervet sõna, koos _
continue; // ... aga see ei õnnestunud
}
//------
else // viimane komponent oli järelliide
{
gene_t2 = gene_t1.Mid(k2);
ette = gene_t1.Mid(0, k2);
ette.Remove((FSxCHAR)'_');
ette.Remove((FSxCHAR)'=');
ette.Remove((FSxCHAR)'+');
r = GeneSTV(pValja, &ette, &gene_t2, /*&((*pMrfTul)[i]->sl),*/ &gene_liik, pGeneVormid, algv_lopp, algv_vorm, pGeneKigi );
if (r == false)
return false;
if (pValja->idxLast > viimne) // midagi leitigi
continue;
}
// viimane komponent oli osasõna
for (k1=gene_t1.Find((FSxCHAR)'_'); k1!=-1; k1=gene_t1.Find((FSxCHAR)'_', k1+1)) // võta järjest eestpoolt osi ära, kuni midagi järel pole
{
k1 += 1;
gene_t2 = gene_t1.Mid(k1);
ette = gene_t1.Mid(0, k1);
ette.Remove((FSxCHAR)'_');
ette.Remove((FSxCHAR)'=');
ette.Remove((FSxCHAR)'+');
gene_t2.Remove((FSxCHAR)'_');
gene_t2.Remove((FSxCHAR)'=');
gene_t2.Remove((FSxCHAR)'+');
r = GeneMTVDetailne(pValja, &ette, &gene_t2, pnaidis, &gene_liik, pGeneVormid, algv_lopp, algv_vorm, pGeneKigi );
if (r == false)
return false;
if (pValja->idxLast > viimne) // midagi leitigi
{
pValja->eKustTulemused = eMRF_SP; // tulemused põhisõnastikust
break;
}
}
}
pValja->SortUniq();
return true;
}
const FSxCHAR *OLETAJA_DCT::leia_analoog(FSXSTRING *tyvi, FSXSTRING *sonaliik, const FSxGOTAB *t)
{
int k;
FSXSTRING tylp;
FSXSTRING tmp1;
// kas s�naliik on �ige?
if (t->sonaliik != *sonaliik)
return (NULL);
// kas algv tyvele h��likuklassid sobivad?
k = FSxSTRLEN(t->meta);
if (k)
{
FSXSTRING tmp;
int i;
tmp = tyvi->Left(tyvi->GetLength() - FSxSTRLEN(t->a_tylp));
tmp = tmp.Right(k);
if (tmp.GetLength() != k) // string liiga l�hike vms jama
return (NULL);
tmp.MakeLower();
for (i=0; i < k; i++)
{
if ((t->meta[i] == (FSxCHAR)'V' && TaheHulgad::OnTaishaalik(tmp[i])) || tmp[i] == (FSxCHAR)'y')
continue;
if (t->meta[i] == (FSxCHAR)'L' && TaheHulgad::OnLmnr(tmp[i]))
continue;
if (t->meta[i] == (FSxCHAR)'P' && TaheHulgad::OnKpt(tmp[i]))
continue;
if (t->meta[i] == (FSxCHAR)'D' && TaheHulgad::OnKaashaalik(tmp[i]) && (tmp[i]) != (FSxCHAR)'s')
continue;
if (t->meta[i] == (FSxCHAR)'C' && TaheHulgad::OnKaashaalik(tmp[i]))
continue;
if (t->meta[i] == (FSxCHAR)'B' && TaheHulgad::OnKaashaalik(tmp[i]) && !TaheHulgad::OnKpt(tmp[i]))
continue;
return NULL;
}
}
// silbita tyvi
SILP s;
s.silbita(tyvi);
if (s.silpe() == 0) // liiga l�hike t�vi vm jama
return (NULL);
s.silbivalted();
k = s.silpe() - s.viimane_rohuline_silp();
ASSERT(k > 0);
// kas a_tyvi silbid sobivad?
if (k < t->min_silpe || k > t->max_silpe)
return (NULL); // vale silpide arv
if (FSxSTRCMP(t->sonaliik, LIIK_VERB)==0)
{
if (TaheHulgad::OnLopus(tyvi, FSxSTR("ne")) && s.silpe() > 3)
return (NULL);
}
if (FSxSTRCMP(t->sonaliik, LIIK_VERB)==0)
if (*sonaliik != LIIK_VERB)
return(NULL);
// teatud juhtudel v�lte arvestamine
if (!FSxSTRCMP(t->tyypsona, FSxSTR("ragin")))
{ // sobivad ainult 2-silbilised 1. v�ltes s�nad
if (s.silpe() == 2 && k == 2 && s.silbid[0]->valde == 1)
; // OK
else
return (NULL);
}
return (t->tyypsona);
}
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;
}
int Tmain(int argc, FSTCHAR **argv)
{
CPFSFile infile; /* viit sisendfailile */
CPFSFile outf, errf; /* viidad v@ljundfailidele */
CPFSFile lgrf; /* viit lõpugruppide failile LGR*/
FSXSTRING inbuf; /* toodeldav rida */
FSXSTRING outbuf; /* toodeldav rida */
CFSFileName fn0=argv[1];
CFSFileName fn1=argv[2];
CFSFileName fn2=argv[3];
CFSFileName fn3=FSTSTR("lgr");
int total, converted, unknown;
int k;
int kk, era, k2, k3;
FSXSTRING inbuf_era, inbuf_para_ind;
converted = unknown = 0;
if (argc != 4)
{
printf("kirjuta paras arv parameetreid või keri poti laadale\n");
return EXIT_FAILURE;
}
if (infile.Open( fn0, FSTSTR("rb" )) == false ||
outf.Open( fn1, FSTSTR("wb" )) == false ||
errf.Open( fn2, FSTSTR("wb" )) == false ||
lgrf.Open( fn3, FSTSTR("ab+")) == false)
{
printf( "Can't open files\n" ); // fopen
exit( 1 );
}
loe_lgr( &lgrf ); /* loe lõpugrupid mällu */
tyvi[0].tyv = FSxSTR("");
for (total=0; infile.ReadLine(&inbuf)==true; total++)
{
kk = inbuf.Find(FSxSTR(".0!"));
if (kk!=-1) /* on 0-muuttyybi sõna */
{
tyybinr = 1; /* lihtsalt et poleks 0 */
k2 = inbuf.Find(FSxSTR("!\\"));
if (k2!=-1)
{
FSXSTRING tmp;
tmp = (const FSxCHAR *)inbuf.Mid(k2+2);
k3 = tmp.Find(FSxSTR("\\"));
if (k3!=-1)
{
sliik = (const FSxCHAR *)tmp.Left(k3);
}
}
if (k2==-1 || k3==-1)
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = nomnul( &inbuf );
if (!k)
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
converted++;
lisa_lgr( &lgrf ); /* leiab igale selle parad tyvele lgr nr */
tee_rida(&inbuf, &outbuf); /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
return EXIT_FAILURE;
}
nullityv(); /* et saaks järgmist parad. teha */
continue; /* et ei vaataks nii, nagu 'norm' ridu */
}
era = inbuf.Find(FSxSTR("**"));
inbuf_era = FSxSTR("");
if (era != -1)
inbuf_era = (const FSxCHAR *)inbuf.Mid(era-1);
inbuf = (const FSxCHAR *)inbuf.Left(inbuf.GetLength()-inbuf_era.GetLength());
kk = inbuf.Find(FSxSTR("&&"));
inbuf_para_ind = FSxSTR("");
if (kk != -1)
inbuf_para_ind = (const FSxCHAR *)inbuf.Mid(kk);
inbuf = (const FSxCHAR *)inbuf.Left(inbuf.GetLength()-inbuf_para_ind.GetLength());
k = era_ind( &inbuf );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = era_reegel( &inbuf );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = era_tyvi( &inbuf );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = tee_para( );
if (!k) /* oli mingi viga */
{
unknown++;
nullityv(); /* et saaks järgmist parad. teha */
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
if ( kk != -1 ) /* leidub parall. indeks */
{
inbuf_para_ind = (const FSxCHAR *)inbuf_para_ind.Mid(2);
if (inbuf_para_ind.Find(FSxSTR("."))==-1)
{ /* => on uus sonaliik; => salvest. senine*/
lisa_lgr( &lgrf ); /*leiab igale selle parad tyvele lgr nr */
tee_rida(&inbuf, &outbuf); /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
return EXIT_FAILURE;
}
nullityv(); /* et saaks järgmist parad. teha */
era_tyvi( &inbuf ); /* nullityv() oli ka tyved kaotand */
}
k = era_ind(&inbuf_para_ind);
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
k = era_reegel( &inbuf_para_ind );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
if (inbuf_para_ind.Find(FSxSTR("(")) == 0)
{
for (k=0; tyvi[k].tyv.GetLength() > 0; k++)
tyvi[k].sulg = 1;
}
k = par_para( );
if (!k) /* oli mingi viga */
{
unknown++;
nullityv(); /* et saaks järgmist parad. teha */
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
}
if ( era != -1 ) /* leidub ka erandeid */
{
inbuf_era = (const FSxCHAR *)inbuf_era.Mid(3);
k = nomerand( &inbuf_era );
if (!k) /* oli mingi viga */
{
unknown++;
if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. error-faili ebaõnnestus");
return EXIT_FAILURE;
}
continue; /* vt järgmisi ridu */
}
}
converted++;
lisa_lgr( &lgrf ); /* leiab igale selle parad tyvele lgr nr */
tee_rida(&inbuf, &outbuf); /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
{
printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
return EXIT_FAILURE;
}
nullityv(); /* et saaks järgmist parad. teha */
/*STAT:*/ /* tooseisu v@ljastamine ekraanile */
if ( total % 100 == 0 )
printf( "\r KOKKU: %6d KORRAS: %6d SEGASEID: %6d ",
total, converted, unknown );
}
/*FILE_END:*/
printf( "\r KOKKU: %6d KORRAS: %6d SEGASEID: %6d ",
total, converted, unknown );
Tprintf( FSTSTR("** NOM: %s\n"), (const FSTCHAR*)fn0 );
infile.Close();
outf.Close();
errf.Close();
lgrf.Close();
return EXIT_SUCCESS;
}