예제 #1
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;
    }
예제 #2
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);
     }
예제 #3
0
/*
* return minimaalne tyvepikkus, mida on m�tet otsida 
*/
int MORF0::minipik(FSXSTRING *ty)
    {
    FSXSTRING ttt;
    int pik=2;

    ttt = (const FSxCHAR *)(ty->Left(3));  
    if ( ttt == FSxSTR("alu") || ttt == FSxSTR("ude") || ttt == FSxSTR("pan") )
	    pik = 4;
    else
        {
        ttt = (const FSxCHAR *)(ttt.Left(2));
        if ( ( (dctLoend[9])[(FSxCHAR *)(const FSxCHAR *)ttt] ) == -1 )
	        pik = 3;
        }
    return(pik);
    }
예제 #4
0
const FSWCHAR* MRF2YH2MRF::Poore( // välja ühestajamärgend
    const FSXSTRING* p_vorm) const
    {
    MRF2YH_LOEND* p_rec;
    FSXSTRING vorm = *p_vorm;
    vorm.TrimRight(FSWSTR(", "));

    if(vorm[0]==(FSWCHAR)0 || vorm[0]==(FSWCHAR)'?')
        {
        return NULL;
        }
    p_rec=poorded.Get((FSWCHAR*)(const FSWCHAR*)vorm);
    if(p_rec!=NULL)
        {
        return p_rec->p_yhTag;
        }
    return NULL;
    }
예제 #5
0
const FSWCHAR* MRF2YH2MRF::Kaane( // välja ühestajamärgend
    const FSXSTRING* p_vorm) const
    {
    MRF2YH_LOEND* p_rec;
    FSXSTRING vorm = *p_vorm;
    vorm.TrimRight(FSWSTR(", "));

    int nihe=0;
    if(TaheHulgad::OnAlguses(&vorm, FSWSTR("sg "))==true ||
                    TaheHulgad::OnAlguses(&vorm, FSWSTR("pl "))==true)
        {
        nihe += 3;
        }
    if(vorm[nihe]==(FSWCHAR)0 || vorm[nihe]==(FSWCHAR)'?')
        {
        return NULL; //TUNDMATU_P_YM
        }
    p_rec=kaanded.Get((FSWCHAR*)(const FSWCHAR*)vorm+nihe); // tabelist mrf2yhKaands
    if(p_rec!=NULL) // igaks juhuks; peaks alati olema tõene
        {
        return p_rec->p_yhTag;
        }
    return NULL; //TUNDMATU_P_YM
    }
예제 #6
0
파일: chknr2.cpp 프로젝트: estnltk/estnltk
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;
    }
예제 #7
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;
    }
예제 #8
0
파일: kchk6.cpp 프로젝트: estnltk/estnltk
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;
    }
예제 #9
0
파일: chkgeon.cpp 프로젝트: estnltk/estnltk
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;
    }
