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