public void Nou(string str, Marques marques, Marques excepte)
{
totes.Mes(marques);
if ((object)excepte != null)
totes.Mes(excepte);
cont.Nou(str, marques, excepte);
}
private void testParaules(RTest resultat, Identificador idPar, Marques filtre, params string[] paraules)
{
List<Entrada> entrades = new List<Entrada>();
List<string> notes = new List<string>();
foreach (string paraula in paraules)
{
string infoParaula = paraula;
string[] esperat = null;
int posFletxa = paraula.IndexOf(" > ");
if (posFletxa >= 0)
{
infoParaula = paraula.Substring(0, posFletxa);
esperat = paraula.Substring(posFletxa + 3).Split(' ');
}
Entrada entrada = idPar.IdentificaEntrada(infoParaula);
entrades.Add(entrada);
string llista = Mot.LlistaPlana(entrada.GeneraMots(filtre, false), Cat.Cmp, true);
bool ok = true;
if (esperat != null)
foreach (string esp in esperat)
if (!(llista + " ").Contains(esp + " "))
{
notes.Add(string.Format("No s'ha generat {0} ({1})", esp, entrada.Arrel));
ok = false;
}
resultat.Nota("{0}: {1}", entrada.Ent, ok ? "OK" : "ERROR");
}
if (notes.Count > 0)
{
resultat.Assert(false, "Hi ha {0} error{1}", notes.Count, notes.Count == 1 ? "" : "s");
foreach (string nota in notes)
resultat.Nota(nota);
}
}
public override List<ItemDic> GeneraDic(Dictionary<string, string> dades,
Dictionary<string, string> excepcions, Marques filtre, Entrada.Speller speller)
{
List<ItemDic> llista = new List<ItemDic>();
llista.Add(new ItemDic(dades["arrel"]));
return llista;
}
/// <summary>
/// Crea una entrada, amb una arrel, un paradigma i informació extra.
/// La informació extra es pot referir a excepcions, origen de la paraula, etc.
/// Per defecte, les entrades tenen la marca '000'.
/// </summary>
/// <param name="identificador">L'objecte que identifica el paradigma al qual pertany l'entrada.</param>
/// <param name="dades">Informació sobre l'entrada</param>
public Entrada(Identificador identificador, Dictionary<string, string> dades)
{
this.dades = dades;
this.excepcions = null;
this.identificador = identificador;
marques = null;
}
private VersioDiccionari(string nom, string desc, string variant, Marques filtre)
{
this.nom = nom;
this.desc = desc;
this.variant = variant;
this.filtre = filtre;
extra = new Dictionary<string, string>();
}
/// <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;
}
/// <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;
}
private void CreaFitxerAff(string nomFitxer, Marques filtre)
{
string[] ids = new string[regles.Count];
regles.Keys.CopyTo(ids, 0);
Array.Sort(ids);
StreamWriter sw = new StreamWriter(nomFitxer + ".aff", false, Encoding.Default);
foreach (string str in descripcio)
sw.WriteLine("# " + str);
sw.WriteLine();
sw.WriteLine("# Regles:");
foreach (string id in ids)
{
Regla regla = regles[id];
sw.WriteLine(string.Format("# {0} {1}{2}", regla.Id, regla.ToString(),
regla.CalCombinable ? string.Format(" ({0}, versió combinable)", regla.IdCombinable) : ""));
}
sw.WriteLine();
sw.WriteLine("SET {0}", set);
sw.WriteLine();
sw.WriteLine("WORDCHARS {0}", wordchars);
sw.WriteLine();
sw.WriteLine("TRY {0}", caracters);
if (rep.Count > 0)
{
sw.WriteLine();
sw.WriteLine("REP {0}", rep.Count);
foreach (string r in rep)
sw.WriteLine("REP {0}", r);
}
foreach (string id in ids)
{
Regla regla = regles[id];
sw.WriteLine();
string[] liniesAff = regla.GeneraAff(filtre, this);
foreach (string linia in liniesAff)
sw.WriteLine(linia);
if (regla.CalCombinable)
{
sw.WriteLine();
liniesAff = regla.GeneraAff(filtre, regla.IdCombinable, true, this);
foreach (string linia in liniesAff)
sw.WriteLine(linia);
}
}
sw.Close();
}
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 void Nou(string str, Marques marques, Marques excepte)
{
if (trossos.Count > 0)
{
TrosMarques darrer = trossos[trossos.Count - 1];
if (darrer.Marques == marques && (object) darrer.Excepte == (object) excepte)
{
trossos[trossos.Count - 1].NouStr(str);
return;
}
}
TrosMarques nou = new TrosMarques(str, marques, excepte);
trossos.Add(nou);
}
/// <summary>
/// Llegeix d'un stream obert.
/// </summary>
/// <param name="lector">L'stream d'on llegirem les regles.</param>
/// <param name="nomFitxer">El nom del fitxer de regles.</param>
/// <param name="filtre">Les marques que admetem. Els casos de les regles que no passin
/// el filtre es rebutgen.</param>
private void Llegeix(StreamReader lector, string nomFitxer, Marques filtre)
{
regles = new Dictionary<string, Regla>();
marques = new Dictionary<string, Marca>();
descripcio = new List<string>();
caracters = null;
wordchars = null;
rep = new List<string>();
set = null;
Regla regla = null; // la regla que estam llegint
int numLinia = 0;
Llegint estat = Llegint.IGNORA;
while (!lector.EndOfStream)
{
string liniaBruta = lector.ReadLine();
string linia = liniaBruta.Trim();
++numLinia;
if (linia.Length == 0 || linia.StartsWith("//"))
continue;
switch (estat)
{
case Llegint.IGNORA:
if (linia.StartsWith("DESC"))
estat = Llegint.DESC;
else if (linia.StartsWith("GRUPS"))
estat = Llegint.GRUPS;
else if (linia.StartsWith("REGLA"))
{
regla = Regla.Crea(linia);
regles[regla.Id] = regla;
estat = Llegint.REGLA;
}
else if (linia.StartsWith("SET"))
set = ContingutLinia(linia);
else if (linia.StartsWith("WORDCHARS"))
wordchars = ContingutLinia(linia);
else if (linia.StartsWith("TRY"))
caracters = ContingutLinia(linia);
else if (linia.StartsWith("FIRST"))
NouFirst(ContingutLinia(linia));
break;
case Llegint.DESC:
if (linia.StartsWith("/DESC"))
estat = Llegint.IGNORA;
else
descripcio.Add(liniaBruta);
break;
case Llegint.GRUPS:
if (linia.StartsWith("/GRUPS"))
estat = Llegint.IGNORA;
else
{
Match match = PartsGrup.Match(linia);
if (match.Success)
{
String id = match.Groups[1].Value;
String desc = match.Groups[2].Value;
marques[id] = Marca.Crea(id, desc);
}
else
throw new Exception(String.Format("Error llegint marques dialectals: {0} [{1}.{2}]", linia, nomFitxer, numLinia));
}
break;
case Llegint.REGLA:
if (linia.StartsWith("/REGLA"))
estat = Llegint.IGNORA;
else
{
CasRegla cas = CasRegla.Crea(linia, regla, marques);
if (filtre.Conte(cas.Marca))
regla.NouCas(cas);
}
break;
default:
throw new Exception(String.Format("No sé que fer amb l'estat {0}", estat));
}
}
foreach (KeyValuePair<string, Regla> sr in regles)
sr.Value.CalculaCalCombinable(this);
if (estat != Llegint.IGNORA)
throw new Exception(String.Format("Error llegint regles, estat final = {0}", estat.ToString()));
}
public TrosMarques(string cont, Marques marques, Marques excepte)
{
this.cont = cont;
this.marques = new Marques(marques);
if ((object)excepte == null)
this.excepte = null;
else
this.excepte = new Marques(excepte);
}
public LiniaMarques()
{
cont = new TrossosMarques();
totes = new Marques(false);
}
/// <summary>
/// Torna el contingut com un diccionari de valors.
/// La línia té el format "A=xxx & B=yyy"
/// </summary>
/// <param name="filtre">Les marques que condicionen el contingut del diccionari.</param>
/// <returns>Un diccionari amb els identificadors i els valors.</returns>
public Dictionary<string, string> Valors(Marques filtre)
{
Dictionary<string, string> valors = new Dictionary<string, string>();
string linia = Valor(filtre);
foreach (string tros in separadorIrr.Split(linia))
{
string cv = tros.Trim();
if (cv.Length == 0)
continue;
Match match = clauIgualValor.Match(cv);
if (!match.Success)
throw new Exception(String.Format("S'esperava xxx=yyy (llegit: \"{0}\")", cv));
valors[match.Groups[1].Value] = match.Groups[2].Value;
}
return valors;
}
/// <summary>
/// Llegeix un fitxer de regles.
/// </summary>
/// <param name="nomFitxer">El nom del fitxer amb les regles.</param>
public Regles(string nomFitxer)
{
StreamReader fitxer = new StreamReader(nomFitxer, Encoding.Default);
Marques filtre = new Marques(true);
Llegeix(fitxer, nomFitxer, filtre);
fitxer.Close();
}
/// <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>
/// 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 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;
}
public override List<Mot> GeneraMots(Entrada entrada, Marques filtre, bool nomesAfixos)
{
List<Mot> llista = new List<Mot>();
llista.Add(new Mot(entrada.Arrel, null, null));
return llista;
}
/// <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> /// Torna el contingut en funció de les marques. /// </summary> public abstract string Cont(Marques marques);
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;
}
public override string Cont(Marques filtre)
{
if (filtre.Conte(marques) && ((object)excepte == null || !filtre.Conte(excepte)))
return cont;
else
return null;
}
/// <summary>
/// Genera les línies d'un fitxer .dic a partir de la llista d'entrades.
/// No conté cap línia amb el nombre de línies.
/// Només s'inclouen les entrades que tenen totes les marques incloses dins filtre.
/// </summary>
/// <param name="entrades">Les entrades que ha de contenir el fitxer .dic.</param>
/// <param name="speller">El client per al qual generarem les línies .dic.</param>
/// <param name="comparador">La funció de comparació.</param>
/// <returns>Una llista de línies amb el format adequat, ordenada segons el comparador.</returns>
public static string[] GeneraLiniesDic(IEnumerable<Entrada> entrades, Marques filtre,
Speller speller, Comparison<string> comparador)
{
List<ItemDic> llista = Entrada.GeneraItemsDic(entrades, filtre, speller, comparador);
Entrada entrada0 = null;
foreach (Entrada ent in entrades)
{
entrada0 = ent;
break;
}
Regles regles = entrada0.Identificador.Regles;
Dictionary<string, List<ItemDic>> dic = new Dictionary<string, List<ItemDic>>();
List<ItemDic> llistaCompactada = new List<ItemDic>(llista.Count);
foreach (ItemDic id in llista)
{
bool crea = true, afegeix = true;
if (dic.ContainsKey(id.Arrel))
{
crea = false;
foreach(ItemDic item in dic[id.Arrel])
if (item.FlagsCompatibles(id, regles))
{
item.MesFlags(id);
afegeix = false;
}
}
if (afegeix)
{
if (crea)
dic[id.Arrel] = new List<ItemDic>();
dic[id.Arrel].Add(id);
llistaCompactada.Add(id);
}
}
llistaCompactada.Sort(delegate(ItemDic item1, ItemDic item2)
{
int cmp = comparador(item1.Arrel, item2.Arrel);
if (cmp != 0)
return cmp;
else
return String.Compare(item1.FlagsComLletres, item2.FlagsComLletres);
});
string[] linies = new string[llistaCompactada.Count];
for (int i = 0; i < llistaCompactada.Count; i++)
linies[i] = llistaCompactada[i].ToString();
return linies;
}
public override string Cont(Marques marques)
{
StringBuilder sb = new StringBuilder();
foreach (ContMarques tros in trossos)
{
string str = tros.Cont(marques);
if (str != null)
sb.Append(str);
}
return sb.ToString();
}
/// <summary>
/// Genera les línies d'un fitxer .dic per a una entrada.
/// </summary>
/// <param name="entrada">L'entrada a partir de la qual volem generar.</param>
/// <param name="identificador">Un identificador per als paradigmes.</param>
/// <param name="filtre">Les marques que volem incloure al resultat.</param>
/// <param name="speller">El client per al qual generarem les línies .dic.</param>
/// <param name="comparador">La funció de comparació.</param>
/// <returns>Una llista de línies amb el format adequat, ordenada segons el comparador.</returns>
public static string[] GeneraLiniesDic(Entrada entrada, Marques filtre,
Speller speller, Comparison<string> comparador)
{
List<Entrada> entrades = new List<Entrada>();
entrades.Add(entrada);
return GeneraLiniesDic(entrades, filtre, speller, comparador);
}
public void Nou(string str, Marques marques)
{
totes.Mes(marques);
cont.Nou(str, marques, null);
}
/// <summary>
/// Genera la llista de mots corresponent a aquesta entrada.
/// </summary>
/// <param name="filtre">Només es generen els mots que tenen marques contingudes en aquest filtre.</param>
/// <param name="nomesAfixos">Només s'apliquen les regles que afegeixen informació morfològica i gramatical.</param>
/// <returns>La llista dels mots generats.</returns>
public List<Mot> GeneraMots(Marques filtre, bool nomesAfixos)
{
List<ItemDic> items = Entrada.GeneraItemsDic(this, filtre, Speller.HUNSPELL, String.Compare);
return ItemDic.GeneraMots(items, filtre, identificador.Regles, nomesAfixos);
}
/// <summary>
/// Torna el valor de la línia, segons les marques actives.
/// </summary>
/// <param name="marques">Les marques que condicionen el contingut de la línia.</param>
/// <returns>Una línia depenent de les marques.</returns>
public string Valor(Marques filtre)
{
return cont.Cont(filtre);
}
private static void AplicaModel(Dictionary<string, string> dades, out Dictionary<string, string> excepcions,
string[] model, LiniaMarques lmExcepcions, Marques filtre)
{
dades["ent"] = AplicaModel(dades["ent"], model);
dades["arrel"] = AplicaModel(dades["arrel"], model);
List<string> originals = new List<string>();
for (int i = 1; i < model.Length; i += 2)
originals.Add(model[i]);
string oo = String.Join("|", originals.ToArray());
Regex cerca = new Regex(string.Format("(^|[=/ ])({0})", oo));
lmExcepcions = lmExcepcions.AplicaModel(cerca, model);
excepcions = lmExcepcions.Valors(filtre);
}