예제 #10
0
void MRF2YH2MRF::FsTags2YmmTags(
	const FSXSTRING* p_sona,
	MRFTUL* p_mTul,
	FSXSTRING& yhmarg1,
	FSXSTRING& yhmarg2,
	FSXSTRING& yhmarg3	
	) const
    {
	FSUNUSED(yhmarg3);
    MRF2YH_LOEND* p_rec;
    const FSWCHAR* p_yTag;

    // punktuatsioon --> ühestajamärgendiks
    if(p_mTul->sl==FSWSTR("Z")) // sõnaliik oli punktuatsioon
        {
        p_rec=punktuatsioon.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
        if(p_rec!= NULL)        // oli meie punktuatsiooni loendis
            {            
            //p_mTul->mrg1st=p_rec->p_yhTag;
			yhmarg1=p_rec->p_yhTag;
            return;
            }
        // p_rec==NULL -- polnud loendis...
		else // vt kas esimene m�rk oli loendis 
			{
			FSXSTRING algustht = p_sona->Left(1);
			p_rec=punktuatsioon.Get((FSWCHAR*)(const FSWCHAR*)algustht);
			if(p_rec!= NULL)        // oli meie punktuatsiooni loendis
				{            
				//p_mTul->mrg1st=p_rec->p_yhTag;
				yhmarg1=p_rec->p_yhTag;
				return;
				}
			}
        // p_rec==NULL -- polnud loendis...
        //p_mTul->mrg1st=FSWSTR("WIE");   //...vaikimisi see
        //p_mTul->mrg1st=FSWSTR("X");   //...vaikimisi see
		yhmarg1=FSWSTR("X");   //...vaikimisi see
        return;
        }
    // sõna --> ühestajamärgendiks

    // if(sonaliik != "H")
    if(p_mTul->sl[0]!=(FSWCHAR)'H')
    {
        p_rec=sona.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
        if(p_rec!= NULL)    // oli meie sõnade loendis
            {
            //p_mTul->mrg1st=p_rec->p_yhTag;
            yhmarg1=p_rec->p_yhTag;
            return;
            }
    }
    // endif

    // sõnaliik + sõna --> ühestajamärgendiks
    // DXIG -> RR RR II ASG t��tlus
    if(muut1.Find(p_mTul->sl[0]) >= 0) // sõnaliik oli 'muut1' loendis
        {
        p_rec=rr.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
        if(p_rec!= NULL)    // 
            {            
            //p_mTul->mrg1st=p_rec->p_yhTag;
			yhmarg1=p_rec->p_yhTag;
            return;
            }
        // p_rec==NULL -- polnud loendis...
		if((p_rec=noomTags.Get((FSWCHAR*)(const FSWCHAR*)(p_mTul->sl)))!=NULL)
			{                              // märgendi 1. pool
			//p_mTul->mrg1st=p_rec->p_yhTag; // tuleneb sõnaliigist
			yhmarg1=p_rec->p_yhTag;
			return;
			}

		//p_mTul->mrg1st=FSWSTR("RR");    //...vaikimisi see VALE!!!!
        // return;
        }
    // sõnaliik + sõnalõpp --> ühestajamärgendiks
    // nud-tud-dud lõpulised V, A -> VMAZ (partitsiip)
    if(verb_v_adj.Find(p_mTul->sl[0]) >= 0) // sõnaliik oli 'verb_v_adj' loendis
        {
        // kas sõna "[ntd]ud" lõpuline
        if(TaheHulgad::OnLopus(p_sona, FSWSTR("nud"))==true ||
           TaheHulgad::OnLopus(p_sona, FSWSTR("tud"))==true ||
           TaheHulgad::OnLopus(p_sona, FSWSTR("dud"))==true )
            {
            //p_mTul->mrg1st=FSWSTR("VMAZ");
			yhmarg1=FSWSTR("VMAZ");
            return; //??
            }
        //return; //??
        }
    // sõnaliik + sõnalõpp --> ühestajamärgendiks
    // nud-tud lõpulised S -> VMAZ (partitsiip)
    //   if(p_mTul->sl[0] == (FSWCHAR)'S') 
    //       {
    //       // kas sõna "[nt]ud" lõpuline
    //      if(TaheHulgad::OnLopus(p_sona, FSWSTR("nud"))==true ||
    //          TaheHulgad::OnLopus(p_sona, FSWSTR("tud"))==true )
    //          {
    //          p_mTul->mrg1st=FSWSTR("VMAZ");
    //          return; //??
    //          }
    //      // return; //??
    //      }
    // yks ja teine -> YKS* ja TEINE*
    if(yks_v_teine_sonaliik.Find(p_mTul->sl[0]) >= 0) // sõnaliik oli 'yks_v_teine_sonaliik' loendis
        {
        //p_rec=yksTeine.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
        p_rec=yksTeine.Get((FSWCHAR*)(const FSWCHAR*)p_mTul->tyvi);
        if(p_rec!= NULL)        // oli  loendis
            {                               // märgendi 1. pool
            //p_mTul->mrg1st=p_rec->p_yhTag;  // tuleneb sõnast
			yhmarg1=p_rec->p_yhTag;
            p_yTag=Kaane(&(p_mTul->vormid));
            if(p_yTag==NULL) // seda ei tohiks olla
                {
                //p_mTul->mrg1st=FSWSTR("PSX"); // TUNDMATU_P_YM
				yhmarg1=FSWSTR("PSX"); // TUNDMATU_P_YM
                return;
                }
            //p_mTul->mrg1st +=p_yTag;        // märgendi 2. pool,
			yhmarg1 += p_yTag;        // märgendi 2. pool,
            return;                         // tuleneb käändevormist
            }
        // p_rec==NULL -- polnud loendis, ei tee midagi
        }
    //  P -> PP1 PP2 PP3 juhtumi tõõtlus
    if(p_mTul->sl[0] == (FSWCHAR)'P')
        {
        //p_rec=ase.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
		p_rec=ase.Get((FSWCHAR*)(const FSWCHAR*)p_mTul->tyvi);
        if(p_rec!= NULL)     
            {                               // märgendi 1. pool
            //p_mTul->mrg1st=p_rec->p_yhTag;  // tuleneb sõnast
            yhmarg1=p_rec->p_yhTag;
			p_yTag=Kaane(&(p_mTul->vormid));
            if(p_yTag==NULL) // seda ei tohiks olla
                {
                //p_mTul->mrg1st=FSWSTR("PSX"); // TUNDMATU_P_YM
				yhmarg1=FSWSTR("PSX"); // TUNDMATU_P_YM
                return;                       
                }                           // märgendi 2. pool,
            //p_mTul->mrg1st +=  p_yTag;      // tuleneb käädevormist
			yhmarg1 +=  p_yTag;      // tuleneb käädevormist
            if(*p_sona == FSWSTR("tema") && yhmarg1==FSWSTR("PP3SG")) // väga kole!!!
                {
                // mõhh???
                //p_mTul->mrg1st=FSWSTR("M");
				//yhmarg1=FSWSTR("PP3SN"); HJK 23.11.2004 prooviks ikka ühestada...
                return;
                }
            return;
            }
        // p_rec==NULL -- polnud loendis, ei tee midagi
        }
    // ACUSHNOPY -> A, A, A, NC, NP, MC, MO, P, Y töötlus
    if((p_rec=noomTags.Get((FSWCHAR*)(const FSWCHAR*)(p_mTul->sl)))!=NULL)
        {                              // märgendi 1. pool
        //p_mTul->mrg1st=p_rec->p_yhTag; // tuleneb sõnaliigist
		yhmarg1=p_rec->p_yhTag; // tuleneb sõnaliigist
        p_yTag=Kaane(&(p_mTul->vormid));
        if(p_yTag==NULL)
            {
            if(p_mTul->sl==FSWSTR("A"))
                {
                //
                MRF2YH_LOEND* p_rec2;
                if((p_rec2=asxrr.Get((FSWCHAR*)(const FSWCHAR*)
                                                (p_mTul->sl)))!=NULL)
                    {
                    //p_mTul->mrg1st=p_rec2->p_yhTag; // ASXRR asemele
					yhmarg1=p_rec2->p_yhTag; // ASXRR asemele
                    return;
                    }
                //p_mTul->mrg1st += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
				yhmarg1 += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
                return;                         // sappa juurde
                }
            if(TaheHulgad::OnLopus(&yhmarg1, FSWSTR("NP"))==true)
                {
                // et ei tekiks NPSX keerame ...NP --> ...NC
                //p_mTul->mrg1st.Delete(p_mTul->mrg1st.GetLength()-1);
                if(p_mTul->mrg1st.GetLength()>0) //TV071109
				    yhmarg1.Delete(p_mTul->mrg1st.GetLength()-1);
                //p_mTul->mrg1st += FSWSTR("C");
				yhmarg1 += FSWSTR("C");
                }
            //p_mTul->mrg1st += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
			yhmarg1 += FSWSTR("SX"); // MUUTUMATU_NOOMENI_TUNNUS
            return;                         // sappa juurde
            }
        //p_mTul->mrg1st += p_yTag; // märgendi 2. pool
		yhmarg1 += p_yTag; // märgendi 2. pool
        return;                   // tulenb käändevormist        
        }
    // J -> CS ja CC töötlus
    if(p_mTul->sl[0] == (FSWCHAR)'J')
        {
        p_rec=sidec.Get((FSWCHAR*)(const FSWCHAR*)*p_sona);
        if(p_rec!= NULL)     
            {                               
            //p_mTul->mrg1st=p_rec->p_yhTag;  
			yhmarg1=p_rec->p_yhTag; 
            return;
            }
        //p_mTul->mrg1st=FSWSTR("CS");
		yhmarg1=FSWSTR("CS");
        return;
        }
    // K -> SP ja ST töötlus
    if(p_mTul->sl[0] == (FSWCHAR)'K')
        {
        // TODO::
        Kaas2Yh(p_sona, yhmarg1, yhmarg2);
        //       if(p_yTag==NULL) // seda ei tohiks olla
        //           {
        //           p_mTul->mrg1st=FSWSTR("ST");
        //           return;
        //           }
        //p_mTul->mrg1st=p_yTag;
        return;
        }
    // V -> VM töötlus
    if(p_mTul->sl[0] == (FSWCHAR)'V')
        {
        //p_mTul->mrg1st=FSWSTR("VM"); // VERBI_YM
		yhmarg1=FSWSTR("VM"); // VERBI_YM
        p_yTag=Poore(&(p_mTul->vormid));
        if(p_yTag==NULL)
            {
            //p_mTul->mrg1st += FSWSTR("S"); // MUUTUMATU_VERBI_TUNNUS
			yhmarg1 += FSWSTR("S"); // MUUTUMATU_VERBI_TUNNUS
            return;
            }
        if(sid_variandid==p_yTag)
            {
            // siin toimub veel midagi segast
            //p_mTul->mrg1st += FSWSTR("3"); // YM_MA_VAHE
			yhmarg2 = yhmarg1;
			yhmarg1 += FSWSTR("2"); // YM_MA_VAHE
			yhmarg2 += FSWSTR("3"); // YM_MA_VAHE
            return;
            }
        //p_mTul->mrg1st += p_yTag;
		yhmarg1 += p_yTag;
        return;
        }
    assert(false);
    //p_mTul->mrg1st=FSWSTR("X"); // TUNDMATU_LOOM
	yhmarg1=FSWSTR("X"); // TUNDMATU_LOOM
    }
