public static List<ItemDic> GeneraItemsDic(IEnumerable<Entrada> entrades, Marques filtre,
Speller speller, Comparison<string> comparador)
{
List<ItemDic> llista = new List<ItemDic>();
Marques filtreExc = new Marques(filtre);
Dictionary<string, string> dades;
foreach (Entrada ent in entrades)
{
if (!filtre.Conte(ent.Marques))
continue;
List<ItemDic> ids = new List<ItemDic>();
Paradigma par = null;
if (ent.Excepcions == null)
{
par = ent.Identificador.IdentificaParadigma(ent.Dades, null);
ids.AddRange(par.GeneraDic(ent.Dades, null, filtre, speller));
llista.AddRange(ids);
}
else
{
for (int g = 1; g <= 2; g++)
{
Marca grup = (g == 1) ? Marca.grup1 : Marca.grup2;
if (!ent.Excepcions.Contingut.Conte(grup))
continue;
filtreExc.Menys(Marca.grups12);
filtreExc.Mes(grup);
Dictionary<string, string> excepcions = ent.Excepcions.Contingut.Valors(filtreExc);
dades = new Dictionary<string, string>(ent.Dades);
if (excepcions.ContainsKey("MODEL"))
{
string[] model = excepcions["MODEL"].Split('/');
if (excepcions.Count == 1)
AplicaModel(dades, out excepcions, model, ent.Identificador.Excepcio(model[0]).Contingut, filtreExc);
else
{
// A part del model, hi ha més dades
Dictionary<string, string> excepcionsOriginals = new Dictionary<string,string>(excepcions);
AplicaModel(dades, out excepcions, model, ent.Identificador.Excepcio(model[0]).Contingut, filtreExc);
foreach (KeyValuePair<string, string> kv in excepcionsOriginals)
excepcions[kv.Key] = kv.Value;
}
}
if (excepcions.ContainsKey("IGNORA")) // sempre deu ser IGNORA=1
continue;
if (excepcions.ContainsKey("ALT"))
dades["arrel"] = excepcions["ALT"];
if (excepcions.ContainsKey("NOVACAT"))
dades["cat1"] = excepcions["NOVACAT"];
par = ent.Identificador.IdentificaParadigma(dades, excepcions);
ids.AddRange(par.GeneraDic(dades, excepcions, filtre, speller));
}
llista.AddRange(ids);
}
foreach (ItemDic id in ids)
{
id.Entrada = ent;
if (id.Paradigma == null)
id.Paradigma = par;
}
}
llista.Sort(delegate(ItemDic id1, ItemDic id2)
{
return comparador(id1.Arrel, id2.Arrel);
});
return llista;
}
/// <summary>
/// Interpreta una línia d'excepcions i crea una LiniaMarques.
/// </summary>
public static LiniaMarques LlegeixLiniaExc(string linia)
{
LiniaMarques lm = new LiniaMarques();
Marques mm = new Marques(false, Marca.grup1);
Marques excepte = new Marques(false);
int iniTros = 0;
int midaTros;
foreach (Match match in condicions.Matches(linia))
{
midaTros = match.Index - iniTros;
if (midaTros > 0)
lm.Nou(linia.Substring(iniTros, midaTros), mm, excepte.Buit ? null : excepte);
if (match.Groups[2].Value == "<<")
{
string grup = match.Groups[3].Value;
if (grup == "EXT")
{
lm.PosaMarca(Marca.grup1);
mm.Menys(Marca.grup1);
mm.Mes(Marca.grup2);
}
else
{
if (grup.StartsWith("!"))
excepte.Mes(Marca.Una(grup.Substring(1)));
else
mm.Mes(Marca.Una(grup));
}
}
else if (match.Groups[6].Value == ">>")
{
string grup = match.Groups[5].Value;
if (grup == "EXT")
{
mm.Menys(Marca.grup2);
mm.Mes(Marca.grup1);
// PERFER: mirar si hi pot haver més de dos grups
}
else
{
if (grup.StartsWith("!"))
excepte.Menys(Marca.Una(grup.Substring(1)));
else
mm.Menys(Marca.Una(grup));
}
}
iniTros = match.Index + match.Length;
}
return lm;
}
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'");
});
}