internal bool CheckBlocking(out Word word)
{
word = null;
LexFamily family = ((LexEntry)RootAllomorph.Morpheme).Family;
if (family == null)
{
return(false);
}
foreach (LexEntry entry in family.Entries)
{
if (entry != RootAllomorph.Morpheme && entry.Stratum == Stratum && SyntacticFeatureStruct.Subsumes(entry.SyntacticFeatureStruct))
{
word = new Word(entry.PrimaryAllomorph, RealizationalFeatureStruct.DeepClone())
{
CurrentTrace = CurrentTrace
};
word.Freeze();
return(true);
}
}
return(false);
}
private Word ChooseInflectionalStem(Word input)
{
LexFamily family = ((LexEntry)input.RootAllomorph.Morpheme).Family;
if (family == null || input.RealizationalFeatureStruct.IsEmpty)
{
return(input);
}
Word best = input;
foreach (LexEntry relative in family.Entries)
{
if (relative != input.RootAllomorph.Morpheme && relative.Stratum == input.Stratum &&
input.RealizationalFeatureStruct.IsUnifiable(relative.SyntacticFeatureStruct) &&
best.SyntacticFeatureStruct.Subsumes(relative.SyntacticFeatureStruct))
{
FeatureStruct remainder = relative.SyntacticFeatureStruct.DeepClone();
remainder.Subtract(best.SyntacticFeatureStruct);
if (!remainder.IsEmpty && input.RealizationalFeatureStruct.IsUnifiable(remainder))
{
best = new Word(relative.PrimaryAllomorph, input.RealizationalFeatureStruct.DeepClone())
{
CurrentTrace = input.CurrentTrace
};
best.Freeze();
}
}
}
if (_morpher.TraceManager.IsTracing && best != input)
{
_morpher.TraceManager.ParseBlocked(_stratum, best);
}
return(best);
}
/// <summary>
/// Adds the lexical family.
/// </summary>
/// <param name="family">The lexical family.</param>
public void AddFamily(LexFamily family)
{
m_families.Add(family);
}
void LoadLanguage(XmlElement langElem)
{
string id = langElem.GetAttribute("id");
m_curMorpher = new Morpher(id, langElem.SelectSingleNode("Name").InnerText);
m_morphers.Add(m_curMorpher);
XmlNodeList posList = langElem.SelectNodes("PartsOfSpeech/PartOfSpeech");
foreach (XmlNode posNode in posList)
{
XmlElement posElem = posNode as XmlElement;
string posId = posElem.GetAttribute("id");
m_curMorpher.AddPOS(new PartOfSpeech(posId, posElem.InnerText, m_curMorpher));
}
XmlNodeList mprFeatList = langElem.SelectNodes("MorphologicalPhonologicalRuleFeatures/MorphologicalPhonologicalRuleFeature[@isActive='yes']");
foreach (XmlNode mprFeatNode in mprFeatList)
{
XmlElement mprFeatElem = mprFeatNode as XmlElement;
string mprFeatId = mprFeatElem.GetAttribute("id");
m_curMorpher.AddMPRFeature(new MPRFeature(mprFeatId, mprFeatElem.InnerText, m_curMorpher));
}
XmlNodeList mprFeatGroupList = langElem.SelectNodes("MorphologicalPhonologicalRuleFeatures/MorphologicalPhonologicalRuleFeatureGroup[@isActive='yes']");
foreach (XmlNode mprFeatGroupNode in mprFeatGroupList)
LoadMPRFeatGroup(mprFeatGroupNode as XmlElement);
XmlNode phonFeatSysNode = langElem.SelectSingleNode("PhonologicalFeatureSystem[@isActive='yes']");
if (phonFeatSysNode != null)
LoadFeatureSystem(phonFeatSysNode as XmlElement, m_curMorpher.PhoneticFeatureSystem);
XmlNode headFeatsNode = langElem.SelectSingleNode("HeadFeatures");
if (headFeatsNode != null)
LoadFeatureSystem(headFeatsNode as XmlElement, m_curMorpher.HeadFeatureSystem);
XmlNode footFeatsNode = langElem.SelectSingleNode("FootFeatures");
if (footFeatsNode != null)
LoadFeatureSystem(footFeatsNode as XmlElement, m_curMorpher.FootFeatureSystem);
XmlNodeList charDefTableList = langElem.SelectNodes("CharacterDefinitionTable[@isActive='yes']");
foreach (XmlNode charDefTableNode in charDefTableList)
LoadCharDefTable(charDefTableNode as XmlElement);
XmlNodeList featNatClassList = langElem.SelectNodes("NaturalClasses/FeatureNaturalClass[@isActive='yes']");
foreach (XmlNode natClassNode in featNatClassList)
LoadFeatNatClass(natClassNode as XmlElement);
XmlNodeList segNatClassList = langElem.SelectNodes("NaturalClasses/SegmentNaturalClass[@isActive='yes']");
foreach (XmlNode natClassNode in segNatClassList)
LoadSegNatClass(natClassNode as XmlElement);
XmlNodeList mrulesNodeList = langElem.SelectNodes("MorphologicalRules/*[@isActive='yes']");
if (mrulesNodeList != null)
{
foreach (XmlNode mruleNode in mrulesNodeList)
{
XmlElement mruleElem = mruleNode as XmlElement;
try
{
switch (mruleElem.Name)
{
case "MorphologicalRule":
LoadMRule(mruleNode as XmlElement);
break;
case "RealizationalRule":
LoadRealRule(mruleNode as XmlElement);
break;
case "CompoundingRule":
LoadCompoundRule(mruleNode as XmlElement);
break;
}
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
}
}
HCObjectSet<MorphologicalRule> templateRules = new HCObjectSet<MorphologicalRule>();
XmlNodeList tempList = langElem.SelectNodes("Strata/AffixTemplate[@isActive='yes']");
foreach (XmlNode tempNode in tempList)
LoadAffixTemplate(tempNode as XmlElement, templateRules);
XmlNodeList stratumList = langElem.SelectNodes("Strata/Stratum[@isActive='yes']");
XmlElement surfaceElem = null;
foreach (XmlNode stratumNode in stratumList)
{
XmlElement stratumElem = stratumNode as XmlElement;
if (stratumElem.GetAttribute("id") == Stratum.SURFACE_STRATUM_ID)
surfaceElem = stratumElem;
else
LoadStratum(stratumElem);
}
if (surfaceElem == null)
throw CreateUndefinedObjectException(HCStrings.kstidNoSurfaceStratum, Stratum.SURFACE_STRATUM_ID);
LoadStratum(surfaceElem);
if (mrulesNodeList != null)
{
foreach (XmlNode mruleNode in mrulesNodeList)
{
XmlElement mruleElem = mruleNode as XmlElement;
string ruleId = mruleElem.GetAttribute("id");
if (!templateRules.Contains(ruleId))
{
MorphologicalRule mrule = m_curMorpher.GetMorphologicalRule(ruleId);
if (mrule != null)
{
Stratum stratum = m_curMorpher.GetStratum(mruleElem.GetAttribute("stratum"));
stratum.AddMorphologicalRule(mrule);
}
}
}
}
XmlNodeList familyList = langElem.SelectNodes("Lexicon/Families/Family[@isActive='yes']");
foreach (XmlNode familyNode in familyList)
{
XmlElement familyElem = familyNode as XmlElement;
LexFamily family = new LexFamily(familyElem.GetAttribute("id"), familyElem.InnerText, m_curMorpher);
m_curMorpher.Lexicon.AddFamily(family);
}
XmlNodeList entryList = langElem.SelectNodes("Lexicon/LexicalEntry[@isActive='yes']");
foreach (XmlNode entryNode in entryList)
{
try
{
LoadLexEntry(entryNode as XmlElement);
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
}
// co-occurrence rules cannot be loaded until all of the morphemes and their allomorphs have been loaded
XmlNodeList morphemeList = langElem.SelectNodes("Lexicon/LexicalEntry[@isActive='yes'] | MorphologicalRules/*[@isActive='yes']");
foreach (XmlNode morphemeNode in morphemeList)
{
XmlElement morphemeElem = morphemeNode as XmlElement;
string morphemeId = morphemeElem.GetAttribute("id");
Morpheme morpheme = m_curMorpher.GetMorpheme(morphemeId);
if (morpheme != null)
{
try
{
morpheme.RequiredMorphemeCoOccurrences = LoadMorphCoOccurs(morphemeElem.SelectSingleNode("RequiredMorphemeCoOccurrences"));
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
try
{
morpheme.ExcludedMorphemeCoOccurrences = LoadMorphCoOccurs(morphemeElem.SelectSingleNode("ExcludedMorphemeCoOccurrences"));
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
}
XmlNodeList allomorphList = morphemeNode.SelectNodes("Allomorphs/Allomorph[@isActive='yes'] | MorphologicalSubrules/MorphologicalSubruleStructure[@isActive='yes']");
foreach (XmlNode alloNode in allomorphList)
{
XmlElement alloElem = alloNode as XmlElement;
string alloId = alloElem.GetAttribute("id");
Allomorph allomorph = m_curMorpher.GetAllomorph(alloId);
if (allomorph != null)
{
try
{
allomorph.RequiredAllomorphCoOccurrences = LoadAlloCoOccurs(alloElem.SelectSingleNode("RequiredAllomorphCoOccurrences"));
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
try
{
allomorph.ExcludedAllomorphCoOccurrences = LoadAlloCoOccurs(alloElem.SelectSingleNode("ExcludedAllomorphCoOccurrences"));
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
}
}
}
XmlNodeList prules = langElem.SelectNodes("PhonologicalRules/*[@isActive='yes']");
foreach (XmlNode pruleNode in prules)
{
XmlElement pruleElem = pruleNode as XmlElement;
try
{
switch (pruleElem.Name)
{
case "MetathesisRule":
LoadMetathesisRule(pruleElem);
break;
case "PhonologicalRule":
LoadPRule(pruleElem);
break;
}
}
catch (LoadException le)
{
if (m_quitOnError)
throw le;
}
}
}
/// <summary>
/// Adds the lexical family.
/// </summary>
/// <param name="family">The lexical family.</param>
public void AddFamily(LexFamily family)
{
m_families.Add(family);
}
private void LoadLanguage(XElement langElem)
{
_language = new Language { Name = (string) langElem.Element("Name") };
IEnumerable<FeatureSymbol> posSymbols = langElem.Elements("PartsOfSpeech").Elements("PartOfSpeech")
.Select(e => new FeatureSymbol((string) e.Attribute("id"), (string) e.Element("Name")));
_posFeature = _language.SyntacticFeatureSystem.AddPartsOfSpeech(posSymbols);
XElement phonFeatSysElem = langElem.Elements("PhonologicalFeatureSystem").SingleOrDefault(IsActive);
if (phonFeatSysElem != null)
LoadPhonologicalFeatureSystem(phonFeatSysElem);
_language.PhonologicalFeatureSystem.Freeze();
XElement headFeatsElem = langElem.Element("HeadFeatures");
if (headFeatsElem != null)
{
_headFeature = _language.SyntacticFeatureSystem.AddHeadFeature();
LoadSyntacticFeatureSystem(headFeatsElem, SyntacticFeatureType.Head);
}
XElement footFeatsElem = langElem.Element("FootFeatures");
if (footFeatsElem != null)
{
_footFeature = _language.SyntacticFeatureSystem.AddFootFeature();
LoadSyntacticFeatureSystem(footFeatsElem, SyntacticFeatureType.Foot);
}
_language.SyntacticFeatureSystem.Freeze();
foreach (XElement mfElem in langElem.Elements("MorphologicalPhonologicalRuleFeatures").Elements("MorphologicalPhonologicalRuleFeature").Where(IsActive))
{
var mprFeature = new MprFeature {Name = (string) mfElem};
_language.MprFeatures.Add(mprFeature);
_mprFeatures[(string) mfElem.Attribute("id")] = mprFeature;
}
foreach (XElement mprFeatGroupElem in langElem.Elements("MorphologicalPhonologicalRuleFeatures").Elements("MorphologicalPhonologicalRuleFeatureGroup").Where(IsActive))
LoadMprFeatGroup(mprFeatGroupElem);
foreach (XElement stemNameElem in langElem.Elements("StemNames").Elements("StemName"))
LoadStemName(stemNameElem);
foreach (XElement charDefTableElem in langElem.Elements("CharacterDefinitionTable").Where(IsActive))
LoadCharacterDefinitionTable(charDefTableElem);
foreach (XElement natClassElem in langElem.Elements("NaturalClasses").Elements().Where(IsActive))
LoadNaturalClass(natClassElem);
foreach (XElement familyElem in langElem.Elements("Families").Elements("Family").Where(IsActive))
{
var family = new LexFamily {Name = (string) familyElem};
_language.Families.Add(family);
_families[(string) familyElem.Attribute("id")] = family;
}
foreach (XElement pruleElem in langElem.Elements("PhonologicalRuleDefinitions").Elements().Where(IsActive))
LoadPhonologicalRule(pruleElem);
foreach (XElement stratumElem in langElem.Elements("Strata").Elements("Stratum").Where(IsActive))
LoadStratum(stratumElem);
foreach (XElement coOccurElem in langElem.Elements("MorphemeCoOccurrenceRules").Elements("MorphemeCoOccurrenceRule").Where(IsActive))
LoadMorphemeCoOccurrenceRule(coOccurElem);
foreach (XElement coOccurElem in langElem.Elements("AllomorphCoOccurrenceRules").Elements("AllomorphCoOccurrenceRule").Where(IsActive))
LoadAllomorphCoOccurrenceRule(coOccurElem);
}
