public void kelimeBicimlendir(Kelime kelime) {
        Kok kok = kelime.kok();
        HarfDizisi olusan = kelime.icerik();
        if (kok.tip().Equals(KelimeTipi.KISALTMA)) {
            //cozumleme sirasinda eklenmis harf varsa onlari sil.
            int silinecek = kok.icerik().Length;
            if (kok.ozelDurumIceriyormu(TurkceKokOzelDurumTipi.KISALTMA_SON_SESSIZ))
                silinecek += 2;
            if (kok.ozelDurumIceriyormu(TurkceKokOzelDurumTipi.KISALTMA_SON_SESLI))
                silinecek++;
            //kelimenin olusan kismindan kokun icereigini sil.
            olusan.harfSil(0, silinecek);
            //simdi kokun orjinal halini ekle.
            olusan.ekle(0, new HarfDizisi(kok.asil(), alfabe));

            if (olusan.Length == kok.asil().Length)
                return;
            //eger gerekiyorsa kesme isareti koy.
            if (!olusan.harf(kok.asil().Length - 1).Equals(alfabe.harf('.')))
                olusan.ekle(kok.asil().Length, alfabe.harf('\''));

        } else if (kok.tip() == KelimeTipi.OZEL) {
            olusan.harfDegistir(0, alfabe.buyukHarf(olusan.ilkHarf()));
            if (kok.ozelDurumIceriyormu(TurkceKokOzelDurumTipi.KESMESIZ))
                return;
            List<Ek> ekler = kelime.ekler();
            if (ekler.Count > 1) {
                Ek ek = (Ek) ekler[1];
                if (ek.iyelikEkiMi() ||ek.halEkiMi()) {
                    int kesmePozisyonu = kok.icerik().Length;
                    olusan.ekle(kesmePozisyonu,alfabe.harf('\''));
                }
            }
        }
        // ozel ic karakter iceren kokler icin bicimleme
/*        if (kok.ozelDurumlar().contains(TurkceKokOzelDurumlari.OZEL_IC_KARAKTER)) {
            //olusan ksimdan koku sil
            int silinecek = kok.icerik().length();
            olusan.harfSil(0, silinecek);
            //simdi kokun orjinal halini ekle.
            olusan.ekle(0, new HarfDizisi(kok.asil()));
        }*/
    }
    private IList<Kelime> coz(Kok kok, HarfDizisi kokDizi, HarfDizisi girisDizi, int tolerans) {

        Kelime kelime = new Kelime(kok, kokDizi);
        kelime.ekEkle(ekYonetici.ilkEkBelirle(kelime.kok()));
        BasitKelimeYigini kelimeYigini = new BasitKelimeYigini();

        List<Kelime> uygunSonuclar = new List<Kelime>();

        //analiz kelimesini kokler kokunden olustur.
        kelimeYigini.temizle();
        Ek bulunanEk = kelime.sonEk();

        int ardisilEkSirasi = 0;
        while (true) {
            //bulunan son ekten sonra gelebilecek eklerden siradakini al.
            Ek incelenenEk = bulunanEk.getArdisilEk(ardisilEkSirasi++);

            //siradaki ek yoksa incelenen ek yanlis demektir.
            // yigindan kelimenin onceki durumunu cek.
            if (incelenenEk == null) {
                //yigin bos ise sonuclar dondur.
                if (kelimeYigini.bosMu())
                    return uygunSonuclar;

                //kelimeyi ve bulunan eki onceki formuna donustur.
                BasitKelimeYigini.YiginKelime yiginKelime = kelimeYigini.al();
                kelime = yiginKelime.getKelime();
                bulunanEk = kelime.sonEk();
                ardisilEkSirasi = yiginKelime.getEkSirasi();
                continue;
            }

            //eger daha olusan kelime kok asamasinda ise (yani sadece YALIN eki eklenmisse)
            // ve kokun (kelime ile kok ayni ozel durumlara sahip) icinde bir ozel durum var ise
            // ozel durum denetlenir, yani kokun girilen ek ile degisip degismedigine bakilir.
            if (kelime.ekler().Count == 1 && kelime.kok().ozelDurumVarmi()) {
                if (!ozelDurumDenetle(kelime, girisDizi, incelenenEk, tolerans)) 
                {
                    if (logger.IsInfoEnabled) logger.Info("Ozel durum yanlis, ek:" + incelenenEk);
                    continue;
                }
            }

            //bazi eklerin olusumu, giris kelimesinin yapisina gore degisebilir.
            // ornegin giris "geleceGim" oldugu durumda gelecek zaman ekinin son harfinin
            // yumusamasi bilgisi ancak girise bakarak anlasilabilir. bu nedenle ek olusturma sirasinda giris
            // kullanilir

            HarfDizisi olusanEk = incelenenEk.cozumlemeIcinUret(kelime, girisDizi, null);
            //log.info("ek:" + incelenenEk + " olusum:" + olusanEk);
            if (olusanEk == null || olusanEk.Length == 0) {
                //log.info("bos ek.. " + incelenenEk);
                continue;
            }


            if (logger.IsInfoEnabled) logger.Info("Kok ve Olusan Ek:" + kelime.icerik() + " " + olusanEk);

            //Toleransli kiyaslama islemi burada yapiliyor. once gecici bir sekilde olusan kelimeye
            // olusan ek ekleniyor, ve giris ile toleransli kiyaslama yapiliyor. Eger kiyaslama
            // sonunda esik tolerans degeri asilmazsa dogru kabul edilip devam ediliyor.
            HarfDizisi olusum = new HarfDizisi(kelime.icerik());
            olusum.ekle(olusanEk);
            String olusumStr = olusum.ToString();
            if (logger.IsInfoEnabled) logger.Info("olusum:" + olusum);

            if (MetinAraclari.isInSubstringEditDistance(olusumStr, girisDizi.ToString(), tolerans) ||
                    MetinAraclari.inEditDistance(olusumStr, girisDizi.ToString(), tolerans)) {
                        kelimeYigini.koy((Kelime)kelime.Clone(), ardisilEkSirasi);
                ardisilEkSirasi = 0;
                // ek ekleneceginde yumusama yapilip yapilmayacagi belirleniyor.. aci
                if (olusanEk.harf(0).sesliMi()
                        && kelime.sonHarf().sertMi()
                        && kelime.ekler().Count > 1
                        && olusanEk.ilkHarf().sertDonusum()!=null) {
                    kelime.icerik().sonHarfYumusat();
                }
                kelime.icerikEkle(olusanEk);
                kelime.ekEkle(incelenenEk);
                olusumStr = kelime.icerikStr();
                if (logger.IsInfoEnabled) logger.Info("ekleme sonrasi olusan kelime: " + kelime.icerik());

                bulunanEk = incelenenEk;

                if (MetinAraclari.inEditDistance(olusumStr, girisDizi.ToString(), tolerans)) {
                    uygunSonuclar.Add((Kelime)kelime.Clone());
                    if (logger.IsInfoEnabled) logger.Info("uygun kelime:" + kelime.icerik());
                }
/*
                        TurkceHarf ekIlkHarf = giris.harf(kelime.boy());
                        if (ekIlkHarf == TurkceAlfabe.TANIMSIZ_HARF)
                            return false;*/

            }
        }
    }
    public bool kelimeBicimiDenetle(Kelime kelime, String giris) {
        if (giris.Length == 0) return false;
        Kok kok = kelime.kok();
        if (kok.tip().Equals(KelimeTipi.KISALTMA)) {
            // eger giriskokun orjinal hali ile baslamiyorsa hatali demektir.
            String _asil = kok.asil();
            if (!giris.StartsWith(_asil))
                return false;
            if (giris.Equals(_asil))
                return true;
            //burada farkli kisaltma turleri icin kesme ve nokta isaretlerinin
            // dogru olup olmadigina bakiliyor.
            String kalan = giris.Substring(_asil.Length);
            if (_asil[_asil.Length - 1] == '.') {
                return kalan[0] != '\'';
            }
            return kalan[0] == '\'';
        } else if (kelime.kok().tip() == KelimeTipi.OZEL) {
            if (Char.IsLower(giris[0]))
                return false;
            if (kelime.kok().ozelDurumIceriyormu(TurkceKokOzelDurumTipi.KESMESIZ))
                return true;
            List<Ek> ekler = kelime.ekler();
            if (ekler.Count > 1) {
                Ek ek = (Ek) ekler[1];
                if (ek.iyelikEkiMi() || ek.halEkiMi()) {
                    int kesmePozisyonu = kelime.kok().icerik().Length;
                    return kesmePozisyonu <= giris.Length && giris[kesmePozisyonu] == '\'';
                }
            }
        }
        // ozel ic karakter iceren kokler icin bicimleme
/*        if (kok.ozelDurumlar().contains(TurkceKokOzelDurumlari.OZEL_IC_KARAKTER)) {&
            //olusan ksimdan koku sil
            String _asil = kok.asil();
            if (!giris.startsWith(_asil))
              return false;
        }*/
        return true;
    }
