public static string ConjugateNameVerbToPastParticiple(string name)
{
ConjugatedVerb conjugations = ConjugatedVerbs.FirstOrDefault(cv => cv.VerbVariations.Any(variation => name.IndexOf(variation, StringComparison.CurrentCultureIgnoreCase) != -1));
if (conjugations == null)
{
return(name);
}
// verb past participle
if (name.IndexOf(conjugations.PastParticipleVerb, StringComparison.CurrentCultureIgnoreCase) != -1)
{
return(name);
}
// verb
int index = name.IndexOf(conjugations.Verb, StringComparison.CurrentCultureIgnoreCase);
if (index != -1)
{
return(conjugations.PastParticipleVerb.Substring(0, 1).ToUpper() + conjugations.PastParticipleVerb.Substring(1).ToLower() + "By");
}
return(name);
}
// Renvoie true si les deux mots entrés en paramètre sont accordés, sinon false.
public static bool SontAccordes(VariableWord motVariable, ConjugatedVerb verbeConjugue)
{
if (verbeConjugue.GetGender() == motVariable.Gender && verbeConjugue.Number == motVariable.Number)
{
return(true);
}
else
{
return(false);
}
}
// Conjugue le verbe à la personne et au temps donnés en paramètre.
public static void Conjugate(ref Verb verbe, string person, string time, string mode)
{
string action;
if (verbe.Nature == "verbe conjugué")
{
action = verbe.Action;
}
else
{
action = verbe._verbe;
}
verbe = new ConjugatedVerb(ConjugationOf(verbe, person, time, mode), person, verbe.Group, time, mode, action, verbe.AuxAvoir,
verbe.AuxEtre, verbe.NonPronominale, verbe.Pronominale, verbe.Transitif, verbe.Intransitif);
}
// Renvoie True si la condition passée en paramètre est vraie, sinon False
public static bool EvaluerCondition(Condition condition, Word mot)
{
switch (condition)
{
case Condition.None:
return(true);
case Condition.PronPers:
Pronoun pronom = (Pronoun)mot;
return(pronom.NatureDetaillee == "pronompersonnel");
case Condition.VerbEtat:
ConjugatedVerb verbe = (ConjugatedVerb)mot;
return(ConjugatedVerb.IsAStateVerb(verbe));
case Condition.PasVerbEtat:
ConjugatedVerb verbe2 = (ConjugatedVerb)mot;
return(!ConjugatedVerb.IsAStateVerb(verbe2));
}
return(false);
}
public static void Test_Verbe()
{
// MINI PROGRAMME DE TEST POUR LA CONJUGAISON DES VERBES
Verb verbe;
string temps;
string mode;
string type;
string res = "";
Console.WriteLine(" 1. Je veux entrer des verbes à l'infinitif\n 2. Je veux entrer des verbes conjugués");
if (Console.ReadLine() == "1")
{
type = "verbe infinitif";
}
else
{
type = "verbe conjugué";
}
Console.WriteLine();
while (true)
{
temps = "";
mode = "indicatif";
res = "";
Console.WriteLine("Verbe ?\t");
if (type == "verbe infinitif")
{
verbe = new InfinitiveVerb(Console.ReadLine());
}
else
{
verbe = new ConjugatedVerb(Console.ReadLine());
}
while (res != "autre")
{
Console.WriteLine("\nMode et temps ?\t");
res = Console.ReadLine();
if (res == "autre")
{
break;
}
// On cherche le mode
if (res.Contains("conditionnel"))
{
mode = "conditionnel";
}
else if (res.Contains("subjonctif"))
{
mode = "subjonctif";
}
else if (res.Contains("impératif"))
{
mode = "impératif";
}
else if (res.Contains("participe"))
{
mode = "participe";
}
else
{
mode = "indicatif";
}
// On cherche le temps
if (res.Contains("présent"))
{
temps = "présent";
}
else if (mode == "indicatif")
{
if (res.Contains("imparfait"))
{
temps = "imparfait";
}
else if (res.Contains("passé simple"))
{
temps = "passé simple";
}
else if (res.Contains("futur simple"))
{
temps = "futur simple";
}
else if (res.Contains("composé"))
{
temps = "passé composé";
}
else if (res.Contains("parfait"))
{
temps = "plus-que-parfait";
}
else if (res.Contains("passé antérieur"))
{
temps = "passé antérieur";
}
else if (res.Contains("futur antérieur"))
{
temps = "futur antérieur";
}
else if (res.Contains("passé"))
{
temps = "passé simple";
}
else if (res.Contains("futur"))
{
temps = "futur simple";
}
else
{
temps = "présent";
}
}
else if (mode == "subjonctif")
{
if (res.Contains("imparfait"))
{
temps = "imparfait";
}
else if (res.Contains("passé"))
{
temps = "passé";
}
else if (res.Contains("parfait"))
{
temps = "plus-que-parfait";
}
else
{
temps = "présent";
}
}
else
{
if (res.Contains("passé"))
{
temps = "passé";
}
else
{
temps = "présent";
}
}
Console.WriteLine();
if (type == "verbe infinitif")
{
if (mode == "impératif")
{
Console.WriteLine(ConjugationOf(verbe, "2", temps, mode) + " !");
Console.WriteLine(ConjugationOf(verbe, "4", temps, mode) + " !");
Console.WriteLine(ConjugationOf(verbe, "5", temps, mode) + " !");
}
else if (mode == "subjonctif")
{
string leVerbe = ConjugationOf(verbe, "1", temps, mode);
if (leVerbe != "" && new char[] { 'a', 'e', 'i', 'o', 'u', 'y' }.Contains(leVerbe[0]))
{
Console.WriteLine("que j'" + leVerbe);
}
else
{
Console.WriteLine("que je " + ConjugationOf(verbe, "1", temps, mode));
}
Console.WriteLine("que tu " + ConjugationOf(verbe, "2", temps, mode));
Console.WriteLine("qu'il " + ConjugationOf(verbe, "3", temps, mode));
Console.WriteLine("que nous " + ConjugationOf(verbe, "4", temps, mode));
Console.WriteLine("que vous " + ConjugationOf(verbe, "5", temps, mode));
Console.WriteLine("qu'ils " + ConjugationOf(verbe, "6", temps, mode));
}
else if (mode == "participe")
{
Console.WriteLine(ConjugationOf(verbe, "1", temps, mode));
}
else
{
string leVerbe = ConjugationOf(verbe, "1", temps, mode);
if (leVerbe != "" && new char[] { 'a', 'e', 'i', 'o', 'u', 'y' }.Contains(leVerbe[0]))
{
Console.WriteLine("J'" + leVerbe);
}
else
{
Console.WriteLine("Je " + ConjugationOf(verbe, "1", temps, mode));
}
Console.WriteLine("Tu " + ConjugationOf(verbe, "2", temps, mode));
Console.WriteLine("Il " + ConjugationOf(verbe, "3", temps, mode));
Console.WriteLine("Nous " + ConjugationOf(verbe, "4", temps, mode));
Console.WriteLine("Vous " + ConjugationOf(verbe, "5", temps, mode));
Console.WriteLine("Ils " + ConjugationOf(verbe, "6", temps, mode));
}
}
else
{
if (mode == "impératif")
{
Console.WriteLine(ConjugationOf(verbe, "2", temps, mode) + " !");
Console.WriteLine(ConjugationOf(verbe, "4", temps, mode) + " !");
Console.WriteLine(ConjugationOf(verbe, "5", temps, mode) + " !");
}
else if (mode == "subjonctif")
{
string leVerbe = ConjugationOf(verbe, "1", temps, mode);
if (leVerbe != "" && new char[] { 'a', 'e', 'i', 'o', 'u', 'y' }.Contains(leVerbe[0]))
{
Console.WriteLine("que j'" + leVerbe);
}
else
{
Console.WriteLine("que je " + ConjugationOf(verbe, "1", temps, mode));
}
Console.WriteLine("que tu " + ConjugationOf(verbe, "2", temps, mode));
Console.WriteLine("qu'il " + ConjugationOf(verbe, "3", temps, mode));
Console.WriteLine("que nous " + ConjugationOf(verbe, "4", temps, mode));
Console.WriteLine("que vous " + ConjugationOf(verbe, "5", temps, mode));
Console.WriteLine("qu'ils " + ConjugationOf(verbe, "6", temps, mode));
}
else if (mode == "participe")
{
Console.WriteLine(ConjugationOf(verbe, "1", temps, mode));
}
else
{
string leVerbe = ConjugationOf(verbe, "1", temps, mode);
if (leVerbe != "" && new char[] { 'a', 'e', 'i', 'o', 'u', 'y' }.Contains(leVerbe[0]))
{
Console.WriteLine("J'" + leVerbe);
}
else
{
Console.WriteLine("Je " + ConjugationOf(verbe, "1", temps, mode));
}
Console.WriteLine("Tu " + ConjugationOf(verbe, "2", temps, mode));
Console.WriteLine("Il " + ConjugationOf(verbe, "3", temps, mode));
Console.WriteLine("Nous " + ConjugationOf(verbe, "4", temps, mode));
Console.WriteLine("Vous " + ConjugationOf(verbe, "5", temps, mode));
Console.WriteLine("Ils " + ConjugationOf(verbe, "6", temps, mode));
}
}
Console.WriteLine();
}
Console.Clear();
}
// POUR CRÉER UN FICHIER TEXTE CONTENANT LA LISTE DES VERBES À AJOUTER
// Conjugaison.AjoutAutomatiqueVerbe.triVerbes();
}
// Lie les noms et les compléments du nom et place le résultat dans phraseFonction.
private static void LierNomsComplNom(List <Word> phrase, List <Word[]> phraseFonction)
{
for (ushort indiceMotCourant = 0; indiceMotCourant < phrase.Count; indiceMotCourant++)
{
Word mot = phrase[indiceMotCourant];
bool quiSujet = true;
// Si on tombe sur un nom ou nom propre...
if ((mot.Nature == "nom" || mot.Nature == "nom propre") && indiceMotCourant < phrase.Count - 1)
{
VariableWord nomComplete = (VariableWord)mot;
ushort indiceMotTeste = (ushort)(indiceMotCourant + 1);
// On cherche un éventuel complément du nom, qui se situe toujours après le nom.
// Le complément du nom est la plupart du temps précédé d'une préposition.
// Ainsi, pour savoir si le nom possède un complément du nom, on regarde si une
// préposition se trouve après lui.
if (phrase[indiceMotTeste].Nature == "préposition")
{
Word laPreposition = phrase[indiceMotTeste];
if (indiceMotTeste < phrase.Count - 1)
{
indiceMotTeste++;
// Si le mot suivant la préposition est et nom, un nom propre, un pronom, un verbe infinitif, ou un adverbe,
// la préposition se rattache à ce mot suivant.
if (new string[] { "nom", "nom propre", "pronom", "verbe infinitif", "adverbe" }.Contains(phrase[indiceMotTeste].Nature))
{
phraseFonction.Add(new Word[] { laPreposition, new LinkBetweenWord("PREP"), phrase[indiceMotTeste] });
}
// On supprime la préposition de la phrase et vu que cela décale les mots vers la gauche, on fait indiceMotTeste-=2
// pour retomber sur le nom complément.
phrase.RemoveAt(indiceMotTeste - 1);
indiceMotTeste--;
if (phrase[indiceMotTeste].ToString() == "qui")
{
indiceMotTeste--;
quiSujet = false;
}
// On traite le cas où le nom complément peut être suivi d'un pronom relatif (qui que quoi dont où -quel)
// qui se rattache au nom complément (et non pas au nom complété). La seule façon de savoir si le pronom
// relatif "QUI" (sujet) se rattache au nom complément ou au nom complété est de regarder les accords avec
// le verbe dans la suite de la phrase, pour voir à quel nom entre le nom complément et le nom complété
// conjugue le verbe. Si les deux noms sont du même genre/nombre... on ne peut devenir que grâce au sens de la phrase !
// Pour les autres pronoms relatifs (que COD, quoi, dont (= de qui) COI, auquel (= de qui) COI, où CCL),
// ils se rattachent la plupart du temps au nom qui se trouve juste avant (donc le nom complément) s'il
// n'y a pas de virgule pour les séparer.
// Le pronom relatif ne peut se rattacher qu'à un nom, on vérifie donc que le mot soit un nom.
// On vérifie également qu'on ne se situe pas au dernier mot, et donc qu'il y a encore des mots après...
// Enfin, on regarde si le mot suivant est un pronom.
if ((phrase[indiceMotTeste].Nature == "nom" || phrase[indiceMotTeste].Nature == "nom propre") &&
indiceMotTeste < phrase.Count - 1 && phrase[indiceMotTeste + 1].Nature == "pronom")
{
Name nomComplement = (Name)phrase[indiceMotTeste];
Pronoun pronom = (Pronoun)phrase[indiceMotTeste + 1];
// On vérifie que le pronom soit de type relatif.
if (pronom.Type.Contains("relatif"))
{
// Si le pronom relatif est "qui"...
#region Cas où le pronom relatif est "qui"
if (pronom.ToString() == "qui")
{
// Tant qu'il y a encore un encore un mot après...
for (ushort i = (ushort)(indiceMotTeste + 2); i < phrase.Count; i++)
{
// Si on a trouvé un verbe conjugué...
if (phrase[i].Nature == "verbe conjugué")
{
ConjugatedVerb verbeConjugue = (ConjugatedVerb)phrase[i];
// Si le verbe est conjugué à un temps composé (et donc qu'il possède un participe passé accordable)...
#region Cas où le verbe est à un temps composé
if (verbeConjugue.IsTempsCompose())
{
// On récupère l'auxiliaire.
Verb auxConjugue = new ConjugatedVerb(verbeConjugue.GetAuxiliaireConjugue(), verbeConjugue.Person);
// On le passe à l'infinitif.
Verb.ToInfinitive(ref auxConjugue);
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complément.
if (quiSujet && auxConjugue.ToString() == "être" && SontAccordes(nomComplement, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complété.
else if (quiSujet && auxConjugue.ToString() == "être" && SontAccordes(nomComplete, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
}
#endregion
// Sinon, si le verbe n'est pas à un temps composé, on regarde s'il s'agit du verbe être et
// on cherche s'il est suivi d'un adjectif, accordable...
#region Cas où le verbe n'est pas à un temps composé, on cherche un adjectif à la suite.
else if (verbeConjugue.Action == "être" && i < phrase.Count - 1)
{
// On ne cherche l'adjectif que 4 positions plus loin dans la phrase.
for (int j = i + 1; j < i + 5; j++)
{
// Si on trouve un adjectif...
if (phrase[j].Nature == "adjectif")
{
// Si cet adjectif est accordé avec le nom complément...
if (SontAccordes(nomComplement, (VariableWord)phrase[j]))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Sinon, si cet adjectif est accordé avec le nom complété...
else if (SontAccordes(nomComplete, (VariableWord)phrase[j]))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// On sort du for après le premier adjectif trouvé.
break;
}
}
}
#endregion
break;
}
}
}
#endregion
// Sinon, si le pronom relatif est "que"...
#region Cas où le pronom relatif est "que"
else if (pronom.ToString() == "que")
{
// Tant qu'il y a encore un encore un mot après...
for (ushort i = (ushort)(indiceMotTeste + 2); i < phrase.Count; i++)
{
// Si on a trouvé un verbe conjugué...
if (phrase[i].Nature == "verbe conjugué")
{
ConjugatedVerb verbeConjugue = (ConjugatedVerb)phrase[i];
// Si le verbe est conjugué à un temps composé (et donc qu'il possède un participe passé accordable)...
#region Cas où le verbe est à un temps composé
if (verbeConjugue.IsTempsCompose())
{
// On récupère l'auxiliaire.
Verb auxConjugue = new ConjugatedVerb(verbeConjugue.GetAuxiliaireConjugue(), verbeConjugue.Person);
// On le passe à l'infinitif.
Verb.ToInfinitive(ref auxConjugue);
// Si le verbe utilise l'auxiliaire avoir, et que le nom complément est accordé avec le participe passé,
// le pronom relatif remplace le nom complément (car avec avoir, le participe passé s'accorde avec le COD
// si ce dernier se situe avant le verbe).
if (auxConjugue.ToString() == "avoir" && SontAccordes(nomComplement, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complété.
else if (auxConjugue.ToString() == "avoir" && SontAccordes(nomComplete, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
}
#endregion
break;
}
}
}
#endregion
// Sinon, si le pronom relatif est "dont", "auquel", "où"...
#region Cas où le pronom relatif est "dont", "auquel", "où"
else if (new string[] { "dont", "auquel", "où" }.Contains(pronom.ToString()))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
#endregion
}
}
}
}
// TODO: Traiter les rares cas où le complément du nom n'est pas séparé du nom par une préposition.
}
}
}
