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::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::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 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;
}
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;
}