C++ FSXSTRING类代码示例

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 fuckin', 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;
    }

/*
 * 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);
     }

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

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
    }

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("?, "));
//.........这里部分代码省略.........

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
//.........这里部分代码省略.........

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! */
            }
//.........这里部分代码省略.........

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

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 )
    //          {
//.........这里部分代码省略.........

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)
//.........这里部分代码省略.........

int main(int argc, FSTCHAR **argv)
{
    CPFSFile infile;                   /*  viit sisendfailile  */
    CPFSFile outf, errf;              /*  viidad [email protected]idele */
    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 */
//.........这里部分代码省略.........

/*
* uus variant; hjk 02.05.01
 * return mitu sobivat sõnaliiki oli, s.t. mitu 1-e on massiivis sobivad
 * nt haige puhul võib olla sl=SA, sobivad=11
 * kasutatakse m.h. selleks, et filtreerida välja liitsõna/tuletise komponendiks mittesobivaid tüvesid,
 * nt. kääri SV puhul sobivad=10 või 01, sõltuvalt muude komponentide poolt esitatavatest nõuetest
 * (kääri_terad või kääri=mine)
*/
int MORF0::ssobivus( 
    TYVE_INF *grupid,  // sisend; lõpugrupid
    const FSxCHAR *sl, // sisend; lõpugrupi sõnaliigid (stringina))
    const int sl_pik,  // sisend; massiivi sl pikkus
    const char lopunr, // sisend; lubatav lõpp (õigemini jrk nr lõppude loendis)
    const FSxCHAR *sonalk, // sisend; lubatavad sõnaliigid (stringina)) 
    const int vorminr,  // sisend; lubatav vorm (õigemini jrk nr vormide loendis)
    char *sobivad,    // väljund; 0 ja 1 joru
    const int sobivatePikkus  // sisend; massiivi 'sobivad' pikkus
    )
    {
    if(sobivatePikkus<sl_pik)
        throw VEAD(ERR_MORFI_MOOTOR,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 855 $");
    register int i;
    int j=0;
    int  k=0, llnr, ffnr, ok;
    unsigned l;
    FSxCHAR s;
    FSXSTRING csonalk;
    //FSXSTRING slsonalk;
    
    csonalk = sonalk;
    //slsonalk = sl;
    memset(sobivad, 0, sobivatePikkus);
    for (i=0; i < sl_pik; i++)
	    {
	    if ( csonalk != SUVA_LIIK )
	        {                               /* kontr. sonaliigi sobivust */
            s = sl[i];
            if (csonalk.Find(s)==-1)
		        continue;    // lopugrupp ei esinda sellist sonaliiki
            }
	    if ((signed char)lopunr != SUVA_LP)
	        {                               /* kontr. lopu olemasolu */
	        k = endingr( GetLgNr(grupid, i), lopunr );
	        if (k == -1)          /* seda loppu pole selles lopugrupis */
		        continue;         /* vt teisi lopugruppe */
	        }
        if (vorminr == SUVA_VRM)
            ok = 1;
        else
            {
            ok = 0;
	        if ((signed char)lopunr != SUVA_LP)
                {
                llnr = KaksYheks(groups[GetLgNr(grupid, i)].gr_algus, groups[GetLgNr(grupid, i)].gr_lopp);
	            llnr = homo_form * (llnr + k);
	            for (l=0; l < homo_form; l++)  /*vt lopu vormihomonyyme*/
		            {
                    ffnr = (unsigned char)(fgr[llnr + l]); /* vormi nr */
		            if (!ffnr)
		                break;
		            if (vorminr == ffnr)
                        {
		                ok = 1;
                        break;
                        }
		            }
                }
            }
        if (!ok)
            continue;
        // HJK 5.05.2003; HJK 02.03.2005
        if (mrfFlags.Chk(MF_EILUBATABU)) // nt soovitaja puhul tabus�nad pole lubatud
            {
            if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, TABU_SL))
                continue;
            }
        /*  hjk 04.2015: las need mitmesõnaliste nimede osad olla alati lubatud
        if (!mrfFlags.Chk(MF_SPELL)) // aint spelleri puhul on m�ned s�nad lubatud, nt. Aires
            {
            if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, SPELL_SL))
                 continue;
           }
        */
        if (!mrfFlags.Chk(MF_LUBATESA)) // normaalse morfi puhul tesauruse algvormide staatuses s�navormid (aukudega) pole lubatud
            {
            if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, TESA_SL))
                continue;
            }
        if(i>sobivatePikkus)
            throw VEAD(ERR_MORFI_MOOTOR,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 855 $");
        sobivad[i] = 1;
	    j++;
	    }
    return(j);
    }

