int main(int argc, char* argv[])
#endif
{
FSUNUSED(argc);
FSUNUSED(argv);
try {
vabamorf::speller spl(FSTSTR("et.dct"));
for (size_t i = 0; words[i]; i++) {
std::wcout << words[i] << L" -- ";
if (spl.spell(words[i])) {
std::wcout << L"OK\n";
} else {
std::wcout << L"Vigane, soovitan:";
std::vector<std::wstring> suggs = spl.suggest(words[i]);
for (size_t j = 0; j < suggs.size(); j++) {
std::wcout << L" " << suggs[j];
}
std::wcout << L"\n";
}
}
} catch (const vabamorf::exception &) {
std::wcerr << L"Viga!\n";
}
return 0;
}
int CFSMutex::Lock(ULONG lTimeout)
{
#if defined (WIN32)
FSUNUSED(lTimeout);
::EnterCriticalSection(&m_hMutex);
#elif defined (UNIX)
FSUNUSED(lTimeout);
pthread_mutex_lock(&m_hMutex);
#elif defined (MAC)
MPEnterCriticalRegion(m_hMutex, (lTimeout == -1 ? kDurationForever : lTimeout));
#endif
return 0;
}
int FSxGOTAB::Compare(
const FSxGOTAB *e2,
const int sortOrder
)
{
FSUNUSED(sortOrder);
int v;
v = FSxSTRCMP( a_tylp, e2->a_tylp);
if (v==0)
v = FSxSTRLEN(e2->meta) - FSxSTRLEN(meta); // pikem meta on eespool
if (v==0)
v = FSxSTRCMP( meta, e2->meta);
if (v==0)
{ // muutumatu silpide arvuga mallid ettepoole
if (min_silpe == max_silpe)
{
if (e2->min_silpe == e2->max_silpe)
v = min_silpe - e2->min_silpe; // kahest muutumatust v�iksem ettepoole
else
v = -1; // e1 ettepoole
}
else if (e2->min_silpe == e2->max_silpe)
v = 1;
else
v = min_silpe - e2->min_silpe;
}
if (v==0)
v = max_silpe - e2->max_silpe;
if (v==0)
v = FSxSTRCMP( tyypsona, e2->tyypsona);
return v;
}
int FSxGOTAB::Compare(
const FSxCHAR *key,
const int sortOrder
)
{
FSUNUSED(sortOrder);
return FSxSTRCMP(a_tylp, key);
}
int CFSThread::SetPriority(int iPriority)
{
if (!m_hThread) {
return -1;
}
#if defined (WINRT)
// Unimplemented
FSUNUSED(iPriority);
#elif defined (WIN32)
::SetThreadPriority(m_hThread, iPriority);
#elif defined (UNIX)
// Unimplemented
FSUNUSED(iPriority);
#elif defined (MAC)
MPSetTaskWeight(m_hThread, iPriority);
#endif
return 0;
}
int CFSThread::Create(void *pData, long lFlags)
{
m_pData=pData;
#if defined (WIN32CE)
m_hThread=CreateThread(NULL, 0, CFSThreadFunc, this, lFlags, &m_lThreadID);
return (m_hThread==0);
#elif defined (WINRT)
// Unimplemented
FSUNUSED(pData);
FSUNUSED(lFlags);
return -1;
#elif defined (WIN32)
m_hThread=(HANDLE)_beginthreadex(NULL, 0, CFSThreadFunc, this, lFlags, &m_lThreadID);
return (m_hThread==0);
#elif defined (UNIX)
FSUNUSED(lFlags);
return pthread_create(&m_hThread, 0, CFSThreadFunc, this);
#elif defined (MAC)
FSUNUSED(lFlags);
return MPCreateTask(CFSThreadFunc, this, 512*1024, m_WaitQueue, 0, 0, 0,&m_hThread);
#endif
}
int cCACHE::CacheOpen(
const int _DBSIZE_,
const int nBlokki // see CACHEi versioon ei kasua seda muutuja, selleks et oleks teistega kompatiibel
)
{
FSUNUSED(nBlokki);
assert( (_DBSIZE_ % 256)==0 ); // peab olema n*256
xptr=NULL;
dbuf=NULL;
DBSIZE=_DBSIZE_;
dbuf = (struct STRUCT_CASH *)(malloc(sizeof(CASH) + DBSIZE)); // see malloc on OK
if(dbuf==NULL)
{
assert( ClassInvariant() );
return 1;
}
dbuf->index = VABA;
dbuf->buffer = (unsigned char *)(dbuf+1); // MIS KURAT SEE VEEL ON?
// ahaa, vt �lal m�lureserveerimist
assert( ClassInvariant() );
return 0;
}
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;
}
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
}
