/*
* 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);
}
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;
}
bool ETMRFAS::GeneSTV(
MRFTULEMUSED *pValja,
const FSXSTRING *gPrf, // käib tüve ette
const FSXSTRING *gSuffiks, // suffiks morf analüüsija väljundist
//const FSXSTRING *gSufSl, // suffiksi son liik morf anal väljundist
const FSXSTRING *sl, // sõnaliigid, millesse kuuluvaid sonu tahetakse
const FSXSTRING *geneVormid, // genetavate vormide loend
const int algv_lopp, // 0, -ma voi -d
const int algv_vorm, // sg_g[0], sg_n[0], ma voi pl_n[0]
const FSXSTRING *pGeneKigi)
{
FSUNUSED(sl);
int sufNr; // sufiksi nr sufiksite tabelis
int i, j;
FSXSTRING tmpSuf, tmpSuf1, tmpSuf2;
FSXSTRING *sonaLiigid;
FSxCHAR sl1;
//FSXSTRING *sssl;
int nSonaLiiki;
FSXSTRING gTyviUus;
//FSXSTRING gene_t2;
FSXSTRING styvi;
FSXSTRING skronksutyvi;
int adhocnu = 0; // ad hoc nud, tud, dud jaoks
if (gSuffiks->GetLength() >= SUFLEN)
return true; //* ei saa olla sufiks *
tmpSuf = (const FSxCHAR *)*gSuffiks;
//* otsime välja sufiksi indeksi sufiksite tabelist *
sufNr=suffnr((const FSxCHAR *)tmpSuf);
if (sufNr == -1)
{
//* sellist sufiksit pole olemas, *
//* see juhtub nt siis, kui suf loendis on pikem sufiks, *
//* aga lingv ilu pa'rast na'idat. teda lu'hemana *
//* nt =umuslik asemel =muslik *
//* mingi kombineerimine *
int mitu_maha = gPrf->GetLength();
if (mitu_maha > 3)
mitu_maha = 3;
tmpSuf1 = gPrf->Right(mitu_maha);
tmpSuf1 += (const FSxCHAR *)*gSuffiks;
for (i=0; i < mitu_maha; i++)
{
tmpSuf = tmpSuf1.Mid(i);
if ((sufNr=suffnr((const FSxCHAR *)tmpSuf)) > -1)
break; //* suffiks käes *
}
if (i == mitu_maha) // tavaliselt seda ei saa olla, et ei leia sobivat suffiksit
{
if(*gSuffiks == FSxSTR("nud") || *gSuffiks == FSxSTR("tud") || *gSuffiks == FSxSTR("dud"))
{ // ... aga vahel ikka saab: leksikonis on ainult S nu, tu ja du, mitte A nud, tud ja dud...
tmpSuf = gSuffiks->Left(2);
sufNr=suffnr((const FSxCHAR *)tmpSuf);
adhocnu = 1; // lipp püsti
}
else
return true;
}
tmpSuf1 = tmpSuf.Mid((int)(sufix[sufNr].mitutht));
}
else
tmpSuf1 = tmpSuf;
sonaLiigid = sonaliik[(unsigned char) sufix[sufNr].ssl];
nSonaLiiki = sonaLiigid->GetLength();
for(i=0; i < nSonaLiiki; i++) // vt sufiksi homonüüme (s.h. lik ja l<ik on homonüümid)
{
sl1 = (*sonaLiigid)[i];
if ( sl->Find(sl1) == -1) // see sõnaliik pole siin lubatud
if (adhocnu == 1); // ... aga teatud juhtudel ikkagi võiks
else if (sl->Find((FSxCHAR)'A') != -1 && // tahetakse A, aga sufiks on leksikonis S
(tmpSuf1 == FSxSTR("tu") ||
tmpSuf1.Right(2) == FSxSTR("ke") ||
tmpSuf1.Right(4) == FSxSTR("kene"))); // ... aga teatud juhtudel ikkagi võiks
else
continue;
// vaja kontrollida, kas on ikka vajaliku algvormi tüvi
gTyviUus = tmpSuf1;
if(OtsiTyvi(&(sufix[sufNr].suftyinf[i].idx),
algv_lopp, algv_vorm, &gTyviUus)==false)
continue; //polnud sobiv tüvi
if(gTyviUus != tmpSuf1) // pole õige algvormi tüvi
continue;
if(sl1==W_SL) // nagunii on ka S liigiline sõna leitud
continue;
if(sl1==(FSxCHAR)'B' && sl->Find((FSxCHAR)'A') >=0)
sl1 = 'A'; // kah õige sõnaliik: tahad A-d saad B, aga ütleme, et said A
MKT1c *rec1; // siia pannakse gTyvi (nt piksel) lgNr ja tyMuut
MKTc *rec; // {lgNr, tyMuut} massiiv, mis on seotud ühe sõnaga; nt tyvedele piksel, piksli, piksle
int muutumatu; // muutumatu tüveosa (nt piks)
tmpSuf2 = tmpSuf1;
if((rec1=tyveMuutused.Get(sufix[sufNr].suftyinf[i].idx.tab_idx,sufix[sufNr].suftyinf[i].idx.blk_idx))==NULL)
{
return false;
}
// leia muutumatu tüveosa
if((muutumatu=tmpSuf1.GetLength()-rec1->tyMuut.GetLength()) < 0)
{
return false;
}
if((rec=tyveMuutused[sufix[sufNr].suftyinf[i].idx.tab_idx])==NULL)
{
return false;
}
int tmpsufnr, jj, jjnSonaLiiki;
FSXSTRING vormityvi;
FSXSTRING tyvi, utyvi;
for (j=0; j < rec->n; j++) // vt selle sufiksi paradigma kõiki "tüvesid"
{
utyvi = gPrf->Right(sufix[sufNr].mitutht); // tavaliselt "", aga umuslik puhul u
tyvi = tmpSuf1.Left(muutumatu) + rec->mkt1c[j].tyMuut;
utyvi += tyvi;
tmpsufnr=suffnr((const FSxCHAR *)utyvi);
FSXSTRING *jjsonaLiigid = sonaliik[(unsigned char) sufix[tmpsufnr].ssl];
jjnSonaLiiki = jjsonaLiigid->GetLength();
for (jj=0; jj < jjnSonaLiiki; jj++) // vt "tüve" kõiki homonüüme
{
if ((*sonaliik[(unsigned char) sufix[tmpsufnr].ssl])[jj] != sl1)
continue; // pole sama sõnaliik ...
//if (sufix[sufNr].suftyinf[i].idx.tab_idx != sufix[tmpsufnr].suftyinf[jj].idx.tab_idx)
//continue; // pole sama paradigma
// kole asi üksikute juhtumite filtreerimiseks, nt l<ik ja lik eristamiseks
// tundl<ik+0 vs tundlik+el
MKT1c *rec2 = tyveMuutused.Get(sufix[tmpsufnr].suftyinf[jj].idx.tab_idx,sufix[tmpsufnr].suftyinf[jj].idx.blk_idx);
if (rec->mkt1c[j].lgNr != rec2->lgNr)
continue; // homonüümne tüvi (kui hääldust ei arvesta) ja samas paradigmas, aga tegelt sobimatu
LisaKdptr(sufix[tmpsufnr].suftyinf, &vormityvi, &tyvi, jj);
if (adhocnu == 1) // nu -> nud
{
int sgn_koht;
if ((sgn_koht=geneVormid->Find(FSxSTR("sg n"))) != -1)
{
FSXSTRING uustyvi = *gPrf;
uustyvi += tyvi;
uustyvi += FSxSTR("d");
pValja->Add(
(const FSxCHAR *) uustyvi,
FSxSTR(""),
(const FSxCHAR *)*pGeneKigi,
FSxSTR("A"),
FSxSTR("sg n, "));
FSXSTRING uusgeneVormid = geneVormid->Mid(0, sgn_koht);
uusgeneVormid += geneVormid->Mid(sgn_koht+5);
if (GeneL(pValja, gPrf, &vormityvi, (const FSxCHAR) 'A', rec->mkt1c[j].lgNr,
&uusgeneVormid, pGeneKigi)==false)
{
return false;
}
}
else
{
if (GeneL(pValja, gPrf, &vormityvi, (const FSxCHAR) 'A', rec->mkt1c[j].lgNr,
geneVormid, pGeneKigi)==false)
{
return false;
}
}
}
else
{
if(GeneL(pValja, gPrf, &vormityvi, (const FSxCHAR) sl1, rec->mkt1c[j].lgNr,
geneVormid, pGeneKigi)==false)
{
return false;
}
}
}
}
}
return true;
}
bool ETMRFAS::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;
}
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;
}
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::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;
}
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);
}
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);
}
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;
}
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;
}
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;
}