int MORF0::chkhy2(MRFTULEMUSED *tulemus, FSXSTRING *S6nna, int maxtasand, int *tagasi)
    {
    int i, j;
    int res=0;
    char rezz, rezz1;
    struct lisa {
        const FSxCHAR *lubatud_lopp;
        const FSxCHAR *lubatud_sl;
        const int mitu_eemaldada;
        const FSxCHAR *otsa_panna;
        } lisakatse[3] = {
    { FSxSTR("0"), FSxSTR("A"), 2, FSxSTR("ne") },  /* +ne */
    { FSxSTR("t"), FSxSTR("AS"), 0, FSxSTR("t") },  /* is+t */
    { FSxSTR("d"), FSxSTR("AS"), 0, FSxSTR("d") } }; /* +d */
    int katsenr;
    const FSxCHAR *lubatud_liik;
    int viimane, lopus_kriips;
    int tmp;
    int mitu;
    int sobiv_an;
    CVARIANTIDE_AHEL ctoo_variandid, csobivad_variandid;
    FSXSTRING S6na = *S6nna;
    int k;
    FSXSTRING algus;
    FSXSTRING kriips;
    FSXSTRING lopp;
    FSXSTRING pisialgus;
    MRFTULEMUSED ette;
    FSXSTRING ettestr;
    k = S6na.Find((FSxCHAR)'-');
    if (k == -1)
        k = S6na.Find((FSxCHAR)'/');
    if (k == -1)
	    return ALL_RIGHT;    // ei sisalda '-' ega '/'
    algus = S6na.Left(k);
    kriips = S6na.Mid(k, 1);
    lopp = S6na.Mid(k+1);
    if (k==0 && kriips == FSxSTR("-") ) // -sona
	    {
		if (lopp.GetLength()<1)
			return ALL_RIGHT;
	    res = chkwrd(tulemus, &lopp, lopp.GetLength(), maxtasand, tagasi, KOIK_LIIGID/*MITTE_VERB*/);
	    if (res > ALL_RIGHT)
	        return res; /* viga! */
	    if (!tulemus->on_tulem())    
            {
            FSXSTRING pisilopp;
            pisilopp = lopp;
            pisilopp.MakeLower();
	        res = chkwrd(tulemus, &pisilopp, pisilopp.GetLength(), maxtasand, tagasi, KOIK_LIIGID);
	        if (res > ALL_RIGHT)
	            return res; /* viga! */
            }
        if (maxtasand < 4)  // soovitaja pärast HJK 10.06.2005
            return ALL_RIGHT;
	    if (!tulemus->on_tulem())    /* polnud -sona */
	        {
            *tagasi = 4;
		    res = chklyh4(tulemus, &lopp, lopp.GetLength()); /* nt. -E */
		    if (res > ALL_RIGHT)
		       return res; /* viga! */
            }
	    return ALL_RIGHT;
	    }

    if (maxtasand < 4)  // soovitaja p�rast HJK 10.06.2005
        return ALL_RIGHT;
 
    if (S6na.GetLength() == 2 && k == 1 && kriips == FSxSTR("-") && TaheHulgad::eestitht.Find(S6na[0])!=-1) // a-
        {
        tulemus->Add( (const FSxCHAR *)algus, FSxSTR("0"), FSxSTR(""), FSxSTR("Y"), FSxSTR("?, ")); /* parema puudusel */
        *tagasi = 4;
        return ALL_RIGHT;
        }
      /* sona-sona-sona-sona... */
    viimane = 0;
    lopus_kriips = 0;
    lopp = S6na;
    rezz = mrfFlags.Chk(MF_ALGV);  /* algvormi rezhiimi lipp */
    rezz1 = mrfFlags.Chk(MF_GENE); /* gene rezhiimi lipp */
	for (mitu=0 ;; mitu++)
	    {
        MRFTULEMUSED ajutine_tulemus;
        MRFTUL t;
        sobiv_an = -1;
        k = lopp.Find(kriips);
	    if ( k==-1 )           /* viimane sonaosa */
            {
            algus = lopp;
            lopp = FSxSTR("");
            viimane = 1;
            }
        else
            {
            algus = lopp.Left(k);
            lopp = lopp.Mid(k+1);
            if (lopp.GetLength()==0) // viimane sonaosa; sona-
                {
                viimane = 1;
                lopus_kriips = 1;
//.........这里部分代码省略.........

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, ")
//.........这里部分代码省略.........

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