public IdentificadorCat(string descripcio, Regles regles) : base(descripcio) { this.regles = regles; ParadigmaCat.PosaRegles(regles); excepcions = new Dictionary<string, InfoExcepcio>(); }
private void AfinaRegles(Regles regles) { String[] generaUn = { "V", "W", "Y", "Z", "C", "D" }; foreach (string g1 in generaUn) regles.Llista[g1].MaxGenera = 1; regles.Llista["C"].EsAfix = false; regles.Llista["D"].EsAfix = false; }
/// <summary> /// Crea amb unes regles. /// </summary> /// <param name="regles">Les regles aplicables a una llista tipus DIEC.</param> public IdentificadorDIEC(string desc, Regles regles, string fitxerExcepcions) : base(desc, regles) { if (fitxerExcepcions != null) { int numLinia = 0; FitxerFont fitxerFont = FitxerFont.Crea(fitxerExcepcions); StreamReader fitxer = new StreamReader(fitxerExcepcions, Encoding.Default); while (!fitxer.EndOfStream) { string linia = fitxer.ReadLine().Trim(); ++numLinia; Match match = liniaIrr.Match(linia); if (!match.Success) continue; string ent = match.Groups[1].Value; string cont = match.Groups[2].Value; LiniaMarques lm = LlegeixLiniaExc(cont); NovaExcepcio(ent, lm, fitxerFont, numLinia); } fitxer.Close(); } }
/// <summary> /// Genera els mots per a una arrel. /// </summary> /// <param name="arrel">L'arrel que es vol expandir.</param> /// <param name="infoComuna"> /// Informació comuna a tots els mots que es generaran. /// Aquesta informació s'unifica amb la que va associada als casos. /// Per tant, només es generen els casos que tenen informació compatible. /// </param> /// <param name="regles">La llista completa de regles.</param> /// <param name="filtre">Només es generen mots que tenen marques contingudes en aquest filtre.</param> /// <param name="nomesAfixos">Si és true, només s'apliquen les regles amb la propietat EsAfix = true.</param> /// <returns>La llista generada de mots.</returns> public List<Mot> Genera(string arrel, MorfoGram infoComuna, Regles regles, Marques filtre, bool nomesAfixos) { List<Mot> mots = new List<Mot>(); if (nomesAfixos && !EsAfix) return mots; int afegits = 0; foreach (CasRegla cas in casos) { if (!MorfoGram.Unificables(cas.Info, infoComuna) || !filtre.Conte(cas.Marca)) continue; afegits += cas.Genera(arrel, ref mots, infoComuna, regles, filtre, nomesAfixos); if (afegits >= maxGenera) break; } return mots; }
/// <summary> /// Calcula els valors adequats de CalCombinable per a les regles que calgui. /// </summary> /// <param name="regles">Totes les regles.</param> public void CalculaCalCombinable(Regles regles) { foreach (CasRegla cas in casos) { List<string> mesRegles = cas.MesRegles; if (mesRegles != null) foreach (string idRegla in cas.MesRegles) { Regla regla = regles.Llista[idRegla]; if (!regla.EsCombinable && !regla.CalCombinable) regla.CalCombinable = true; } } }
private Regles CarregaRegles(bool generaCurt, Marques filtre) { Regles regles = new Regles(DirEntrades("regles.txt"), filtre); if (generaCurt) { String[] generaUn = { "V", "W", "Y", "Z", "C", "D" }; foreach (string g1 in generaUn) regles.Llista[g1].MaxGenera = 1; } regles.Llista["C"].EsAfix = false; regles.Llista["D"].EsAfix = false; return regles; }
/// <summary> /// Crea amb unes regles. /// </summary> /// <param name="regles">Les regles en vigor.</param> public IdentificadorToponims(string desc, Regles regles) : base(desc, regles, null) { }
public static List<CreaDicMyspell> GeneraCreadors(ItemDic itemMostra, Dictionary<string, List<ReglaMyspell>> vellANou, Regles regles) { List<CreaDicMyspell> creadors = new List<CreaDicMyspell>(); // Feim la llista de regles que han d'aparèixer a tots els creadors List<string> reglesComunes = new List<string>(); foreach (string idRegla in itemMostra.LlistaFlags) { if (vellANou[idRegla].Count == 0) throw new Exception("Regla sense equivalència: " + idRegla); if (vellANou[idRegla].Count == 1 && vellANou[idRegla][0].EsRegla) reglesComunes.Add(vellANou[idRegla][0].Id); } // Cream regles per als altres flags foreach (string idRegla in itemMostra.LlistaFlags) { foreach (ReglaMyspell regla in vellANou[idRegla]) { if (regla.EsRegla) { CreaDicMyspellRegla creador = new CreaDicMyspellRegla(regles); creador.MesFlags(reglesComunes); creador.MesFlags(regla.Id); creador.ConverteixArrel = regla.Afinador; foreach (Regla contraria in regla.AfixosContraris) foreach (ReglaMyspell nova in vellANou[contraria.Id]) creador.MesFlags(nova.Id); creadors.Add(creador); } else { foreach (CasRegla cas in regla.Casos) { CreaDicMyspellCas creador = new CreaDicMyspellCas(cas, regles); creador.MesFlags(reglesComunes); creador.ConverteixArrel = regla.Afinador; foreach (Regla igual in regla.AfixosIguals) foreach (ReglaMyspell nova in vellANou[igual.Id]) creador.MesFlags(nova.Id); ; foreach (Regla contraria in regla.AfixosContraris) foreach (ReglaMyspell nova in vellANou[contraria.Id]) creador.MesFlags(nova.Id); ; creadors.Add(creador); } } } } // Si no hem afegit cap creador, tornam el vell if (creadors.Count == 0) { CreaDicMyspellRegla creador = new CreaDicMyspellRegla(regles); creador.MesFlags(reglesComunes); creadors.Add(creador); } // return creadors; }
/// <summary> /// Genera la línia corresponent a aquest cas per al fitxer .aff. /// </summary> /// <param name="regla">La regla de la qual forma part aquest cas.</param> /// <param name="regles">Les regles en vigor (per als flags "twofold")</param> /// <returns>Una línia per al fitxer .aff.</returns> public string GeneraAff(Regla regla, Regles regles) { return GeneraAff(regla, regla.Id, regles); }
/// <summary> /// Genera les línies per al fitxer .aff /// </summary> /// <param name="filtre">Només posarem els casos amb marques contingudes dins el filtre.</param> public string[] GeneraAff(Marques filtre, Regles regles) { return GeneraAff(filtre, id, combinable, regles); }
/// <summary> /// Genera una llista de GrupMyspell /// </summary> public List<ReglaMyspell> GrupsMyspell(Regles regles, Marques filtre, GetAfinaReglaMyspell getAfina) { List<ReglaMyspell> grups = new List<ReglaMyspell>(); foreach (CasRegla cas in casos) { if (!filtre.Conte(cas.Marca)) continue; ReglaMyspell grup = grups.Find(delegate(ReglaMyspell g) { return g.CasPertany(cas); }); if (grup == null) { grup = new ReglaMyspell(this, regles, getAfina); grups.Add(grup); } grup.NouCas(cas); } return grups; }
/// <summary> /// Diu si els flags d'aquest ítem són compatibles amb els d'un altre. /// Són compatibles si: /// - Són iguals /// </summary> public bool FlagsCompatibles(ItemDic altre, Regles regles) { return regles.ReglesCompatibles(FlagsComLletres, altre.FlagsComLletres); }
/// Crea amb unes regles. /// </summary> /// <param name="regles">Les regles aplicables a una llista tipus DIEC.</param> public IdentificadorAntroponims(string desc, Regles regles, string fitxerExcepcions) : base(desc, regles, fitxerExcepcions) { }
public static List<Mot> GeneraMots(List<ItemDic> items, Marques filtre, Regles regles, bool nomesAfixos) { List<Mot> llista = new List<Mot>(); foreach (ItemDic item in items) { string arrel = item.Arrel; List<Regla> pre = null; List<Regla> suf = null; foreach (string idRegla in item.LlistaFlags) { Regla regla = regles.Llista[idRegla]; if (regla.EsSufix) { if (suf == null) suf = new List<Regla>(); suf.Add(regla); } else if (!nomesAfixos || regla.EsAfix) { if (pre == null) pre = new List<Regla>(); pre.Add(regla); } } if (pre == null && suf == null) { llista.Add(new Mot(arrel, null, item.mgArrel | item.mgComuna)); } else if (pre == null || suf == null) { llista.Add(new Mot(arrel, null, item.mgArrel | item.mgComuna)); foreach (Regla regla in ((pre != null) ? pre : suf)) llista.AddRange(regla.Genera(arrel, regla.EsAfix ? item.mgComuna : item.mgComuna | item.mgArrel, regles, filtre, nomesAfixos)); } else // (pre != null && suf != null) { // Afegim l'arrel nua llista.Add(new Mot(arrel, null, item.mgArrel | item.mgComuna)); // Afegim l'arrel combinada amb els prefixos // (com que no afegim sufixos a l'arrel, té els trets procedents de mgArrel) foreach (Regla reglaPre in pre) llista.AddRange(reglaPre.Genera(arrel, item.mgArrel | item.mgComuna, regles, filtre, nomesAfixos)); foreach (Regla reglaSuf in suf) { // Afegim l'arrel combinada amb els sufixos List<Mot> mots = reglaSuf.Genera(arrel, reglaSuf.EsAfix ? item.mgComuna : item.mgComuna | item.mgArrel, regles, filtre, nomesAfixos); llista.AddRange(mots); if (!reglaSuf.EsCombinable) continue; // Afegim els prefixos a cadascun dels sufixos que ho permetin // Els mots hereden la informació procedent dels sufixos foreach (Regla reglaPre in pre) { if (!reglaPre.EsCombinable) continue; foreach (Mot mot in mots) llista.AddRange(reglaPre.Genera(mot.Forma, mot.Info, regles, filtre, nomesAfixos)); } } } } return llista; }
/// <summary> /// Compacta una llista d'ítems. /// Torna una llista amb la longitud mínima i ordenada. /// Uneix els ítems que tenguin la mateixa arrel i siguin compatibles. /// El procés d'unió es repeteix fins que es pugui. /// La informació morfològica i gramatical dels ítems es perd. /// </summary> /// <param name="llista">La llista d'entrada, segurament amb repeticions i ítems que es poden unir.</param> /// <param name="regles">Les regles per interpretar els flags dels ítems.</param> /// <param name="comparador">Una funció per ordenar la llista resultant.</param> /// <returns>Una llista compactada.</returns> public static List<ItemDic> CompactaLlista(List<ItemDic> llista, Regles regles, Comparison<string> comparador) { Dictionary<string, List<ItemDic>> unics = new Dictionary<string, List<ItemDic>>(); foreach (ItemDic item in llista) { if (!unics.ContainsKey(item.Arrel)) unics.Add(item.Arrel, new List<ItemDic>()); ItemDic nou = new ItemDic(item.Arrel); nou.MesFlags(item); List<ItemDic> grup = unics[item.Arrel]; grup.Add(nou); while (grup.Count > 1) { bool canvis = false; for(int i=0; i<grup.Count - 1; i++) { for (int j = i + 1; j < grup.Count; j++) { ItemDic item1 = grup[i]; ItemDic item2 = grup[j]; if (item1.FlagsCompatibles(item2, regles)) { item1.MesFlags(item2); grup.Remove(item2); canvis = true; break; } } if (canvis) break; } break; } } List<ItemDic> llistaNova = new List<ItemDic>(unics.Count * 2); foreach (List<ItemDic> grup in unics.Values) llistaNova.AddRange(grup); llistaNova.Sort(delegate(ItemDic item1, ItemDic item2) { int cmp = comparador(item1.Arrel, item2.Arrel); return (cmp != 0) ? cmp : string.Compare(item1.FlagsComLletres, item2.FlagsComLletres); }); return llistaNova; }
/// <summary> /// Torna una llista d'ItemDic aplanada. /// Els ítems de la llista nova només contenen flags per a regles amb EsSufix = false. /// </summary> /// <param name="items">La llista d'ítems que volem aplanar.</param> /// <param name="regles">La llista de regles que emprarem.</param> /// <param name="filtre">Només es generen mots que tenen marques contingudes en aquest filtre.</param> /// <returns>La llista aplanada.</returns> public static List<ItemDic> Aplana(List<ItemDic> items, Regles regles, Marques filtre) { // PERFER: No desplegar els futurs i els condicionals, ja que són sempre regulars (?) List<ItemDic> llista = new List<ItemDic>(); foreach (ItemDic item in items) { string arrel = item.Arrel; List<Regla> aff = null; List<string> noAff = new List<string>(); foreach (string idRegla in item.LlistaFlags) { Regla regla = regles.Llista[idRegla]; if (regla.EsAfix) { if (aff == null) aff = new List<Regla>(); aff.Add(regla); } else { noAff.Add(idRegla); } } if (aff == null) { // PER_FER: mirar si no hem de posar totes les regles de noaff llista.Add(item); } else // (aff != null) { ItemDic nou = null; // Afegim l'arrel nua nou = new ItemDic(arrel, noAff.ToArray()); nou.MesMorfoGram(item.mgComuna, item.mgArrel); llista.Add(nou); // Afegim els mots generats per les regles d'aff foreach (Regla regla in aff) { List<Mot> mots = new List<Mot>(); foreach (CasRegla cas in regla.Casos) { mots.Clear(); int generats = cas.Genera(arrel, ref mots, item.mgComuna, regles, filtre, true); if (generats == 0) continue; if (generats > 1) throw new Exception("S'esperava un sol mot per al cas"); Mot mot = mots[0]; nou = new ItemDic(mot.Forma); if (regla.EsCombinable) foreach (string id in noAff) { Regla reglaNoAff = regles.Llista[id]; if (reglaNoAff.EsCombinable && reglaNoAff.EsAplicable(nou.Arrel)) nou.MesFlags(id); } if (cas.MesRegles != null) { foreach (string id in cas.MesRegles) { Regla reglaExtra = regles.Llista[id]; if (reglaExtra.EsAplicable(nou.Arrel)) nou.MesFlags(id); } } nou.MesMorfoGram(item.mgComuna, mot.Info); llista.Add(nou); } } } } return llista; }
private void test_02(GrupTest arrel) { GrupTest grup = arrel.NouGrup("Fitxer de regles"); Regles regles = null; grup.NouTest("Llegeix fitxer .txt", delegate(RTest resultat) { //regles = new Regles(DirEntrades("regles.txt"); regles = new Regles(DirEntrades("regles.txt")); }); grup.NouTest("Llegeix fitxer .aff", delegate(RTest resultat) { Regles regles2 = Regles.LlegeixAff(DirResultats("prova.aff")); }); grup.NouTest("Marca de dialecte", delegate(RTest resultat) { Marca marca = regles.Marques["000"]; resultat.Esperat("000: Sense condicions", marca.ToString()); }); grup.NouTest("Marques", delegate(RTest resultat) { Marques m1 = new Marques(false, "001", "002", "005", "013", "014", "101", "102", "103"); Marques m1bis = new Marques(false, "001", "002", "005", "013", "014", "101", "102", "103"); resultat.Esperat("001, 002, 005, 013, 014, 101, 102, 103", m1.ToString()); resultat.Assert(m1.Conte("005"), "Conté 005"); resultat.Assert(!m1.Conte("000"), "No conté 000"); resultat.Assert(m1.Conte(Marca.Una("001").Mascara), "Conté 001"); resultat.Assert(!m1.Conte(Marca.Una("000").Mascara), "No conté 000"); Marques m2 = new Marques(false, "101", "102", "103"); resultat.Assert(m1.Conte(m2), "m1 >= m2"); resultat.Assert(!m2.Conte(m1), "!(m2 >= m1)"); resultat.Assert(m1 == m1bis, "Són iguals!"); m1.Mes(Marca.Una("003")); resultat.Esperat("001, 002, 003, 005, 013, 014, 101, 102, 103", m1.ToString()); m1.Menys(Marca.Una("013")); resultat.Esperat("001, 002, 003, 005, 014, 101, 102, 103", m1.ToString()); }); grup.NouTest("Línia amb condicions I", delegate(RTest resultat) { // Suposam la cadena "abc <<001 def 001>> ghi" LiniaMarques lm = new LiniaMarques(); Marca.Crea("_1_", "Grup 1"); Marca.Crea("_2_", "Grup 2"); Marques m = new Marques(false, "_1_"); lm.Nou("abc ", m); m.Mes(Marca.Una("001")); lm.Nou(" def ", m); m.Menys(Marca.Una("001")); lm.Nou(" ghi", m); resultat.Esperat("abc def ghi", lm.Valor(new Marques(false, "_1_", "001"))); resultat.Esperat("abc ghi", lm.Valor(new Marques(false, "_1_"))); resultat.Esperat("", lm.Valor(new Marques(false))); }); grup.NouTest("Línia amb condicions II", delegate(RTest resultat) { regles = new Regles(DirEntrades("regles.txt")); LiniaMarques lm = IdentificadorDIEC.LlegeixLiniaExc("abc <<001 def 001>> ghi <<!002 jkl !002>>"); resultat.Esperat("abc def ghi jkl", lm.Valor(new Marques(false, "_1_", "001")).Trim()); resultat.Esperat("abc ghi jkl", lm.Valor(new Marques(false, "_1_")).Trim()); resultat.Esperat("abc ghi", lm.Valor(new Marques(false, "_1_", "002")).Trim()); resultat.Esperat("", lm.Valor(new Marques(false)).Trim()); }); grup.NouTest("Genera mots", delegate(RTest resultat) { Regla regla = regles.Llista["E"]; List<Mot> mots = regla.Genera("aigua", null, regles, Marques.totes, true); resultat.Esperat("aigües", Mot.LlistaPlana(mots, Cat.Cmp, false)); for (int i = 0; i < mots.Count; i++) resultat.Nota("{0}: {1}", i, mots[i]); }); grup.NouTest("Regles aplicables", delegate(RTest resultat) { Regla regla = regles.Llista["A"]; resultat.Assert(regla.EsAplicable("cantava"), "Es pot aplicar la regla A a 'cantava'"); resultat.Assert(!regla.EsAplicable("cantar"), "No es pot aplicar la regla A a 'cantar'"); }); }
/// Crea amb unes regles. /// </summary> /// <param name="regles">Les regles aplicables a una llista tipus DIEC.</param> public IdentificadorDiversos(string desc, Regles regles) : base(desc, regles, null) { }
/// <summary> /// Genera les línies per al fitxer .aff /// </summary> /// <param name="filtre">Només posarem els casos amb marques contingudes dins el filtre.</param> /// <param name="nouId">L'identificador que farem servir per a la regla.</param> /// <param name="nouCombinable">El valor nou per a combinable.</param> /// <param name="regles">Les regles a les quals pertany aquesta.</param> public string[] GeneraAff(Marques filtre, string nouId, bool nouCombinable, Regles regles) { List<string> liniesCasos = new List<string>(); foreach (CasRegla cas in casos) if (filtre.Conte(cas.Marca)) liniesCasos.Add(cas.GeneraAff(this, nouId, regles)); List<string> linies = new List<string>(); linies.Add(string.Format("{0}FX {1} {2} {3}", sufix ? "S" : "P", nouId, nouCombinable ? "Y" : "N", liniesCasos.Count)); linies.AddRange(liniesCasos); return linies.ToArray(); }
/// <summary> /// Torna una llista de regles que només conté els casos que surten a gros però no a petit. /// </summary> /// <param name="gros">La llista de regles més grossa.</param> /// <param name="petit">La llista de regles més petita.</param> /// <returns>La llista de regles diferència.</returns> public static Regles Diferencia(Regles gros, Regles petit) { //PER_FER: donar un error si un cas surt a petit però no a gros? Regles regles = new Regles(); Dictionary<string, bool> dinsPetit = new Dictionary<string, bool>(); foreach (Regla regla in petit.regles.Values) foreach (CasRegla cas in regla.Casos) dinsPetit[cas.ToString()] = true; foreach (Regla regla in gros.regles.Values) { Regla reglaNova = null; foreach (CasRegla cas in regla.Casos) if (!dinsPetit.ContainsKey(cas.ToString())) { if (reglaNova == null) { reglaNova = new Regla(regla.Id, regla.Descripcio, regla.EsSufix, regla.EsCombinable); regles.regles.Add(reglaNova.Id, reglaNova); } reglaNova.NouCas(cas); } } return regles; }
public ReglaMyspell(Regla reglaOriginal, Regles regles, GetAfinaReglaMyspell getAfinaGrup) { this.reglaOriginal = reglaOriginal; this.regles = regles; casos = new List<CasRegla>(); afixosContraris = new List<Regla>(); afixosIguals = new List<Regla>(); getAfinador = getAfinaGrup; afinador = null; regla = null; }
public static void GeneraOXT(Regles regles, string dirFitxer, string nomFitxer, CanviaString canvis) { // genera .oxt String path = dirFitxer + nomFitxer + ".oxt"; File.Delete(path); using (ZipFile zip = new ZipFile(path)) { zip.AddFile(dirFitxer + nomFitxer + ".dic", "dictionaries"); zip.AddFile(dirFitxer + nomFitxer + ".aff", "dictionaries"); zip.AddFile(dirFitxer + @"..\..\OXT\" + "LICENSES-en.txt",""); zip.AddFile(dirFitxer + @"..\..\OXT\" + "LLICENCIES-ca.txt", ""); zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + nomFitxer + "\dictionaries.xcu", canvis, "\r\n", Encoding.UTF8), "dictionaries.xcu", ""); zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + nomFitxer + "\description.xml", canvis, "\r\n", Encoding.UTF8), "description.xml", ""); //zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + "release-notes_en.txt", canvia), "release-notes_en.txt", ""); //zip.AddStringAsFile(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + "release-notes_ca.txt", canvia), "release-notes_ca.txt", ""); zip.AddFile(dirFitxer + @"..\..\OXT\META-INF\" + "manifest.xml", "META-INF/"); zip.AddFile(dirFitxer + @"..\..\OXT\" + "SC-logo.png",""); zip.Save(); } // genera update.xml, release-notes_en.txt i release-notes_ca.txt path = dirFitxer + nomFitxer + ".update.xml"; using (StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8)) { sw.Write(AdaptaFitxer(dirFitxer + @"..\..\OXT\update.xml", canvis, "\r\n", Encoding.UTF8)); } string[] llengues = { "ca", "en" }; foreach (string llengua in llengues) { path = dirFitxer + "release-notes_" + llengua + ".html"; using (StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8)) { sw.Write(AdaptaFitxer(dirFitxer + @"..\..\OXT\" + "release-notes_" + llengua + ".html", canvis, "\r\n", Encoding.UTF8)); } } }
/// <summary> /// Genera mots a partir d'una arrel. Els mots creats s'afegeixen a la llista donada. /// </summary> /// <param name="mots">La llista que recull els mots creats.</param> /// <param name="arrel">L'arrel a la qual s'ha d'aplicar el cas.</param> /// <param name="infoComuna">Informació morfològica que s'ha d'afegir a la del cas. /// Pot ser informació comuna a totes les formes d'una entrada.</param> /// <param name="regles">Llista de regles en vigor, per si està definit mesRegles</param> /// <param name="filtre">Només es generen mots que tenen marques contingudes en aquest filtre.</param> /// <param name="nomesAfixos">Si és true, només s'apliquen les regles amb la propietat EsAfix = true.</param> /// <returns>El nombre de mots afegits.</returns> public int Genera(string arrel, ref List<Mot> mots, MorfoGram infoComuna, Regles regles, Marques filtre, bool nomesAfixos) { if ((suprimir > arrel.Length) || (condicio != null && !condicio.IsMatch(arrel)) || !filtre.Conte(Marca)) return 0; int afegits = 0; string forma; if (sufix) forma = arrel.Substring(0, arrel.Length - suprimir) + afegir; else forma = afegir + arrel.Substring(suprimir); Mot motBase = new Mot(forma, this, infoComuna); mots.Add(motBase); afegits += 1; if (mesRegles != null) foreach (string idRegla in mesRegles) { Regla regla = regles.Llista[idRegla]; if (nomesAfixos && !regla.EsAfix) continue; List<Mot> nous = regla.Genera(forma, motBase.Info, regles, filtre, nomesAfixos); if (mesRegles.Count > 1) { foreach (string idRegla2 in mesRegles) { if (idRegla == idRegla2) continue; Regla regla2 = regles.Llista[idRegla2]; if (nomesAfixos && !regla2.EsAfix) continue; List<Mot> nous2; foreach (Mot mot in nous) { nous2 = regla2.Genera(mot.Forma, mot.Info, regles, filtre, nomesAfixos); mots.AddRange(nous2); afegits += nous2.Count; } } } mots.AddRange(nous); afegits += nous.Count; } return afegits; }
/// <summary> /// Crea un objecte Regles a partir d'un fitxer .aff. /// Tots els casos es fan pertanyents al grup 000 ("Sense condicions"). /// </summary> /// <param name="nomFitxer">El fitxe .aff.</param> /// <returns>Un objecte Regles.</returns> public static Regles LlegeixAff(string nomFitxer) { StreamReader ent = new StreamReader(nomFitxer, Encoding.Default); MemoryStream mem = new MemoryStream(); StreamWriter sort = new StreamWriter(mem, Encoding.Default); sort.WriteLine("GRUPS"); sort.WriteLine("000 Sense condicions"); sort.WriteLine("/GRUPS"); Regex rePartsRegla = null; int casosRegla = 0; Match match; while (!ent.EndOfStream) { string linia = ent.ReadLine(); if (linia.Length == 0 || linia.StartsWith("#")) continue; if (linia.StartsWith("SET ") || linia.StartsWith("TRY ") || linia.StartsWith("WORDCHARS ")) { sort.WriteLine(linia); sort.WriteLine(); } else if (linia.StartsWith("REP ")) { string[] trossos = linia.Split(' '); if (trossos.Length == 3) sort.WriteLine(string.Format("FIRST {0}/{1}", trossos[1], trossos[2])); } else if (linia.StartsWith("PFX ") || linia.StartsWith("SFX ")) { if (casosRegla > 0 && (match = rePartsRegla.Match(linia)).Success) { sort.WriteLine(string.Format("000 {0} {1} {2}", match.Groups[1].Value, match.Groups[2].Value, match.Groups[3].Value)); --casosRegla; if (casosRegla == 0) sort.WriteLine("/REGLA"); } else if ((match = reIniciRegla.Match(linia)).Success) { rePartsRegla = new Regex(string.Format(@"^{0}\s+{1}\s+(\S+)\s+(\S+)\s+(\S+)", match.Groups[1].Value, match.Groups[2].Value)); casosRegla = int.Parse(match.Groups[4].Value); sort.WriteLine(); sort.WriteLine(string.Format("REGLA {0} {1}{2} Regla {3}", match.Groups[2].Value, match.Groups[1].Value, match.Groups[3].Value == "Y" ? "+" : "", match.Groups[2].Value)); } } else throw new Exception("No sé què fer amb " + linia); } ent.Close(); sort.Flush(); //mem.Seek(0, SeekOrigin.Begin); //mem.WriteTo((new StreamWriter(@"..\..\resultats\prova2.txt", false, Encoding.Default)).BaseStream); mem.Seek(0, SeekOrigin.Begin); StreamReader fitxer = new StreamReader(mem, Encoding.Default); Regles regles = new Regles(); regles.Llegeix(fitxer, nomFitxer, new Marques(true)); fitxer.Close(); return regles; }
/// <summary> /// Genera la línia corresponent a aquest cas per al fitxer .aff. /// </summary> /// <param name="regla">La regla de la qual forma part aquest cas.</param> /// <param name="nouId">L'identificador que farem servir per als casos.</param> /// <param name="regles">Les regles en vigor (per als flags "twofold")</param> /// <returns>Una línia per al fitxer .aff.</returns> public string GeneraAff(Regla regla, string nouId, Regles regles) { StringBuilder sb = new StringBuilder(); sb.AppendFormat("{0}FX {1} {2} {3}", sufix ? "S" : "P", nouId, sSuprimir, afegir); if (mesRegles != null) { sb.Append("/"); foreach (string id in mesRegles) sb.Append(regles.Llista[id].IdCombinable); } sb.AppendFormat(" {0}", sCondicio); return sb.ToString(); }
private Regles AMyspell(string nomFitxer, List<ItemDic> itemsVells, Marques filtre, Comparison<string> comparador, GetAfinaReglaMyspell afinaRegla) { Regles novesRegles = new Regles(); novesRegles.regles = new Dictionary<string, Regla>(); novesRegles.marques = new Dictionary<string, Marca>(marques); novesRegles.descripcio = new List<string>(descripcio); novesRegles.set = set; novesRegles.caracters = caracters; novesRegles.rep = rep; char nomNou = '1'; char nomNouInv = 'a'; Dictionary<string, List<ReglaMyspell>> vellANou = new Dictionary<string, List<ReglaMyspell>>(); foreach (KeyValuePair<string, Regla> kvReglaVella in regles) { string idReglaVella = kvReglaVella.Key; Regla reglaVella = kvReglaVella.Value; vellANou.Add(idReglaVella, new List<ReglaMyspell>()); List<ReglaMyspell> reglesMyspell = reglaVella.GrupsMyspell(this, filtre, afinaRegla); int maxCasos = 0; ReglaMyspell millorRegla = null; foreach (ReglaMyspell regla in reglesMyspell) if (regla.EsRegla && regla.NCasos > maxCasos) { maxCasos = regla.NCasos; millorRegla = regla; } foreach (ReglaMyspell regla in reglesMyspell) { string id; string desc; if (regla == millorRegla) { id = reglaVella.Id; desc = reglaVella.Descripcio; } else { desc = string.Format("Part de la regla {0} ({1})", reglaVella.Id, reglaVella.Descripcio); if (regla.EsRegla) { id = nomNou.ToString(); ++nomNou; } else { id = nomNouInv.ToString(); ++nomNouInv; } } regla.Descripcio = desc; regla.Id = id; vellANou[idReglaVella].Add(regla); if (regla.EsRegla) novesRegles.regles[id] = regla.Regla; } } List<ItemDic> itemsNous = new List<ItemDic>(); Dictionary<string, List<CreaDicMyspell>> creadors = new Dictionary<string, List<CreaDicMyspell>>(); foreach (ItemDic itemVell in itemsVells) { string flags = itemVell.FlagsComLletres; if (!creadors.ContainsKey(flags)) creadors.Add(flags, CreaDicMyspell.GeneraCreadors(itemVell, vellANou, novesRegles)); foreach (CreaDicMyspell creador in creadors[flags]) { ItemDic itemNou = creador.Converteix(itemVell); if (itemNou != null) itemsNous.Add(itemNou); } } // Unim tots els ítems que comparteixen la mateixa arrel // Ho feim per una limitació de MySpell, que no permet arrels repetides, // a diferència d'Hunspell. itemsNous = ItemDic.CompactaLlista(itemsNous, comparador); StreamWriter sw = new StreamWriter(nomFitxer + ".dic", false, Encoding.Default); sw.WriteLine(itemsNous.Count); foreach (ItemDic item in itemsNous) sw.WriteLine(item.ToString()); sw.Close(); return novesRegles; }
public CreaDicMyspellCas(CasRegla cas, Regles regles) { this.cas = cas; this.regles = regles; }
public CreaDicMyspellRegla(Regles regles) { this.regles = regles; }
/// <summary> /// Crea amb unes regles. /// </summary> /// <param name="regles">Les regles aplicables a una llista tipus DIEC.</param> public IdentificadorGentilicis(string desc, Regles regles, string fitxerExcepcions) : base(desc, regles, fitxerExcepcions) { }
/// <summary> /// Llegeix un fitxer com el generat pel web de tractament de propostes. /// Conté entrades en diversos formats: DIEC, topònims, antropònims, etc. /// </summary> private void LlegeixEntradesWeb(int mod, List<string> log, DateTime horaInici, Regles regles, List<Identificador> identificadors, List<Entrada> entrades) { var idDiec = new IdentificadorDIEC("web", regles, null); var idToponims = new IdentificadorToponims("web", regles); var idAntroponims = new IdentificadorAntroponims("web", regles, null); var idDiversos = new IdentificadorDiversos("web", regles); AfegeixLiniaLog("Llegeix les propostes del web", horaInici, log); var sr = new StreamReader(DirEntrades("web.txt"), Encoding.Default); var linies = new List<string>(); while (!sr.EndOfStream) linies.Add(sr.ReadLine()); var temp = DirEntrades("_part_web.txt"); // llista de topònims linies = TriaLinies(linies, temp, delegate(string lin) { Match m; if ((m = reTopo.Match(lin)).Success) return m.Groups["nom"].Value; else return ""; }); idToponims.LlegeixEntrades(temp, entrades, mod); // llista d'antropònims linies = TriaLinies(linies, temp, delegate(string lin) { Match m; if ((m = reAntro.Match(lin)).Success) { if (m.Groups["gen"].Value == "m") return m.Groups["nom"].Value; else { var nom = m.Groups["nom"].Value; var p = new Paraula(nom); return string.Format("{0}{1}", nom, p.PotApostrofar(true) ? " f" : ""); } } else return ""; }); idAntroponims.LlegeixEntrades(temp, entrades, mod); // llista de diversos linies = TriaLinies(linies, temp, delegate(string lin) { Match m; if ((m = reDivers.Match(lin)).Success) return m.Groups["nom"].Value; else return ""; }); idDiversos.LlegeixEntrades(temp, entrades, mod); // la resta, té el format DIEC TriaLinies(linies, temp, lin => lin); idDiec.LlegeixEntrades(temp, entrades, mod); if (File.Exists(temp)) File.Delete(temp); identificadors.Add(idToponims); identificadors.Add(idAntroponims); identificadors.Add(idDiversos); identificadors.Add(idDiec); }