public void AbsorbeSuivant(SylInW suivant)
{
Debug.Assert(suivant.First == Last + 1);
Last = suivant.Last;
if (!EstVoyelle() && suivant.EstVoyelle())
{
P = suivant.P;
}
}
/// <summary>
/// Vérifie si une syllabe et son successeur (voir http://www.academie-francaise.fr/la-successeur)
/// doivent être fusionnées.
/// <remarks>
/// Marie-Pierre parle de "mixer" et documente les cas suivants:
/// <para>
/// mixer les doubles phonèmes de consonnes qui incluent [l] et [r] ; ex. : bl, tr, cr, chr, pl
/// </para>
/// <para>
/// mixer les doubles phonèmes [y] et [i], [u] et [i,e_tilda,o_tilda]
/// </para>
/// <para>
/// accrocher les lettres muettes aux lettres qui précèdent
/// </para>
/// <para>
/// j'ai rajouté des cas comme le ¨[u] suivi de [a] dans certaines situations...
/// </para>
/// <para>
/// D'une manière générale, on peut dire que
/// la langue n'aime pas tellement le voyelles qui se suivent. On appelle
/// ça l'hiatus. Pour l'éviter, deux voyelles qui se suivent sont parfois
/// prononcées ensemble. La diérèse en poésie consiste justement à quand
/// même prononcer ces deux sons.
/// On essaye ici de traîter les cas évidents. Il existe certainement plein
/// d'exceptions...
/// </para>
/// </remarks>
/// <remarks>
/// Ces tests sont regroupés dans une méthode séparée pour faciliter la lecture du code.
/// </remarks>
/// </summary>
/// <param name="syls">Liste des syllabes du mot, comme elles sont comprises au moment
/// de l'appel de la méthode.</param>
/// <param name="sylIndex">L'index dans <paramref name="syls"/> de la syllabe.</param>
/// <param name="succ">L'index dans <paramref name="syls"/> de son successeur dans
/// le mot.</param>
/// <param name="forceDierese">indique si la diérèse doit être forcée. Dans ce cas, la
/// méthode retourne false si on avait pu fusionner deux voyelles.</param>
/// <returns></returns>
private bool FusionnerSyllabes(List <SylInW> syls, int sylIndex, int succIndex, bool forceDierese)
{
bool toReturn = false;
SylInW syl = syls[sylIndex];
SylInW succ = syls[succIndex];
if (syl.EstBkptgdfv() && (succ.P == Phonemes.l || succ.P == Phonemes.R)) // [bkptgdfv][lR]
{
toReturn = true;
}
else if (syl.P == Phonemes.y && succ.P == Phonemes.i) // ui
{
toReturn = true;
}
else if (syl.P == Phonemes.u)
{
if (succ.P == Phonemes.e_tilda || succ.P == Phonemes.o_tilda) // u(e_tilda|o_tilda)
{
toReturn = !forceDierese;
}
else if (succ.P == Phonemes.i && succ.ToLowerString() != "ï") // ui
{
if (this.ToLowerString() == "oui")
{
toReturn = true;
}
else if (!ToLowerString().StartsWith("enfoui") &&
!ToLowerString().StartsWith("foui") &&
!ToLowerString().StartsWith("joui") &&
!ToLowerString().StartsWith("réjoui") &&
!ToLowerString().StartsWith("ébloui") &&
!ToLowerString().StartsWith("épanoui") &&
!ToLowerString().StartsWith("évanoui"))
{
// pour les exceptions ci-dessus, pas de fusion.
toReturn = !forceDierese;
}
}
else if (succ.P == Phonemes.a && !forceDierese && succ.Last < this.Last)
{
// Pas la fin du mot. Quelle est la lettre suivante?
char nextC = succ.T.ToLowerString()[succ.Last + 1];
switch (nextC)
{
case 'c':
case 'd':
case 'n':
case 'p':
case 'q':
case 't':
toReturn = true;
break;
default:
break;
}
}
}
else if (succ.EstMuet())
{
if (syl.EstConsonne() && succ.ToLowerString() == "h")
{
// Il faut parfois faire le césure de syllabes entre la consonne et le h
// (bon-homme, mal-heur) et parfois il est correct de fusionner la consonne
// avec le h qui suit (sym-pa-thique).
// Hypothèse: ça dépend de la consonne qui précède. Certaines repoussent le
// h alors que d'autres l'attirent :-). C'est probablement un peu plus compliqué
// mais essayons avec ça...
const string AttireH = "bcdgkpqrtvwz";
const string RepousseH = "fjlmnsxç";
// remarques: pour le s, on suppose que le son [S] est identifié par l'automate.
// il reste donc des cas où s repousse h.
toReturn = true;
if (RepousseH.IndexOf(succ.T.ToLowerString()[syl.Last]) > -1)
{
for (int i = succIndex + 1; i < syls.Count; i++)
{
toReturn = toReturn & syls[i].EstMuet();
}
}
}
else
{
toReturn = true;
}
}
return(toReturn);
}
/// <summary>
/// Calcule les syllabes avec la <see cref="Config"/> donnée. La liste 'syls' est remplie.
/// </summary>
/// <param name="forceDierese">Indique s'il faut forcer la diérèse. Si <c>true</c> les
/// 'i' suivis de voyelle comme dans 'hier' sont considérés comme une syllabe à part:
/// 'hi-er'. Si <c>false</c> 'hier' correspond à une seule syllabe.</param>
public void ComputeSyls(bool forceDierese = false)
{
logger.ConditionalTrace(ConfigBase.cultF, "ComputeAndColorSyls {0}", GetWord());
SylInW siw;
int i, j;
SylConfig sylConfig = theConf.sylConf;
// Algorithme de Marie-Pierre
syls = new List <SylInW>((Last - First) / 2);
// créons une syllabe pour chaque phonème
for (i = 0; i < phons.Count; i++)
{
syls.Add(new SylInW(phons[i]));
}
logger.ConditionalTrace("Etape 1 {0} --> {1}, {2}", GetWord(), Syllabes(), GetPhonSyllabes());
if (syls.Count > 1)
{
// Si le décodage est standard dupliquer les phonèmes qui comportent des consonnes doubles
if (sylConfig.DoubleConsStd)
{
for (i = 0; i < syls.Count; i++)
{
if (syls[i].EstConsonneRedoublee())
{
siw = new SylInW(syls[i]);
syls[i].ReduitADerniereLettre();
siw.ReduitAPremiereLettre();
syls.Insert(i, siw);
}
}
}
logger.ConditionalTrace("Etape 2 {0} --> {1}, {2}", GetWord(), Syllabes(), GetPhonSyllabes());
// Il y a une série de cas spéciaux où deux sons ne forment qu'une syllabe
// par exemple [bkptgdfv][lR] ou [y][i] ou [u]([i]|[e_tilda]|[o_tilda])
// (la notation est un peu libre :-)
for (i = 0; i < syls.Count - 1; i++)
{
if (FusionnerSyllabes(syls, i, i + 1, forceDierese))
{
// mixer les deux phonèmes puis raccourcir la chaîne
syls[i].AbsorbeSuivant(syls[i + 1]);
syls.RemoveAt(i + 1);
logger.ConditionalTrace("Etape 3-{0} {1} --> {2}, {3}", i, GetWord(), Syllabes(), GetPhonSyllabes());
i--; // faire en sorte que la prochaine itération considère le nouveau
// phonème fusionné et son successeur
}
}
// construire les syllabes par association de phonèmes consonnes et voyelles
// Les syllabes sont constituées de tout ce qui précède un phonème voyelle
// jusqu'à la syllabe précédente ou le début du mot.
// De plus si le phonème voyelle est suivi de deux consonnes, la première fait
// partie de la première syllabe.
i = 0;
j = 0; // début de la syllabe
while (i < syls.Count)
{
logger.ConditionalTrace("Etape fusion consonnes et voyelles i:{0}, j:{1} {2} --> {3}, {4}"
, i, j, GetWord(), Syllabes(), GetPhonSyllabes());
if (syls[i].EstVoyelle(forceDierese))
{
// fusionner les syllabes de j à i
for (int k = 0; k < (i - j); k++)
{
syls[j].AbsorbeSuivant(syls[j + 1]);
syls.RemoveAt(j + 1);
}
i = j;
j++;
logger.ConditionalTrace("Etape 4A i:{0}, j:{1} {2} --> {3}, {4}",
i, j, GetWord(), Syllabes(), GetPhonSyllabes());
// si les deux lettres qui suivent sont des consonnes, la première fait partie de la syllabe que nous venons de créer
// A condition qu'elles ne soient pas toutes les deux dans la même syllabe.
if (j < syls.Count)
{
int pos = syls[j].First; // position de la lettre suivante dans le texte sous-jacent
if (syls[j].Last == syls[j].First &&
pos < this.Last &&
EstConsonne(GetChar(pos)) &&
EstConsonne(GetChar(pos + 1)))
{
syls[j - 1].EtendDroite(1);
if (!syls[j].ReduitGauche(1))
{
syls.RemoveAt(j);
}
}
}
logger.ConditionalTrace("Etape 4B i:{0}, j:{1} {2} --> {3}, {4}",
i, j, GetWord(), Syllabes(), GetPhonSyllabes());
}
i++;
} // while
logger.ConditionalTrace("Etape 5 i:{0}, j:{1} {2} --> {3}, {4}",
i, j, GetWord(), Syllabes(), GetPhonSyllabes());
// précaution de base : si pas de syllabes reconnues, on concatène simplement les phonèmes
if (j == 0)
{
// le mot ne comprend pas de voyelles --> une seule syllabe
syls.Clear();
siw = new SylInW(this, this.First, this.Last, Phonemes.firstPhon);
syls.Add(siw);
logger.ConditionalTrace("Etape 6A i:{0}, j:{1} {2} --> {3}, {4}",
i, j, GetWord(), Syllabes(), GetPhonSyllabes());
}
else
{
// il ne doit rester à la fin que les lettres muettes ou des consonnes qu'on ajoute à la dernière syllabe
while (j < syls.Count)
{
syls[j - 1].AbsorbeSuivant(syls[j]);
syls.RemoveAt(j);
j++;
}
logger.ConditionalTrace("Etape 6B i:{0}, j:{1} {2} --> {3}, {4}",
i, j, GetWord(), Syllabes(), GetPhonSyllabes());
}
// ###############################################################################
// # Traitement spécial de de la dernière syllabe dans les modes oral et poésie. #
// ###############################################################################
if ((syls.Count > 1) && (syls[syls.Count - 1].P == Phonemes.q_caduc))
{
// s'il y a plus d'une syllabe, il y a aussi plus d'un phonème
if (sylConfig.mode == SylConfig.Mode.oral)
{
// si nous sommes en mode oral, les e caducs des dernières syllabes
// doivent être concaténés avec la syllabe précédente
syls[syls.Count - 2].AbsorbeSuivant(syls[syls.Count - 1]);
syls.RemoveAt(syls.Count - 1);
logger.ConditionalTrace("Etape 7A {0} --> {1}, {2}",
GetWord(), Syllabes(), GetPhonSyllabes());
}
else if (sylConfig.mode == SylConfig.Mode.poesie)
{
logger.ConditionalTrace("Mode poésie. Syllabes avant le traitement: {0}",
Syllabes());
// voir http://mamiehiou.over-blog.com/article-versification-comment-compter-les-pieds-syllabes-d-un-vers-97149081.html
// dont nous nous inspirons ici. Il faut toutefois noter que quand le
// "e" ne compte pas pour un pied, nous le relions simplement avec la
// syllabe précédente, ce qui n'est pas tout à fait correct au niveau
// de la prononciation.
// En gros on peut dire que si le mot suivant commence par une voyelle
// (ou équivalent), le e-caduc ne se prononce pas, sauf s'il y a une laison.
// Si le mot suivant commence par une consonne (ou équivalent) le e-caduc
// se prononce.
string txt = T.ToLowerString();
string wrd = ToLowerString();
ComportementMotSuivant cms = ComportementMotSuivant.undef;
int startNextWord = Last + 1;
// cherchons le début du prochain mot (ou la fin de ligne...)
while (startNextWord < txt.Length &&
(txt[startNextWord] == ' ' ||
txt[startNextWord] == '\t' ||
txt[startNextWord] == ',' || // la virgule n'empêche pas l'influence du mot suivant.
txt[startNextWord] == '!' || // ça pourrait dépendre des situations...
txt[startNextWord] == '?' || // ça pourrait dépendre des situations...
txt[startNextWord] == '.' || // ça pourrait dépendre des situations...
txt[startNextWord] == '"' ||
txt[startNextWord] == '«' ||
txt[startNextWord] == '»' ||
txt[startNextWord] == '“' ||
txt[startNextWord] == '”' ||
txt[startNextWord] == '‘' ||
txt[startNextWord] == '’' ||
txt[startNextWord] == '-' ||
txt[startNextWord] == '—' ||
txt[startNextWord] == ';' ||
txt[startNextWord] == ':' // ça pourrait dépendre des situations...
))
{
startNextWord++;
}
// cherchons la fin du mot suivant
int endNextWord = startNextWord;
while (endNextWord < txt.Length &&
(EstConsonne(txt[endNextWord]) || EstVoyelle(txt[endNextWord])))
{
endNextWord++;
}
// startNextWord est l'index du début du mot suivant. S'il y a des
// lettres, endNextWord est celui de la lettre qui suit le mot.
// S'il n'y a pas de lettres, endNextWord == startNextWord
string nextWord = null;
if (endNextWord > startNextWord)
{
nextWord = txt.Substring(startNextWord, endNextWord - startNextWord);
logger.ConditionalTrace("nextWord: {0}", nextWord);
}
if (startNextWord < txt.Length)
{
// il peut y avoir un mot suivant.
if (Disjonction(nextWord))
{
cms = ComportementMotSuivant.consonne;
}
else if (Liaison(nextWord))
{
cms = ComportementMotSuivant.voyelle;
}
else if (txt[startNextWord] == 'y')
{
// Le cas normal est que le y se comporte comme une consonne
// et le e-caduc forme une syllabe). Les exceptions sont
// interceptées par "Liaison"
cms = ComportementMotSuivant.consonne;
}
else if (TextEl.EstVoyelle(txt[startNextWord]))
{
cms = ComportementMotSuivant.voyelle;
}
else if (txt[startNextWord] == 'h')
{
// Le 'h' mérite un dictionnaire à lui tout seul
if (HAspire(nextWord))
{
cms = ComportementMotSuivant.consonne;
}
else
{
// h muet
cms = ComportementMotSuivant.voyelle;
}
}
else if (TextEl.EstConsonne(txt[startNextWord]))
{
cms = ComportementMotSuivant.consonne;
}
else
{
// Il ne s'agit pas d'un lettre. Donc soit de la ponctuation,
// une fin de ligne ou autre chose... On traite ce cas comme
// une fin de vers.
cms = ComportementMotSuivant.fin;
}
}
else
{
// C'est la fin du texte.
cms = ComportementMotSuivant.fin;
}
logger.ConditionalTrace("cms: {0}", cms.ToString());
switch (cms)
{
case ComportementMotSuivant.consonne:
// la syllabe est prononcée, on la laisse.
break;
case ComportementMotSuivant.voyelle:
if (wrd[wrd.Length - 1] == 's' || wrd[wrd.Length - 1] == 't')
{
// il y a une liaison, la syllabe se prononce.
// L'existence d'un eliaison est probablement plus compliquée
// à identifier (il y certainement une foule d'exceptions)
// :-) Commençons quand même comme ça...
}
else
{
// la syllabe ne se prononce pas.
syls[syls.Count - 2].AbsorbeSuivant(syls[syls.Count - 1]);
syls.RemoveAt(syls.Count - 1);
}
break;
case ComportementMotSuivant.fin:
// la syllabe ne se prononce pas.
syls[syls.Count - 2].AbsorbeSuivant(syls[syls.Count - 1]);
syls.RemoveAt(syls.Count - 1);
break;
default:
logger.Error("ComportementMotSuivant {0} non traité", cms);
break;
}
logger.ConditionalTrace("Etape 7A {0} --> {1}, {2}",
GetWord(), Syllabes(), GetPhonSyllabes());
}
}
} // if (syls.Count > 1)
logger.ConditionalTrace("Résultat {0} --> {1}, {2}",
GetWord(), Syllabes(), GetPhonSyllabes());
}