private static XElement CreateMorphologicalRuleElement(IMorphologicalRule rule)
{
XElement elem = CreateHCRuleElement("MorphologicalRule", rule);
elem.Add(new XAttribute("type", rule is AffixProcessRule ? "affix" : "compound"));
return(elem);
}
public void MorphologicalRuleNotApplied(IMorphologicalRule rule, int subruleIndex, Word input, FailureReason reason, object failureObj)
{
((Trace)input.CurrentTrace).Children.Add(new Trace(TraceType.MorphologicalRuleSynthesis, rule)
{
SubruleIndex = subruleIndex, Input = input, FailureReason = reason
});
}
internal void CurrentMorphologicalRuleApplied()
{
CheckFrozen();
IMorphologicalRule mrule = _mrules.Pop();
MorphologicalRuleApplied(mrule);
}
public void MorphologicalRuleNotUnapplied(IMorphologicalRule rule, int subruleIndex, Word input)
{
((Trace)input.CurrentTrace).Children.Add(new Trace(TraceType.MorphologicalRuleAnalysis, rule)
{
SubruleIndex = subruleIndex, Input = input
});
}
/// <summary>
/// Notifies this analysis that the specified morphological rule was unapplied.
/// </summary>
/// <param name="mrule">The morphological rule.</param>
/// <param name="realizational"> </param>
internal void MorphologicalRuleUnapplied(IMorphologicalRule mrule, bool realizational)
{
CheckFrozen();
_mrulesUnapplied.UpdateValue(mrule, () => 0, count => count + 1);
if (!realizational)
{
_mrules.Push(mrule);
}
}
public void MorphologicalRuleUnapplied(IMorphologicalRule rule, int subruleIndex, Word input, Word output)
{
var trace = new Trace(TraceType.MorphologicalRuleAnalysis, rule)
{
SubruleIndex = subruleIndex, Input = input, Output = output
};
((Trace)output.CurrentTrace).Children.Add(trace);
output.CurrentTrace = trace;
}
/// <summary>
/// Gets the number of times the specified morphological rule has been applied.
/// </summary>
/// <param name="mrule">The morphological rule.</param>
/// <returns>The number of applications.</returns>
internal int GetApplicationCount(IMorphologicalRule mrule)
{
int numApplies;
if (!_mrulesApplied.TryGetValue(mrule, out numApplies))
{
numApplies = 0;
}
return(numApplies);
}
public void MorphologicalRuleUnapplied(IMorphologicalRule rule, int subruleIndex, Word input, Word output)
{
var trace = new XElement("MorphologicalRuleAnalysisTrace",
CreateMorphologicalRuleElement(rule));
var aprule = rule as AffixProcessRule;
if (aprule != null)
trace.Add(CreateAllomorphElement(aprule.Allomorphs[subruleIndex]));
trace.Add(CreateWordElement("Output", output, true));
((XElement) output.CurrentTrace).Add(trace);
output.CurrentTrace = trace;
}
internal bool IsMorphologicalRuleApplicable(IMorphologicalRule rule)
{
if (_mruleAppIndex < 0)
{
return(false);
}
IMorphologicalRule curRule = _mruleApps[_mruleAppIndex];
return(curRule == rule || (curRule == null && rule is CompoundingRule));
}
/// <summary>
/// Notifies this word that the specified morphological rule was unapplied. Null
/// indicates that an unknown compounding rule was unapplied. This is used when
/// generating a compound word, because the compounding rule is usually not known just
/// the non-head allomorph.
/// </summary>
internal void MorphologicalRuleUnapplied(IMorphologicalRule mrule)
{
CheckFrozen();
if (mrule != null)
{
_mrulesUnapplied.UpdateValue(mrule, () => 0, count => count + 1);
}
if (!(mrule is RealizationalAffixProcessRule))
{
_mruleApps.Add(mrule);
_mruleAppIndex++;
}
}
public void MorphologicalRuleUnapplied(IMorphologicalRule rule, int subruleIndex, Word input, Word output)
{
var trace = new XElement("MorphologicalRuleAnalysisTrace",
CreateMorphologicalRuleElement(rule));
var aprule = rule as AffixProcessRule;
if (aprule != null)
{
trace.Add(CreateAllomorphElement(aprule.Allomorphs[subruleIndex]));
}
trace.Add(CreateWordElement("Output", output, true));
((XElement)output.CurrentTrace).Add(trace);
output.CurrentTrace = trace;
}
/// <summary>
/// Notifies this word synthesis that the specified morphological rule has applied.
/// </summary>
internal void MorphologicalRuleApplied(IMorphologicalRule mrule)
{
CheckFrozen();
if (IsMorphologicalRuleApplicable(mrule))
{
_mruleAppIndex--;
}
// indicate that the current non-head was applied if this is a compounding rule
if (mrule is CompoundingRule)
{
_nonHeadAppIndex--;
}
_mrulesApplied.UpdateValue(mrule, () => 0, count => count + 1);
}
internal bool HasRemainingRulesFromStratum(Stratum stratum)
{
if (_mruleAppIndex < 0)
{
return(false);
}
IMorphologicalRule curRule = _mruleApps[_mruleAppIndex];
if (curRule == null)
{
return(CurrentNonHead != null && CurrentNonHead.Stratum == stratum);
}
return(curRule.Stratum == stratum);
}
private static XElement CreateMorphologicalRuleElement(IMorphologicalRule rule)
{
XElement elem = CreateHCRuleElement("MorphologicalRule", rule);
elem.Add(new XAttribute("type", rule is AffixProcessRule ? "affix" : "compound"));
return elem;
}
public void MorphologicalRuleNotUnapplied(IMorphologicalRule rule, int subruleIndex, Word input)
{
((Trace) input.CurrentTrace).Children.Add(new Trace(TraceType.MorphologicalRuleAnalysis, rule) {SubruleIndex = subruleIndex, Input = input});
}
public void MorphologicalRuleNotApplied(IMorphologicalRule rule, int subruleIndex, Word input, FailureReason reason, object failureObj)
{
var trace = new XElement("MorphologicalRuleSynthesisTrace",
CreateMorphologicalRuleElement(rule));
var aprule = rule as AffixProcessRule;
if (aprule != null)
trace.Add(CreateAllomorphElement(subruleIndex == -1 ? aprule.Allomorphs.Last() : aprule.Allomorphs[subruleIndex]));
trace.Add(new XElement("Output", "*None*"));
switch (reason)
{
case FailureReason.RequiredSyntacticFeatureStruct:
Debug.Assert(aprule != null);
var requiredFS = (FeatureStruct) failureObj;
var requiredPos = requiredFS.GetValue<SymbolicFeatureValue>("pos");
var inputPos = input.SyntacticFeatureStruct.GetValue<SymbolicFeatureValue>("pos");
if (requiredPos.Values.Intersect(inputPos.Values).Any())
{
trace.Add(new XElement("FailureReason", new XAttribute("type", "inflFeats"),
CreateInflFeaturesElement("InflFeatures", input.SyntacticFeatureStruct),
CreateInflFeaturesElement("RequiredInflFeatures", requiredFS)));
}
else
{
trace.Add(new XElement("FailureReason", new XAttribute("type", "pos"),
new XElement("Pos", string.Join(", ", inputPos.Values.Select(s => s.Description))),
new XElement("RequiredPos", string.Join(", ", requiredPos.Values.Select(s => s.Description)))));
}
break;
case FailureReason.StemName:
trace.Add(new XElement("FailureReason", new XAttribute("type", "fromStemName"),
new XElement("StemName", failureObj)));
break;
case FailureReason.RequiredMprFeatures:
Debug.Assert(aprule != null);
var group = (MprFeatureGroup) failureObj;
trace.Add(group.Name == "lexEntryInflTypes" ? new XElement("FailureReason", new XAttribute("type", "requiredInflType"))
: CreateMprFeaturesFailureElement(true, group, aprule.Allomorphs[subruleIndex].RequiredMprFeatures, input));
break;
case FailureReason.ExcludedMprFeatures:
trace.Add(new XElement("FailureReason", new XAttribute("type", "excludedInflType")));
break;
case FailureReason.Pattern:
Debug.Assert(aprule != null);
var env = (string) aprule.Allomorphs[subruleIndex].Properties["Env"];
var prefixEnv = (string) aprule.Allomorphs[subruleIndex].Properties["PrefixEnv"];
var suffixEnv = (string) aprule.Allomorphs[subruleIndex].Properties["SuffixEnv"];
if (env != null || prefixEnv != null || suffixEnv != null)
{
var reasonElem = new XElement("FailureReason", new XAttribute("type", "environment"));
if (env != null)
reasonElem.Add(new XElement("Environment", env));
if (prefixEnv != null)
reasonElem.Add(new XElement("Environment", env));
if (suffixEnv != null)
reasonElem.Add(new XElement("Environment", env));
trace.Add(reasonElem);
}
else
{
trace.Add(new XElement("FailureReason", new XAttribute("type", "affixProcess")));
}
break;
default:
return;
}
((XElement) input.CurrentTrace).Add(trace);
}
/// <summary>
/// Notifies this word synthesis that the specified morphological rule has applied.
/// </summary>
internal void MorphologicalRuleApplied(IMorphologicalRule mrule)
{
CheckFrozen();
_mrulesApplied.UpdateValue(mrule, () => 0, count => count + 1);
}
private bool TryLoadAffixProcessRule(XElement mruleElem, CharacterDefinitionTable defaultTable, out IMorphologicalRule mrule)
{
var id = (string) mruleElem.Attribute("id");
var affixProcessRule = new AffixProcessRule
{
Name = (string) mruleElem.Element("Name"),
Gloss = (string) mruleElem.Element("Gloss"),
Blockable = (bool?) mruleElem.Attribute("blockable") ?? true,
IsPartial = (bool?) mruleElem.Attribute("partial") ?? false
};
var multApp = (string) mruleElem.Attribute("multipleApplication");
if (!string.IsNullOrEmpty(multApp))
affixProcessRule.MaxApplicationCount = int.Parse(multApp);
var fs = new FeatureStruct();
var requiredPos = (string) mruleElem.Attribute("requiredPartsOfSpeech");
if (!string.IsNullOrEmpty(requiredPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(requiredPos));
XElement requiredHeadFeatElem = mruleElem.Element("RequiredHeadFeatures");
if (requiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(requiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement requiredFootFeatElem = mruleElem.Element("RequiredFootFeatures");
if (requiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(requiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
affixProcessRule.RequiredSyntacticFeatureStruct = fs;
fs = new FeatureStruct();
var outPos = (string) mruleElem.Attribute("outputPartOfSpeech");
if (!string.IsNullOrEmpty(outPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(outPos));
XElement outHeadFeatElem = mruleElem.Element("OutputHeadFeatures");
if (outHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(outHeadFeatElem, _language.SyntacticFeatureSystem));
XElement outFootFeatElem = mruleElem.Element("OutputFootFeatures");
if (outFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(outFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
affixProcessRule.OutSyntacticFeatureStruct = fs;
var obligHeadIDsStr = (string) mruleElem.Attribute("outputObligatoryFeatures");
if (!string.IsNullOrEmpty(obligHeadIDsStr))
{
foreach (string obligHeadID in obligHeadIDsStr.Split(' '))
affixProcessRule.ObligatorySyntacticFeatures.Add(_language.SyntacticFeatureSystem.GetFeature(obligHeadID));
}
var stemNameIDStr = (string) mruleElem.Attribute("requiredStemName");
if (!string.IsNullOrEmpty(stemNameIDStr))
affixProcessRule.RequiredStemName = _stemNames[stemNameIDStr];
LoadProperties(mruleElem.Element("Properties"), affixProcessRule.Properties);
foreach (XElement subruleElem in mruleElem.Elements("MorphologicalSubrules").Elements("MorphologicalSubrule").Where(IsActive))
{
try
{
AffixProcessAllomorph allomorph = LoadAffixProcessAllomorph(subruleElem, defaultTable);
affixProcessRule.Allomorphs.Add(allomorph);
_allomorphs[(string) subruleElem.Attribute("id")] = allomorph;
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, id);
else
throw;
}
}
if (affixProcessRule.Allomorphs.Count > 0)
{
_morphemes[id] = affixProcessRule;
mrule = affixProcessRule;
return true;
}
mrule = null;
return false;
}
public void MorphologicalRuleUnapplied(IMorphologicalRule rule, int subruleIndex, Word input, Word output)
{
var trace = new Trace(TraceType.MorphologicalRuleAnalysis, rule) {SubruleIndex = subruleIndex, Input = input, Output = output};
((Trace) output.CurrentTrace).Children.Add(trace);
output.CurrentTrace = trace;
}
public void MorphologicalRuleNotUnapplied(IMorphologicalRule rule, int subruleIndex, Word input)
{
}
private bool TryLoadRealizationalRule(XElement realRuleElem, CharacterDefinitionTable defaultTable, out IMorphologicalRule mrule)
{
var realRuleID = (string) realRuleElem.Attribute("id");
var realRule = new RealizationalAffixProcessRule
{
Name = (string) realRuleElem.Element("Name"),
Gloss = (string) realRuleElem.Element("Gloss"),
Blockable = (bool?) realRuleElem.Attribute("blockable") ?? true
};
var fs = new FeatureStruct();
XElement requiredHeadFeatElem = realRuleElem.Element("RequiredHeadFeatures");
if (requiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(requiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement requiredFootFeatElem = realRuleElem.Element("RequiredFootFeatures");
if (requiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(requiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
realRule.RequiredSyntacticFeatureStruct = fs;
XElement realFeatElem = realRuleElem.Element("RealizationalFeatures");
if (realFeatElem != null)
realRule.RealizationalFeatureStruct = FeatureStruct.New().Feature(_headFeature).EqualTo(LoadFeatureStruct(realFeatElem, _language.SyntacticFeatureSystem)).Value;
LoadProperties(realRuleElem.Element("Properties"), realRule.Properties);
foreach (XElement subruleElem in realRuleElem.Elements("MorphologicalSubrules").Elements("MorphologicalSubrule").Where(IsActive))
{
try
{
AffixProcessAllomorph allomorph = LoadAffixProcessAllomorph(subruleElem, defaultTable);
realRule.Allomorphs.Add(allomorph);
_allomorphs[(string) subruleElem.Attribute("id")] = allomorph;
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, (string) realRuleElem.Attribute("id"));
else
throw;
}
}
if (realRule.Allomorphs.Count > 0)
{
_morphemes[realRuleID] = realRule;
mrule = realRule;
return true;
}
mrule = null;
return false;
}
public void MorphologicalRuleNotApplied(IMorphologicalRule rule, int subruleIndex, Word input, FailureReason reason, object failureObj)
{
((Trace) input.CurrentTrace).Children.Add(new Trace(TraceType.MorphologicalRuleSynthesis, rule) {SubruleIndex = subruleIndex, Input = input, FailureReason = reason});
}
public void MorphologicalRuleNotApplied(IMorphologicalRule rule, int subruleIndex, Word input, FailureReason reason, object failureObj)
{
var trace = new XElement("MorphologicalRuleSynthesisTrace",
CreateMorphologicalRuleElement(rule));
var aprule = rule as AffixProcessRule;
if (aprule != null)
{
trace.Add(CreateAllomorphElement(subruleIndex == -1 ? aprule.Allomorphs.Last() : aprule.Allomorphs[subruleIndex]));
}
trace.Add(new XElement("Output", "*None*"));
switch (reason)
{
case FailureReason.RequiredSyntacticFeatureStruct:
Debug.Assert(aprule != null);
var requiredFS = (FeatureStruct)failureObj;
FeatureSymbol[] requiredPos = requiredFS.PartsOfSpeech().ToArray();
FeatureSymbol[] inputPos = input.SyntacticFeatureStruct.PartsOfSpeech().ToArray();
if (requiredPos.Intersect(inputPos).Any())
{
trace.Add(new XElement("FailureReason", new XAttribute("type", "inflFeats"),
CreateInflFeaturesElement("InflFeatures", input.SyntacticFeatureStruct),
CreateInflFeaturesElement("RequiredInflFeatures", requiredFS)));
}
else
{
trace.Add(new XElement("FailureReason", new XAttribute("type", "pos"),
new XElement("Pos", string.Join(", ", inputPos.Select(s => s.Description))),
new XElement("RequiredPos", string.Join(", ", requiredPos.Select(s => s.Description)))));
}
break;
case FailureReason.RequiredStemName:
trace.Add(new XElement("FailureReason", new XAttribute("type", "fromStemName"),
new XElement("StemName", failureObj)));
break;
case FailureReason.RequiredMprFeatures:
Debug.Assert(aprule != null);
var group = (MprFeatureGroup)failureObj;
trace.Add(group.Name == "lexEntryInflTypes" ? new XElement("FailureReason", new XAttribute("type", "requiredInflType"))
: CreateMprFeaturesFailureElement(true, group, aprule.Allomorphs[subruleIndex].RequiredMprFeatures, input));
break;
case FailureReason.ExcludedMprFeatures:
trace.Add(new XElement("FailureReason", new XAttribute("type", "excludedInflType")));
break;
case FailureReason.Pattern:
Debug.Assert(aprule != null);
var env = (string)aprule.Allomorphs[subruleIndex].Properties["Env"];
var prefixEnv = (string)aprule.Allomorphs[subruleIndex].Properties["PrefixEnv"];
var suffixEnv = (string)aprule.Allomorphs[subruleIndex].Properties["SuffixEnv"];
if (env != null || prefixEnv != null || suffixEnv != null)
{
var reasonElem = new XElement("FailureReason", new XAttribute("type", "environment"));
if (env != null)
{
reasonElem.Add(new XElement("Environment", env));
}
if (prefixEnv != null)
{
reasonElem.Add(new XElement("Environment", env));
}
if (suffixEnv != null)
{
reasonElem.Add(new XElement("Environment", env));
}
trace.Add(reasonElem);
}
else
{
trace.Add(new XElement("FailureReason", new XAttribute("type", "affixProcess")));
}
break;
case FailureReason.MaxApplicationCount:
trace.Add(new XElement("FailureReason", new XAttribute("type", "maxAppCount")));
break;
case FailureReason.NonPartialRuleProhibitedAfterFinalTemplate:
trace.Add(new XElement("FailureReason", new XAttribute("type", "nonPartialRuleAfterFinalTemplate")));
break;
case FailureReason.NonPartialRuleRequiredAfterNonFinalTemplate:
trace.Add(new XElement("FailureReason", new XAttribute("type", "partialRuleAfterNonFinalTemplate")));
break;
default:
return;
}
((XElement)input.CurrentTrace).Add(trace);
}
public void MorphologicalRuleNotUnapplied(IMorphologicalRule rule, int subruleIndex, Word input)
{
}
private bool TryLoadCompoundingRule(XElement compRuleElem, CharacterDefinitionTable defaultTable, out IMorphologicalRule mrule)
{
var compRuleID = (string) compRuleElem.Attribute("id");
var compRule = new CompoundingRule
{
Name = (string) compRuleElem.Element("Name"),
Blockable = (bool?) compRuleElem.Attribute("blockable") ?? true
};
var multApp = (string) compRuleElem.Attribute("multipleApplication");
if (!string.IsNullOrEmpty(multApp))
compRule.MaxApplicationCount = int.Parse(multApp);
var fs = new FeatureStruct();
var headRequiredPos = (string) compRuleElem.Attribute("headPartsOfSpeech");
if (!string.IsNullOrEmpty(headRequiredPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(headRequiredPos));
XElement headRequiredHeadFeatElem = compRuleElem.Element("HeadRequiredHeadFeatures");
if (headRequiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(headRequiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement headRequiredFootFeatElem = compRuleElem.Element("HeadRequiredFootFeatures");
if (headRequiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(headRequiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
compRule.HeadRequiredSyntacticFeatureStruct = fs;
fs = new FeatureStruct();
var nonHeadRequiredPos = (string) compRuleElem.Attribute("nonHeadPartsOfSpeech");
if (!string.IsNullOrEmpty(nonHeadRequiredPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(nonHeadRequiredPos));
XElement nonHeadRequiredHeadFeatElem = compRuleElem.Element("NonHeadRequiredHeadFeatures");
if (nonHeadRequiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(nonHeadRequiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement nonHeadRequiredFootFeatElem = compRuleElem.Element("NonHeadRequiredFootFeatures");
if (nonHeadRequiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(nonHeadRequiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
compRule.NonHeadRequiredSyntacticFeatureStruct = fs;
fs = new FeatureStruct();
var outPos = (string) compRuleElem.Attribute("outputPartOfSpeech");
if (!string.IsNullOrEmpty(outPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(outPos));
XElement outHeadFeatElem = compRuleElem.Element("OutputHeadFeatures");
if (outHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(outHeadFeatElem, _language.SyntacticFeatureSystem));
XElement outFootFeatElem = compRuleElem.Element("OutputFootFeatures");
if (outFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(outFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
compRule.OutSyntacticFeatureStruct = fs;
var obligHeadIDsStr = (string) compRuleElem.Attribute("outputObligatoryFeatures");
if (!string.IsNullOrEmpty(obligHeadIDsStr))
{
foreach (string obligHeadID in obligHeadIDsStr.Split(' '))
compRule.ObligatorySyntacticFeatures.Add(_language.SyntacticFeatureSystem.GetFeature(obligHeadID));
}
foreach (XElement subruleElem in compRuleElem.Elements("CompoundingSubrules").Elements("CompoundingSubrule").Where(IsActive))
{
try
{
compRule.Subrules.Add(LoadCompoundingSubrule(subruleElem, defaultTable));
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, compRuleID);
else
throw;
}
}
if (compRule.Subrules.Count > 0)
{
mrule = compRule;
return true;
}
mrule = null;
return false;
}
