示例#1
0
/*
 * 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);
     }
示例#2
0
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;
    }
示例#3
0
文件: mrf-gen.cpp 项目: urdvr/estnltk
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;
}
示例#4
0
文件: mrf-gen.cpp 项目: urdvr/estnltk
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;
}
示例#5
0
文件: mrf-gen.cpp 项目: urdvr/estnltk
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;
}
示例#6
0
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;
    }
示例#7
0
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;
    }
示例#8
0
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);
    }
示例#9
0
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);
    }
示例#10
0
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;
}
示例#11
0
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;
    }
示例#12
0
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;
    }