Esempio n. 1
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;
    }
Esempio n. 2
0
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;
    }
Esempio n. 3
0
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;
    }
Esempio n. 4
0
int main(int argc, FSTCHAR **argv)
{
    CPFSFile infile;                   /*  viit sisendfailile  */
    CPFSFile outf, errf;              /*  viidad v@ljundfailidele */
    CPFSFile lgrf;                     /*  viit lõpugruppide failile LGR*/
    FSXSTRING inbuf;		/*  toodeldav rida  */
    FSXSTRING outbuf;		/*  toodeldav rida  */

    CFSFileName fn_0, fn_1, fn_2;
    int  total, converted, unknown;
    int  k;
    int kk, era;
    FSXSTRING inbuf_era, inbuf_para_ind;

    total = converted = unknown = 0;
    if (argc != 4)
        {
        printf("pane argumendid taha !\n");
        return EXIT_FAILURE;
        }
    else
        {
        fn_0=argv[1];
        fn_1=argv[2];
        fn_2=argv[3];
        }

    if (infile.Open(fn_0,      FSTSTR("rb" )) == false ||
        outf.Open( fn_1,       FSTSTR("wb" )) == false ||
        errf.Open( fn_2,       FSTSTR("wb" )) == false ||
        lgrf.Open( FSTSTR("lgr"), FSTSTR("ab+")) == false)
        {
        printf( "Can't open files\n" );
        return EXIT_FAILURE;
        }
    loe_lgr( &lgrf );            /* loe lõpugrupid mällu */
    tyvi[0].tyv = FSxSTR("");


    for (total=0; infile.ReadLine(&inbuf)==true; total++)
        {
        era = inbuf.Find(FSxSTR("**"));
        if (era != -1)
            {
            tyybinr = 1;    /* lihtsalt et poleks 0; vaja tee_rida() jaoks */
            k = inbuf.Find(FSWSTR("!\\"));
            if ( k == -1)       /* polegi indeksit; ei saa olla... */
                sliik = FSWSTR("V");
            else
                {
                sliik = (const FSWCHAR *)inbuf.Mid(k+2);
                k = sliik.Find(FSWSTR("\\"));
                if ( k == -1)
                    {
                    printf("\nsonaliik sassis ");
                    return EXIT_FAILURE;
                    }
                sliik = (const FSWCHAR *)sliik.Left(k);
                }
            k = verbera( &inbuf );
            if (!k)                           /* oli mingi viga */
                {
                unknown++;
                nullityv();            /* et saaks järgmist parad. teha */
                if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
                    {
                    printf("\ntulemuse kirjut. error-faili ebaõnnestus");
                    return EXIT_FAILURE;
                    }
                continue;          /* vt järgmisi ridu */
                }
            converted++;
            lisa_lgr( &lgrf );      /* leiab igale selle parad tyvele lgr nr */
            tee_rida(&inbuf, &outbuf);            /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
            if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
                {
                printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
                return EXIT_FAILURE;
                }
            nullityv();            /* et saaks järgmist parad. teha */
            continue;              /* vt järgmist kirjet */
            }
        kk = inbuf.Find(FSxSTR("&&"));
        inbuf_para_ind = FSxSTR("");
        if (kk != -1)
            inbuf_para_ind = (const FSxCHAR *)inbuf.Mid(kk);
        inbuf = (const FSxCHAR *)inbuf.Left(inbuf.GetLength()-inbuf_para_ind.GetLength());
        k = era_ind( &inbuf );
        if (!k)                           /* oli mingi viga */
            {
            unknown++;
            if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
                {
                printf("\ntulemuse kirjut. error-faili ebaõnnestus");
                return EXIT_FAILURE;
                }
            continue;          /* vt järgmisi ridu */
            }
        k = era_tyvi( &inbuf );
        if (!k)                           /* oli mingi viga */
            {
            unknown++;
            if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
                {
                printf("\ntulemuse kirjut. error-faili ebaõnnestus");
                return EXIT_FAILURE;
                }
            continue;          /* vt järgmisi ridu */
            }
        k = vteepar( );
        if (!k)                           /* oli mingi viga */
            {
            unknown++;
            nullityv();            /* et saaks järgmist parad. teha */
            if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
                {
                printf("\ntulemuse kirjut. error-faili ebaõnnestus");
                return EXIT_FAILURE;
                }
            continue;          /* vt järgmisi ridu */
	        }
	    if ( kk != -1 )                   /* leidub parall. indeks */
	        {
            inbuf_para_ind = (const FSxCHAR *)inbuf_para_ind.Mid(2);
            k = era_ind( &inbuf_para_ind );
	        if (!k)                           /* oli mingi viga */
		        {
		        unknown++;
                if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
		            {
		            printf("\ntulemuse kirjut. error-faili ebaõnnestus");
		            return EXIT_FAILURE;
		            }
		        continue;          /* vt järgmisi ridu */
		        }
	        k = vparpar( );
	        if (!k)                           /* oli mingi viga */
		        {
		        unknown++;
		        nullityv();            /* et saaks järgmist parad. teha */
                if ((errf.WriteString((const FSxCHAR *)inbuf, inbuf.GetLength())) == false)
		            {
		            printf("\ntulemuse kirjut. error-faili ebaõnnestus");
		            return EXIT_FAILURE;
		            }
		        continue;          /* vt järgmisi ridu */
		        }
	        }
	    converted++;
	    lisa_lgr( &lgrf );      /* leiab igale selle parad tyvele lgr nr */
	    tee_rida(&inbuf, &outbuf);            /* teeb rea nr|tyvi,lgr/tyvi,lgr... */
        if ((outf.WriteString((const FSxCHAR *)outbuf, outbuf.GetLength())) == false)
	        {
	        printf("\ntulemuse kirjut. väljundfaili ebaõnnestus");
	        return EXIT_FAILURE;
	        }
	    nullityv();            /* et saaks järgmist parad. teha */

	    /*STAT:*/    /* tooseisu v@ljastamine ekraanile */
	    if ( total % 100 == 0 )
	        printf( "\r  KOKKU: %6d KORRAS: %6d SEGASEID: %6d ",
			      total, converted, unknown );
	    }

   /* FILE_END:*/
    printf( "\r  KOKKU: %6d KORRAS: %6d SEGASEID: %6d ",
			  total, converted, unknown );
    Wprintf( FSTSTR("** VRB: %s\n"), (const FSTCHAR*)fn_0);
    infile.Close();
    outf.Close();
    errf.Close();
    lgrf.Close();
    return EXIT_SUCCESS;
}
Esempio n. 5
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);
    }
Esempio n. 6
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;
    }
Esempio n. 7
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;
    }