Esempio n. 4
0
    private UretimNesnesi uretimNesnesiUret(Kok kok, IList<Ek> ekler) {

        if (kok == null)
            return new UretimNesnesi("");
        UretimNesnesi ure = new UretimNesnesi(kok.icerik());
        Kelime kelime = new Kelime(kok, alfabe);

        if (ekler.Count > 1) {
            HarfDizisi ozelDurumSonrasi = kok.ozelDurumUygula(alfabe, ekler[1]);
            if (ozelDurumSonrasi != null)
                kelime.setIcerik(ozelDurumSonrasi);
            else
                return ure;
        } else {
            return ure;
        }

        for (int i = 0; i < ekler.Count; i++) {

            Ek ek = ekler[i];

            // eger incelenen ek onceki ekten sonra gelemezse cik.
            if (i > 0) 
            {
                Ek oncekiEk = ekler[i - 1];
                if (!oncekiEk.ardindanGelebilirMi(ek)) 
                {
                    return ure;
                }
            }



            //olusum icin kural belirle ve eki olustur.
            HarfDizisi ekOlusumu;
            if (i < ekler.Count - 1)
                ekOlusumu = new HarfDizisi(ek.olusumIcinUret(kelime, ekler[i + 1]));
            else
                ekOlusumu = new HarfDizisi(ek.olusumIcinUret(kelime, TemelEkYonetici.BOS_EK));

            //TODO: asagidaki bolum dil ozel. muhtemelen olusumIcinURet metodu duzletilirse gerek kalmaz.
            // ek son harf yumusatmayi kendimiz hallediyoruz (eger yalin ek ise bu islemi pas geciyoruz.)
            if (i > 1) {
                if (kelime.sonHarf().sertMi() && ekOlusumu.ilkHarf().sesliMi())
                    kelime.icerik().sonHarfYumusat();
            }

            //eki kelimeye ve ek olusumlarina ekle.
            kelime.icerikEkle(ekOlusumu);
            if (ekOlusumu.Length > 0)
                ure.olusumlar.Add(ekOlusumu.ToString());
            kelime.ekler().Add(ek);
        }

        //son duzeltmeleri uygula.
        yardimci.kelimeBicimlendir(kelime);
        ure.olusum = kelime.icerikStr();
        return ure;
    }
Esempio n. 5
0
 /**
  * Kok ve Ek listesi tasiyan bir kelimeyi String listesi seklinde parcalara ayirir.
  * Kelime {kok={kitap, ISIM} ekler = {ISIM_SAHIPLIK_BEN, ISIM_YONELME_E}} icin
  * {kitap,Im,a} dizisi doner.
  *
  * @param kelime : kelime
  * @return kok ve ek icerikleri (String[]) cinsinden dizi. Eger ek listesi bos ise ya da
  *         sadece yalin ek var ise sadece kok icerigi doner. Kokun ozel durum ile bozulmus hali degil
  *         orjinal icerigini iceren dizi doner.
  *         TODO:
  *         simdilik ozle adlarda bas harf kucuk olarak donuyor. Ayrica ozel yazimli koklerin orjinali
  *         degil ayiklanmis hali doner.
  */
 public IList<String> ayristir(Kelime kelime) {
     UretimNesnesi ure = uretimNesnesiUret(kelime.kok(), kelime.ekler());
     return ure.olusumlar;
 }