예제 #11
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;
}
예제 #12
0
파일: verb.cpp 프로젝트: Filosoft/vabamorf
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;
}
예제 #13
0
/*
* 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);
    }
예제 #14
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;
    }
예제 #15
0
파일: mrf-gen.cpp 프로젝트: urdvr/estnltk
bool ETMRFAS::SyntDetailne(
    MRFTULEMUSED   &valja,
    const FSXSTRING  *pGeneSona,
    const FSXSTRING  *pnaidis,
    const FSXSTRING  *pGeneLiik,
    const FSXSTRING  *pGeneVormid,
    const FSXSTRING  *pGeneKigi)
{
    assert(&valja!=NULL && pGeneSona!=NULL && pnaidis!=NULL && pGeneVormid!=NULL && pGeneKigi!=NULL);
    //MRFTULEMUSED *mrfTul;
    int n;

    valja.Stop();
    valja.Start(5,5);

    valja.s6na  = *pGeneSona;
    if (pnaidis->GetLength() > 0)
    {
        valja.s6na += FSxSTR(" (");
        valja.s6na += *pnaidis;
        valja.s6na += FSxSTR(")");
    }
    valja.s6na += FSxSTR(" //_");
    valja.s6na += *pGeneLiik;
    valja.s6na += FSxSTR("_ ");
    valja.s6na += *pGeneVormid;
    valja.s6na += FSxSTR(" // ");
    valja.s6na += *pGeneKigi;

    adHocString=FSxSTR("");
    valja.eKustTulemused = eMRF_XX; // see peaks tegelt olema pValja tekitamise kohas... HJK aprill 2005
    // Ei. See ütleb, et vaikimisi me ei tea kust analüüs pärit.
    // Seal, kus me tulemuse saime, asendame selle
    // konstandiga, kust tulemus tegelikult tuli.
    // Nii et päeva lõpuks peaks olema eMRF_XX asemel
    // midagi muud. Aga igaks juhuks initsialiseerime
    // ta selliselt.
    MRF_FLAGS_BASE_TYPE geneLipud = mrfFlags->Get();
    FSXSTRING mrfAnal;
    // vaja morfida, kusjuures liiga pikad oleksid valed ja lühendeid üldse ei oleta
    mrfFlags->On(MF_MRF|MF_PIKADVALED|MF_LYHREZH);
    mrfFlags->Off(MF_KR6NKSA);
    // tsükeldame üle tyhikuga eraldet sonade
    // (ei tea kas seda tegelikult kunagi juhtub ka?)
    int vasak=0, parem=0;
    FSXSTRING GeneSona1, tmp;
    n = 0;
    tmp = *pGeneSona;
    tmp.Trim();
    for (; tmp.GetLength() > 0; tmp = tmp.Mid(vasak))
    {
        parem = tmp.Find((FSxCHAR)' ');
        if (parem == -1)
            parem = tmp.GetLength(); // viimase lõpus polnud tyhikut
        GeneSona1=tmp.Left(parem);
        GeneSona1.Trim(); // igaks juhuks, kes kurat teab
        vasak=parem+1;
        ETMRFA::Set1(GeneSona1); // morfi magasini
        n++;
    }
    LYLI morfistLyli;
    if(ETMRFA::Flush(morfistLyli)==false) // morfi magasinist
    {
        ETMRFA::Clr();
        mrfFlags->Set(geneLipud); // taastame endised lipud
        return false;
    }
    assert( morfistLyli.lipp & PRMS_MRF );
    // mrfTul=morfistLyli.ptr.pMrfAnal;
    if(morfistLyli.ptr.pMrfAnal->on_tulem()) // õnnestus analüüsida
    {
        if(morfistLyli.ptr.pMrfAnal->mitmeS6naline != n)
        {
            // pole õige mitmesõnaline
            //delete pLyli;
            ETMRFA::Clr();
            mrfFlags->Set(geneLipud); // taastame endised lipud
            return false;
        }
    }
    if (a.idxLast != 0)
    {
        // nt. taheti geneda mitmesõnalist, aga seda ei õnnestunud analüüsida
        //delete pLyli;
        ETMRFA::Clr();
        mrfFlags->Set(geneLipud); // taastame endised lipud
        return false;
    }
    mrfFlags->Set(geneLipud); // taastame endised lipud
    if(morfistLyli.ptr.pMrfAnal->on_tulem()) // õnnestus analüüda
    {
        bool rs;
        //mrfTul=morfistLyli.ptr.pMrfAnal;
        FSXSTRING gv = *pGeneVormid;
        gv.Trim();
        if(gv==FSWSTR("*,"))
        {
            gv= FSWSTR("adt, b, d, da, des, ge, gem, gu, ")
                FSWSTR("ks, ksid, ksime, ksin, ksite, ")
                FSWSTR("ma, maks, mas, mast, mata, me, ")
                FSWSTR("n, neg, neg ge, neg gem, neg gu, neg ks, neg nud, neg nuks, neg o, neg vat, ")
                FSWSTR("nud, nuks, nuksid, nuksime, nuksin, nuksite, nuvat, ")
                FSWSTR("o, pl ab, pl abl, pl ad, pl all, pl el, pl es, ")
                FSWSTR("pl g, pl ill, pl in, pl kom, pl n, pl p, pl ter, pl tr, ")
                FSWSTR("s, sg ab, sg abl, sg ad, sg all, sg el, sg es, sg g, sg ill, sg in, sg kom, ")
                FSWSTR("sg n, sg p, sg ter, sg tr, ")
                FSWSTR("sid, sime, sin, site, ")
                FSWSTR("ta, tagu, taks, takse, tama, tav, tavat, te, ti, tud, tuks, tuvat, v, vad, vat,");
        }
        rs = Gene2Detailne(&valja, morfistLyli.ptr.pMrfAnal, pnaidis, pGeneLiik, &gv, pGeneKigi);
        if (rs == false)
            return false;
        if (valja.idxLast > 0) // õnnestus sünteesida
            return true;
        // ei suutnud sünteesida ...
        if (morfistLyli.ptr.pMrfAnal->eKustTulemused == eMRF_AP) // tulemus põhisõnastikust
        {   // ilmselt oli sisendsõna mingi tuntud sõna mitte-algvorm
            if (morfistLyli.ptr.pMrfAnal->s6na.Right(3) == FSxSTR("nud") ||
                    morfistLyli.ptr.pMrfAnal->s6na.Right(3) == FSxSTR("tud") ||
                    morfistLyli.ptr.pMrfAnal->s6na.Right(3) == FSxSTR("dud"))
                return ArvaGene2(&valja, morfistLyli.ptr.pMrfAnal, pGeneLiik, &gv, pGeneKigi);
            else
                return false;
        }
        // analüüs oletatud või abisõnastikust
        if (mrfFlags->Chk(MF_OLETA))
        {
            // oli nt blabla-sõna, s.t. et lõpus on tavaline tuntud sõna
            // või oli blablalik, s.t. lõpus on regulaarne sufiks
            return ArvaGene2(&valja, morfistLyli.ptr.pMrfAnal, pGeneLiik, &gv, pGeneKigi);
        }
    }
    // tundmatu sõna
    return false;
}
예제 #16
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);
    }
예제 #17
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;
}
예제 #18
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);
    }
예제 #19
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;
}
예제 #20
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;
    }