/// <summary>
/// Crea un mot amb una forma, amb el cas de la regla que l'ha generat i amb informació morfològica
/// i gramatical.
/// La informació morfològica i gramatical del mot és la combinació de la informació provinent del
/// cas de la regla (casRegla) i la d'info.
/// </summary>
/// <param name="forma">La forma del mot.</param>
/// <param name="casRegla">El cas de la regla a partir del qual s'ha generat el mot.</param>
/// <param name="extra">Informació morfològica i gramatical que s'afegeix a la del cas de la regla.</param>
public Mot(string forma, CasRegla casRegla, MorfoGram extra)
{
this.forma = forma;
this.casRegla = casRegla;
this.extra = extra;
this.info = null;
}
private ItemDic(string arrel, uint[] flags, MorfoGram mgComuna, MorfoGram mgArrel)
{
this.arrel = arrel;
for (int i = 0; i < flags.Length; i++)
this.flags[i] = flags[i];
MesMorfoGram(mgComuna, mgArrel);
flagsComLletres = null;
}
/// <summary>
/// Crea un cas per a una regla.
/// </summary>
/// <param name="regla">La regla a la qual pertany aquest cas.</param>
/// <param name="suprimir">Els caràcters que s'han de suprimir. S'eliminen del principi
/// o del final, segons si és prefix o sufix. Si és "0", no se suprimeix res.</param>
/// <param name="afegir">El que s'ha d'afegir a l'arrel després de suprimir-ne caràcters, si cal.
/// Se suprimeix del principi o del final, segons si és prefix o sufix.</param>
/// <param name="condicio">La condició que ha de complir l'arrel perquè aquest cas sigui aplicable.</param>
/// <param name="sufix">Si és true, es modifica el començament de l'arrel. Si és false, es
/// modifica el final de l'arrel.</param>
/// <param name="marca">La marca dialectal associada a aquest cas.</param>
/// <param name="info">Informació morfològica i gramatical.</param>
/// <param name="mesRegles">Regles que es poden aplicar després d'haver aplicat aquest cas.
/// Correspon al "twofold" introduït per Hunspell.</param>
public CasRegla(Regla regla, string suprimir, string afegir, string condicio, bool sufix, Marca marca, MorfoGram info, List<string> mesRegles)
{
this.regla = regla;
this.sSuprimir = suprimir;
this.suprimir = (suprimir == "0") ? 0 : suprimir.Length;
this.afegir = afegir;
sCondicio = condicio;
if (condicio == ".")
this.condicio = null;
else if (sufix)
this.condicio = new Regex(condicio + "$");
else
this.condicio = new Regex("^" + condicio);
this.sufix = sufix;
this.marca = marca;
this.info = info;
if (mesRegles != null)
{
this.mesRegles = new List<string>(mesRegles);
this.mesRegles.Sort(string.Compare);
}
else
this.mesRegles = null;
}
/// <summary>
/// Crea sumant els valors de dos objectes MorfoGram.
/// Per als objectes inexistents, se suposa el valor NOCAT, NOTEMPS, etc.
/// Si els valors són incompatibles, es provoca una excepció.
/// </summary>
/// <param name="mf1">El primer MorfoGram</param>
/// <param name="mf2">El segon MorfoGram</param>
public MorfoGram(MorfoGram mf1, MorfoGram mf2)
{
if (mf1 == null && mf2 == null)
return;
if (mf1 == null || mf2 == null)
{
MorfoGram mfx = (mf1 != null) ? mf1 : mf2;
cat = mfx.Cat;
temps = mfx.Temps;
pers = mfx.Pers;
gen = mfx.Gen;
nbre = mfx.Nbre;
return;
}
if (Unificables(mf1, mf2))
{
cat = (mf1.Cat != eCat.NOCAT) ? mf1.Cat : mf2.Cat;
temps = (mf1.Temps != eTemps.NOTEMPS) ? mf1.Temps : mf2.Temps;
pers = (mf1.Pers != ePers.NOPERS) ? mf1.Pers : mf2.Pers;
gen = (mf1.Gen != eGen.NOGEN) ? mf1.Gen : mf2.Gen;
nbre = (mf1.Nbre != eNbre.NONBRE) ? mf1.Nbre : mf2.Nbre;
}
else
{
if ((mf1.Cat != eCat.NOCAT) && (mf2.Cat != eCat.NOCAT) && (mf1.Cat != mf2.Cat))
throw new Exception(String.Format("Categories incompatibles ({0}, {1})", mf1.ToString(), mf2.ToString()));
if ((mf1.Temps != eTemps.NOTEMPS) && (mf2.Temps != eTemps.NOTEMPS) && (mf1.Temps != mf2.Temps))
throw new Exception(String.Format("Temps incompatibles ({0}, {1})", mf1.ToString(), mf2.ToString()));
if ((mf1.Pers != ePers.NOPERS) && (mf2.Pers != ePers.NOPERS) && (mf1.Pers != mf2.Pers))
throw new Exception(String.Format("Persones incompatibles ({0}, {1})", mf1.ToString(), mf2.ToString()));
if ((mf1.Gen != eGen.NOGEN) && (mf2.Gen != eGen.NOGEN) && (mf1.Gen != mf2.Gen))
throw new Exception(String.Format("Gèneres incompatibles ({0}, {1})", mf1.ToString(), mf2.ToString()));
if ((mf1.Nbre != eNbre.NONBRE) && (mf2.Nbre != eNbre.NONBRE) && (mf1.Nbre != mf2.Nbre))
throw new Exception(String.Format("Categories incompatibles ({0}, {1})", mf1.ToString(), mf2.ToString()));
}
}
public PC_verb_ir(bool pur, bool inc)
: base(string.Format("Verb en -ir{0}{1}", pur ? ", pur" : "", inc ? ", incoatiu" : ""))
{
mgVerb = new MorfoGram(MorfoGram.eCat.VERB);
mgArrel = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.FUT, MorfoGram.ePers.P1);
this.pur = pur;
this.inc = inc;
}
private static void AgafaInfo(ref MorfoGram.eCat cat, ref MorfoGram.eTemps temps,
ref MorfoGram.eGen gen, ref MorfoGram.eNbre nbre, string nota)
{
Match match = reEtiInfo.Match(nota);
if (!match.Success)
return;
string etiqueta = match.Groups[1].Value;
if (etisInfo.ContainsKey(etiqueta))
{
MorfoGram info = etisInfo[etiqueta];
if (info.Cat != MorfoGram.eCat.NOCAT) cat = info.Cat;
if (info.Temps != MorfoGram.eTemps.NOTEMPS) temps = info.Temps;
if (info.Gen != MorfoGram.eGen.NOGEN) gen = info.Gen;
if (info.Nbre != MorfoGram.eNbre.NONBRE) nbre = info.Nbre;
}
else
throw new Exception("Etiqueta d'informació desconeguda: " + etiqueta);
}
/// <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 el paradigma per a paraules amb singular i plural.
/// </summary>
private ParadigmaCat Id2(string arrel, MorfoGram morfoGram, Dictionary<string, string> dades,
Dictionary<string, string> exc)
{
// PERFER: mirar "dijous"
bool admetArticle = (exc == null || !exc.ContainsKey("NOART"));
string arrel0, arrel1;
arrel0 = ParadigmaCat.Arrel0(arrel, out arrel1);
if (arrel1 != arrel0)
{
// PER_FER: unificar amb Precalc()
// Tenim una paraula amb trossos
PC_multi par = new PC_multi();
string[] trossos = arrel.Split(' ');
for (int i = 0; i < trossos.Length; i++)
{
if (trossos.Length == 0)
continue;
// PER_FER: la paraula pot tenir articles i preposicions
Paraula ptros = new Paraula(trossos[i]);
if (i == 0)
par.Add(new PC_formaFixada("Entrada amb espais, primer tros", morfoGram, ptros,
ptros.PotApostrofar(), ptros.PotApostrofar(morfoGram.Gen == MorfoGram.eGen.F)));
else
par.Add(new PC_formaFixada("Entrada amb espais, tros interior", morfoGram, ptros, false, false));
}
return par;
}
Paraula paraula = new Paraula(arrel0);
Debug.Assert(!paraula.Forma.Contains(" "), "No hi ha d'haver espais a l'arrel");
if (exc != null)
{
// suposam que el singular i el plural tenen el mateix valor de VocalInicial
string plural = Dades(exc, "PLU");
if (plural != null)
{
if (plural.Contains(" "))
{
// Hi ha més d'un plural
string[] trossos = plural.Split(' ');
PC_multi par = new PC_multi();
foreach (string tros in trossos)
par.Add(new PC_plural_precalc(morfoGram, paraula, tros, paraula.VocalInicial,
paraula.VocalInicial && admetArticle));
return par;
}
return new PC_plural_precalc(morfoGram, paraula,
plural, paraula.VocalInicial, paraula.VocalInicial && admetArticle);
}
}
string admet = String.Format("D{0}, L{1}", paraula.VocalInicial ? "+" : "-",
paraula.VocalInicial && admetArticle ? "+" : "-");
if (morfoGram.Cat == MorfoGram.eCat.ADJ)
{
string id = null;
if (paraula.VocalFinal && paraula.Aguda)
id = "A2T, -ns, " + admet;
else if (paraula.SxcFinal && paraula.Aguda)
id = "A2T, -os, " + admet;
else
id = "A2T, -s, " + admet;
return paradigmes[id];
}
else // (no és un adjectiu, ho tractam com un nom)
{
string id = null;
if (morfoGram.Gen == MorfoGram.eGen.F)
{
// exemples: mà, casa
if (paraula.VocalFinal && paraula.Aguda)
id = "NF, -ns, " + admet;
else if (paraula.SxcFinal && paraula.Aguda)
id = "NF, -s, " + admet;
// PERFER: comprovar que el plural de "falç" és "falçs"
else
id = "NF, -s, " + admet;
}
else // (la paraula és masculina o no té gènere)
{
// exemples: ca, moix, peu
if (paraula.VocalFinal && paraula.Aguda)
id = "NM, -ns, " + admet;
else if (paraula.SxcFinal && paraula.Aguda)
id = "NM, -os, " + admet;
else
id = "NM, -s, " + admet;
}
return paradigmes[id];
}
//throw new Exception("No sé què fer amb " + arrel);
}
private void test_04(GrupTest arrel)
{
GrupTest grup = arrel.NouGrup("Entrades i mots");
Regles regles = CarregaRegles(true);
Identificador idDIEC = new IdentificadorDIEC("*** buit ***", regles, null);
grup.NouTest("Entrades ignorades", delegate(RTest resultat)
{
Entrada entrada;
Regex trosseja = new Regex(@"\|\|");
string entrades = "ent=-adelf -adelfa||ent=ab-";
foreach (string tros in trosseja.Split(entrades))
{
entrada = idDIEC.IdentificaEntrada(tros);
resultat.Assert(entrada == null, "S'hauria d'ignorar \"{0}\"", tros);
}
});
grup.NouTest("Neteja d'entrades", delegate(RTest resultat)
{
Entrada entrada;
entrada = idDIEC.IdentificaEntrada("ent=a1^cat1=f.^com1=pl. as");
resultat.Esperat("a", entrada.Arrel);
entrada = idDIEC.IdentificaEntrada("ent=abaltir-se^cat1=v. pron.");
resultat.Esperat("abaltir", entrada.Arrel);
entrada = idDIEC.IdentificaEntrada("ent=abastador2 abastadora^cat1=m. i f.");
resultat.Esperat("abastador abastadora", entrada.Arrel);
});
grup.NouTest("Informació morfològica i gramatical", delegate(RTest resultat)
{
MorfoGram mf1 = new MorfoGram();
resultat.Esperat("ND", mf1.ToString());
MorfoGram mf2 = new MorfoGram(MorfoGram.eCat.NOM);
resultat.Esperat("NOM", mf2.ToString());
MorfoGram mf12 = new MorfoGram(mf1, mf2);
resultat.Esperat("NOM", mf12.ToString());
MorfoGram mf3 = new MorfoGram(MorfoGram.eCat.VERB);
try
{
MorfoGram mf23 = new MorfoGram(mf2, mf3);
resultat.Error("Error indetectat unint {0} i {1}", mf2, mf3);
}
catch (Exception exc)
{
resultat.Nota("Error esperat intentant unir {0} i {1} ({2})", mf2, mf3, exc.Message);
}
MorfoGram mf4 = new MorfoGram(MorfoGram.eCat.NOCAT, MorfoGram.eTemps.IPR, MorfoGram.ePers.P3);
resultat.Esperat("IPR.P3", mf4.ToString());
MorfoGram mf34 = new MorfoGram(mf3, mf4);
resultat.Esperat("VERB.IPR.P3", mf34.ToString());
});
}
public PC_plural_s(MorfoGram mgComuna, bool admetD, bool admetL, string desc)
: base("E", mgComuna, admetD, admetL, desc)
{
}
/// <summary>
/// Crea a partir del plural i amb informació d'apostrofació.
/// </summary>
/// <param name="mgComuna">Informació morfològica i gramatical comuna a totes les formes.</param>
/// <param name="singular">Paraula en singular</param>
/// <param name="plural">Plural precalculat.</param>
/// <param name="admetD">Totes les formes admeten la preposició "de" apostrofada.</param>
/// <param name="admetL">El singular admet l'article apostrofat.</param>
public PC_plural_precalc(MorfoGram mgComuna, Paraula singular, string plural, bool admetD, bool admetL)
: base(mgComuna.ToString() + " " /*+ singular + "/" + plural*/ + (admetD ? ", d'" : "") + (admetL ? ", l'" : ""))
{
this.mgComuna = mgComuna;
mgArrel = null;
this.singular = singular.Forma;
this.plural = plural;
// Interpretam la notació "abacà -às"
if (plural.StartsWith("-"))
this.plural = singular.PreTonica + plural.Substring(1);
// PERFER: mirar si és aplicable la regla 'E'
this.admetD = admetD;
this.admetL = admetL;
}
/// <summary>
/// Crea amb una categoria gramatical i informació sobre l'inici de la paraula.
/// </summary>
/// <param name="regla">La regla que aplicarem per al plural.</param>
/// <param name="mgComuna">La informació morfogramatical comuna a totes les formes.</param>
/// <param name="admetD">Admet "d'".</param>
/// <param name="admetL">Admet "l'".</param>
/// <param name="desc">Descripció del paradigma.</param>
protected PC_plural_EGI(string regla, MorfoGram mgComuna, bool admetD, bool admetL, string desc)
: base(desc)
{
this.regla = regla;
this.mgComuna = mgComuna;
mgArrel = new MorfoGram(MorfoGram.eNbre.SG);
this.admetD = admetD;
this.admetL = admetL;
}
/// <summary>
/// Crea a partir de la forma i amb informació d'apostrofació.
/// </summary>
/// <param name="desc">Descripció del paradigma.</param>
/// <param name="forma">La forma del nom.</param>
/// <param name="admetD">Admet la preposició "de" apostrofada.</param>
/// <param name="admetL">Admet l'article apostrofat.</param>
/// <param name="admetN">Admet l'article personal apostrofat</param>
public PC_nomPropi(string desc, MorfoGram mgComuna, bool admetD, bool admetL, bool admetN)
: base(desc)
{
this.mgComuna = mgComuna;
this.admetD = admetD;
this.admetL = admetL;
this.admetN = admetN;
}
/// <summary>
/// Crea amb una regla, informació morfogramatical i informació sobre apostrofació.
/// No funciona per a les paraules començades amb 'i' o 'u' àtones, ja que el femení i
/// el masculí no funcionen igual pel que fa a l'article.
/// </summary>
/// <param name="regla">La regla per generar formes a partir del masculí singular.</param>
/// <param name="mgComuna">Informació morfogramatical comuna a totes les formes.</param>
/// <param name="admetD">Les formes admeten "d'".</param>
/// <param name="admetL">Les formes admeten "l'".</param>
/// <param name="desc">Descripció del paradigma.</param>
public PC_MFSP(string regla, MorfoGram mgComuna, bool admetD, bool admetL, string desc)
: base(desc)
{
this.regla = regla;
this.mgComuna = mgComuna;
this.admetD = admetD;
this.admetL = admetL;
mgArrel = mgComuna | mgMascSg;
}
/// <summary>
/// Crea a partir de la forma i amb informació d'apostrofació.
/// </summary>
/// <param name="desc">Descripció del paradigma.</param>
/// <param name="mgComuna">Informació morfològica i gramatical comuna a totes les formes.</param>
/// <param name="paraula">La paraula.</param>
/// <param name="admetD">Totes les formes admeten la preposició "de" apostrofada.</param>
/// <param name="admetL">El singular admet l'article apostrofat.</param>
public PC_formaFixada(string desc, MorfoGram mgComuna, Paraula paraula, bool admetD, bool admetL)
: base(desc)
{
this.mgComuna = mgComuna;
mgArrel = null;
this.forma = paraula.Forma;
this.admetD = admetD;
this.admetL = admetL;
}
protected List<Mot> GeneraMots(List<ItemDic> items, MorfoGram filtreMG, Marques filtreMRQ, bool nomesAfixos)
{
List<Mot> tot = GeneraMots(items, filtreMRQ, nomesAfixos);
List<Mot> llista = tot.FindAll(delegate(Mot mot)
{
return MorfoGram.Unificables(mot.Info, filtreMG);
});
return llista;
}
/// <summary>
/// Crea copiant les dades d'un altre.
/// </summary>
/// <param name="mg">L'origen de les dades.</param>
public MorfoGram(MorfoGram mg)
: this(mg, null)
{
}
public PC_precalc(string forma, MorfoGram mg, params string[] flags)
: base(string.Format("precalc"/*@"""{0}"" x {{{1}}}"*/, forma, String.Join(", ", flags)))
{
this.forma = forma;
this.mg = mg;
this.flags = flags;
}
/// <summary>
/// Afegeix informació morfogramatical compartida per totes les formes generades
/// per aquest ítem.
/// </summary>
/// <param name="novaComuna">La informació nova per a mgComuna.</param>
/// <param name="novaArrel">La informació nova per a mgArrel.</param>
public void MesMorfoGram(MorfoGram novaComuna, MorfoGram novaArrel)
{
if (novaComuna != null)
{
if (mgCom == null)
mgCom = new MorfoGram();
mgCom |= novaComuna;
}
if (novaArrel != null)
{
if (mgArr == null)
mgArr = new MorfoGram();
mgArr |= novaArrel;
}
}
/// <summary>
/// Crea amb informació morfogramatical.
/// No admet a cap tros.
/// </summary>
/// <param name="mgComuna">Informació morfològica i gramatical comuna a totes les formes.</param>
public PC_trossos(MorfoGram mgComuna)
: base(mgComuna.ToString() + ", D-, L-")
{
this.mgComuna = mgComuna;
admetD = false;
admetL = false;
esLlista = false;
mgArrel = null;
}
private static Dictionary<string, ParadigmaCat> CreaParadigmes()
{
Dictionary<string, ParadigmaCat> llista = new Dictionary<string, ParadigmaCat>();
for (int tp = 1; tp <= 3; ++tp) // tipus de plural: -s, -ns o -os
{
string descTP = null;
switch (tp)
{
case 1:
descTP = "-s";
break;
case 2:
descTP = "-ns";
break;
case 3:
descTP = "-os";
break;
}
for (int cat = 1; cat <= 3; ++cat) // categoria: NM, NF, ADJ (2 terminacions)
{
string descCat = null;
MorfoGram mg = new MorfoGram();
switch (cat)
{
case 1:
descCat = "NM";
mg.Cat = MorfoGram.eCat.NOM;
mg.Gen = MorfoGram.eGen.M;
break;
case 2:
descCat = "NF";
mg.Cat = MorfoGram.eCat.NOM;
mg.Gen = MorfoGram.eGen.F;
break;
case 3:
descCat = "A2T";
mg.Cat = MorfoGram.eCat.ADJ;
break;
}
for (int admetD = 0; admetD <= 1; ++admetD)
for (int admetL = 0; admetL <= 1; ++admetL)
{
string desc = String.Format("{0}, {1}, D{2}, L{3}",
descCat, descTP,
admetD == 0 ? "-" : "+", admetL == 0 ? "-" : "+");
switch (tp)
{
case 1:
llista[desc] = new PC_plural_s(mg, admetD == 1, admetL == 1, desc);
break;
case 2:
llista[desc] = new PC_plural_ns(mg, admetD == 1, admetL == 1, desc);
break;
case 3:
llista[desc] = new PC_plural_os(mg, admetD == 1, admetL == 1, desc);
break;
}
}
}
}
//
llista["NPM"] = new PC_plural(true);
llista["NPF"] = new PC_plural(false);
//
llista["NSM"] = new PC_singular(true);
llista["NSF"] = new PC_singular(false);
//
llista["???"] = new PC_trossos(new MorfoGram());
llista["CONJ"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.CONJ));
llista["PREP"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.PREP));
llista["ART"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.ART));
llista["PRON, D-"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.PRON), false, false, true);
llista["PRON, D+"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.PRON), true, false, true);
llista["LOC PREP"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.LOCPREP));
llista["LOC ADJ"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.LOCADJ));
llista["LOC ADV"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.LOCADV));
llista["ADV, D-"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.ADV));
llista["ADV, D+"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.ADV), true, false, true);
llista["INTERJ"] = new PC_trossos(new MorfoGram(MorfoGram.eCat.INTERJ));
//
foreach (char ch in "FJBHKL")
{
string regla = ch.ToString();
for (int an = 0; an <= 1; ++an)
{
MorfoGram mg = new MorfoGram(an == 0 ? MorfoGram.eCat.ADJ : MorfoGram.eCat.NOM);
for (int admetD = 0; admetD <= 1; ++admetD)
for (int admetL = 0; admetL <= 1; ++admetL)
{
string desc = String.Format("{0}, MFSP, {1}, D{2}, L{3}",
an == 0 ? "A" : "N", regla,
admetD == 0 ? "-" : "+", admetL == 0 ? "-" : "+");
llista[desc] = new PC_MFSP(regla, mg, admetD == 1, admetL == 1, desc);
}
}
}
//
MorfoGram mgNomPropi = new MorfoGram(MorfoGram.eCat.NOMPR);
for (int admetD = 0; admetD <= 1; ++admetD)
for (int admetL = 0; admetL <= 1; ++admetL)
for (int admetN = 0; admetN <= 1; ++admetN)
{
string desc = String.Format("NP, D{0}, L{1}, N{2}",
admetD == 0 ? "-" : "+", admetL == 0 ? "-" : "+", admetN == 0 ? "-" : "+");
llista[desc] = new PC_nomPropi(desc, mgNomPropi, admetD == 1, admetL == 1, admetN == 1);
}
//
llista["V, -ar"] = new PC_verb_ar();
llista["V, -re"] = new PC_verb_re();
llista["V, -ir, P"] = new PC_verb_ir(true, false);
llista["V, -ir, I"] = new PC_verb_ir(false, true);
//
return llista;
}
/// <summary>
/// Crea amb informació morfogramatical.
/// </summary>
/// <param name="mgComuna">Informació morfològica i gramatical comuna a totes les formes.</param>
/// <param name="admetD">Admet "d'".</param>
/// <param name="admetL">Admet "l'".</param>
/// <param name="esLlista">Si els trossos són una llista. Si és true, admetD i admetL
/// afecten tots els trossos. Si és false, només afecten el primer tros.</param>
public PC_trossos(MorfoGram mgComuna, bool admetD, bool admetL, bool esLlista)
: base(mgComuna.ToString() + (admetD ? ", D+" : ", D-"))
{
this.mgComuna = mgComuna;
this.admetD = admetD;
this.admetL = admetL;
this.esLlista = esLlista;
mgArrel = null;
}
/// <summary>
/// Calcula el paradigma per a adjectius i masculins/femenins.
/// El resultat pot tenir dues terminacions (abacial), tres (feliç) o quatre (blanc).
/// </summary>
private ParadigmaCat Id4(string arrel, MorfoGram morfoGram, Dictionary<string, string> dades, Dictionary<string, string> exc)
{
bool admetArticle = (exc == null || !exc.ContainsKey("NOART"));
string fem;
string masc = ParadigmaCat.Arrel0(arrel, out fem);
if (exc != null && exc.ContainsKey("PLU") && exc["PLU"].Contains(" "))
{
string[] trossos = exc["PLU"].Split(' ');
if (trossos.Length != 2) throw new Exception("S'esperaven dos trossos: " + exc["PLU"]);
Dictionary<string, string> exc2 = new Dictionary<string, string>(exc);
exc2["PLU"] = trossos[0];
ParadigmaCat parMasc = Id2(masc, morfoGram | mgMasc, dades, exc2);
exc2["PLU"] = trossos[1];
ParadigmaCat parFem = Id2(fem, morfoGram | mgFem, dades, exc2);
return new PC_multi(parMasc, parFem);
}
if (fem == masc)
{
// Si hi ha una forma, vol dir que és igual per al masculí i el femení, almenys en singular
ParadigmaCat par = Id2(arrel, morfoGram, dades, exc);
if (arrel.EndsWith("ç"))
{
// Si termina en 'ç', hi ha dues formes per al plural
PC_multi pars = new PC_multi(par);
Paraula fpl = new Paraula(arrel.Substring(0, arrel.Length - 1) + "ces");
pars.Add(new PC_formaFixada("plural en -ces", new MorfoGram(morfoGram.Cat, MorfoGram.eGen.F, MorfoGram.eNbre.PL),
fpl, fpl.VocalInicial, false));
return pars;
}
else
return par;
}
else // (fem != null)
{
Paraula pMasc = new Paraula(masc);
foreach (char id in "FJBHKL")
{
if (id == 'H' && (!pMasc.Aguda || !pMasc.VocalFinal))
continue;
Regla regla = regles.Llista[id.ToString()];
List<Mot> femenins = regla.Genera(masc, mgFemSg, regles, Marques.totes, true);
if (femenins.Count == 0)
continue;
if (femenins.Exists(delegate(Mot mot) { return mot.Forma == fem; }))
{
string idPar = String.Format("{0}, MFSP, {1}, D{2}, L{3}",
morfoGram.Cat == MorfoGram.eCat.ADJ ? "A" : "N",
id.ToString(),
pMasc.VocalInicial ? "+" : "-",
pMasc.VocalInicial && admetArticle ? "+" : "-");
ParadigmaCat par = paradigmes[idPar];
Paraula pFem = new Paraula(fem);
if (pFem.PotApostrofar(true)&& admetArticle)
{
MorfoGram mgFS = new MorfoGram(mgFemSg);
mgFS.Cat = morfoGram.Cat;
par = new PC_multi(par, new PC_formaFixada("femení singular, D+, L+", mgFS, pFem, true, true));
// PERFER: No hauríem d'admetre "d'" ja que està inclòs dins l'altre paradigma
}
return par;
}
}
return new PC_multi(Id2(masc, mgMascSg, dades, exc), Id2(fem, mgFemSg, dades, exc));
}
}
/// <summary>
/// Afegeix un participi a la llista d'ítems.
/// Si comença per vocal, li afegeix el flag que permet "d'" i el que permet "l'".
/// Si comença per vocal, crida AfegeixParFemSg per si la forma femenina singular també pot dur l'article
/// apostrofat.
/// </summary>
protected void AfegeixParticipi(List<ItemDic> items, string mascSg, MorfoGram mgComuna, MorfoGram mgArrel,
Marques filtre, params string[] flags)
{
AfegeixItem(items, mascSg, mgComuna, mgArrel, flags);
if (Paraula.TeVocalInicial(mascSg))
{
AfegeixItem(items, mascSg, mgComuna, mgArrel, "V", "Y");
AfegeixParFemSg(items, mascSg, filtre);
}
}
/// <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;
}
public static int Cmp(MorfoGram mf1, MorfoGram mf2)
{
if ((mf1 == null) && (mf2 == null)) return 0;
if (mf1 == null) return -1;
if (mf2 == null) return 1;
if (mf1.Cat != mf2.Cat) return (int)mf1.Cat - (int)mf2.Cat;
if (mf1.Temps != mf2.Temps) return (int)mf1.Temps - (int)mf2.Temps;
if (mf1.Pers != mf2.Pers) return (int)mf1.Pers - (int)mf2.Pers;
if (mf1.Gen != mf2.Gen) return (int)mf1.Gen - (int)mf2.Gen;
if (mf1.Nbre != mf2.Nbre) return (int)mf1.Nbre - (int)mf2.Nbre;
return 0;
}
private static Dictionary<string, MorfoGram> creaEtisInfo()
{
Dictionary<string, MorfoGram> etis = new Dictionary<string, MorfoGram>();
// flexió nominal
etis["PLU"] = new MorfoGram(MorfoGram.eCat.NOCAT, MorfoGram.eNbre.PL);
etis["FEM"] = new MorfoGram(MorfoGram.eCat.NOCAT, MorfoGram.eGen.F, MorfoGram.eNbre.SG);
etis["MPL"] = new MorfoGram(MorfoGram.eCat.NOCAT, MorfoGram.eGen.M, MorfoGram.eNbre.PL);
etis["FPL"] = new MorfoGram(MorfoGram.eCat.NOCAT, MorfoGram.eGen.F, MorfoGram.eNbre.PL);
// flexió verbal
etis["INF"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.INF);
etis["GER"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.GER);
etis["PAR"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.PAR);
etis["IPR"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.IPR);
etis["IIM"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.IIM);
etis["IPE"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.IPE);
etis["FUT"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.FUT);
etis["CON"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.CON);
etis["SPR"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.SPR);
etis["SIM"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.SIM);
etis["IMP"] = new MorfoGram(MorfoGram.eCat.VERB, MorfoGram.eTemps.IMP);
return etis;
}
/// <summary>
/// Diu si dos conjunts de trets són unificables.
/// Un valor és unificable amb ell mateix i amb el valor NOXXX
/// </summary>
/// <param name="mf1">Un primer conjunt de trets.</param>
/// <param name="mf2">Un segon conjunt de trets.</param>
/// <returns>True si els dos conjunts són unificables.</returns>
public static bool Unificables(MorfoGram mf1, MorfoGram mf2)
{
if (mf1 == null || mf2 == null)
return true;
if ((mf1.Cat != eCat.NOCAT) && (mf2.Cat != eCat.NOCAT) && (mf1.Cat != mf2.Cat))
return false;
if ((mf1.Temps != eTemps.NOTEMPS) && (mf2.Temps != eTemps.NOTEMPS) && (mf1.Temps != mf2.Temps))
return false;
if ((mf1.Pers != ePers.NOPERS) && (mf2.Pers != ePers.NOPERS) && (mf1.Pers != mf2.Pers))
return false;
if ((mf1.Gen != eGen.NOGEN) && (mf2.Gen != eGen.NOGEN) && (mf1.Gen != mf2.Gen))
return false;
if ((mf1.Nbre != eNbre.NONBRE) && (mf2.Nbre != eNbre.NONBRE) && (mf1.Nbre != mf2.Nbre))
return false;
return true;
}
private static Dictionary<string, MorfoGram> CreaTaulaTP()
{
Dictionary<string, MorfoGram> taula = new Dictionary<string,MorfoGram>();
taula.Add("INF0", new MorfoGram(eCat.VERB, eTemps.INF));
taula.Add("GER0", new MorfoGram(eCat.VERB, eTemps.GER));
taula.Add("PAR0", new MorfoGram(eCat.VERB, eTemps.PAR, ePers.NOPERS, eGen.M, eNbre.SG));
taula.Add("PAR1", new MorfoGram(eCat.VERB, eTemps.PAR, ePers.NOPERS, eGen.M, eNbre.SG));
taula.Add("PAR2", new MorfoGram(eCat.VERB, eTemps.PAR, ePers.NOPERS, eGen.M, eNbre.PL));
taula.Add("PAR3", new MorfoGram(eCat.VERB, eTemps.PAR, ePers.NOPERS, eGen.F, eNbre.SG));
taula.Add("PAR4", new MorfoGram(eCat.VERB, eTemps.PAR, ePers.NOPERS, eGen.F, eNbre.PL));
for (eTemps temps = eTemps.IPR; temps <= eTemps.IMP; ++temps)
{
int primera = ((temps == eTemps.IMP) ? 2 : 1);
for (int p = primera; p <= 6; p++)
{
string id = string.Format("{0}{1}", temps, p);
MorfoGram mg = new MorfoGram(eCat.VERB, temps, (ePers)p);
taula.Add(id, mg);
}
}
return taula;
}
protected void AfegeixItem(List<ItemDic> llista, string arrel, MorfoGram mgComuna, MorfoGram mgArrel,
params string[] flags)
{
ItemDic item = llista.Find(delegate(ItemDic i) {
return (i.Arrel == arrel) && MorfoGram.Unificables(i.mgComuna, mgComuna) && MorfoGram.Unificables(i.mgArrel, mgArrel);
});
if (item == null)
{
item = new ItemDic(arrel, flags);
llista.Add(item);
}
else
item.MesFlags(flags);
item.MesMorfoGram(mgComuna, mgArrel);
}
