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