/// <summary> /// Converts the specified phonetic shape to a valid regular expression string. Regular expressions /// formatted for display purposes are NOT guaranteed to compile. /// </summary> /// <param name="shape">The phonetic shape.</param> /// <param name="table">The symbol table.</param> /// <param name="displayFormat">if <c>true</c> the result will be formatted for display, otherwise /// it will be formatted for compilation.</param> /// <returns>The regular expression string.</returns> public static string ToRegexString(this Shape shape, CharacterDefinitionTable table, bool displayFormat) { var sb = new StringBuilder(); if (!displayFormat) { sb.Append("^"); } foreach (ShapeNode node in shape) { if (node.IsDeleted()) { continue; } string[] strReps = table.GetMatchingStrReps(node).ToArray(); int strRepCount = strReps.Length; if (strRepCount > 0) { if (strRepCount > 1) { sb.Append(displayFormat ? "[" : "("); } int i = 0; foreach (string strRep in strReps) { if (strRep.Length > 1) { sb.Append("("); } sb.Append(displayFormat ? strRep : Regex.Escape(strRep)); if (strRep.Length > 1) { sb.Append(")"); } if (i < strRepCount - 1 && !displayFormat) { sb.Append("|"); } i++; } if (strReps.Length > 1) { sb.Append(displayFormat ? "]" : ")"); } if (node.Annotation.Optional) { sb.Append("?"); } } } if (!displayFormat) { sb.Append("$"); } return(sb.ToString()); }
public Segments(CharacterDefinitionTable table, string representation, Shape shape) { _representation = representation; _table = table; _shape = shape; _shape.Freeze(); }
public SegmentDefinition(string strRep, CharacterDefinitionTable charDefTable, FeatureBundle fb) { m_strRep = strRep; m_charDefTable = charDefTable; m_synthFeatures = fb; m_antiFeatures = new FeatureBundle(m_synthFeatures, true); m_analysisFeatures = new FeatureBundle(m_synthFeatures, false); }
/// <summary> /// Initializes a new instance of the <see cref="Stratum"/> class. /// </summary> /// <param name="charDefTable"></param> public Stratum(CharacterDefinitionTable charDefTable) { Depth = -1; _charDefTable = charDefTable; _mrules = new ObservableCollection <IMorphologicalRule>(); _mrules.CollectionChanged += MorphologicalRulesChanged; _prules = new List <IPhonologicalRule>(); _templates = new ObservableCollection <AffixTemplate>(); _templates.CollectionChanged += TemplatesChanged; _entries = new ObservableCollection <LexEntry>(); _entries.CollectionChanged += EntriesChanged; }
/// <summary> /// Initializes a new instance of the <see cref="Stratum"/> class. /// </summary> /// <param name="charDefTable"></param> public Stratum(CharacterDefinitionTable charDefTable) { Depth = -1; _charDefTable = charDefTable; _mrules = new ObservableCollection<IMorphologicalRule>(); _mrules.CollectionChanged += MorphologicalRulesChanged; _prules = new List<IPhonologicalRule>(); _templates = new ObservableCollection<AffixTemplate>(); _templates.CollectionChanged += TemplatesChanged; _entries = new ObservableCollection<LexEntry>(); _entries.CollectionChanged += EntriesChanged; }
public static string ToString(this IEnumerable <ShapeNode> nodes, CharacterDefinitionTable table, bool includeBdry) { var sb = new StringBuilder(); foreach (ShapeNode node in nodes) { if ((!includeBdry && node.Annotation.Type() == HCFeatureSystem.Boundary) || node.IsDeleted()) { continue; } IEnumerable <string> strReps = table.GetMatchingStrReps(node); string strRep = strReps.FirstOrDefault(); if (strRep != null) { sb.Append(strRep); } } return(sb.ToString()); }
/// <summary> /// Converts the specified phonetic shape to a valid regular expression string. Regular expressions /// formatted for display purposes are NOT guaranteed to compile. /// </summary> /// <param name="shape">The phonetic shape.</param> /// <param name="table">The symbol table.</param> /// <param name="displayFormat">if <c>true</c> the result will be formatted for display, otherwise /// it will be formatted for compilation.</param> /// <returns>The regular expression string.</returns> public static string ToRegexString(this Shape shape, CharacterDefinitionTable table, bool displayFormat) { var sb = new StringBuilder(); if (!displayFormat) sb.Append("^"); foreach (ShapeNode node in shape) { if (node.IsDeleted()) continue; string[] strReps = table.GetMatchingStrReps(node).ToArray(); int strRepCount = strReps.Length; if (strRepCount > 0) { if (strRepCount > 1) sb.Append(displayFormat ? "[" : "("); int i = 0; foreach (string strRep in strReps) { if (strRep.Length > 1) sb.Append("("); sb.Append(displayFormat ? strRep : Regex.Escape(strRep)); if (strRep.Length > 1) sb.Append(")"); if (i < strRepCount - 1 && !displayFormat) sb.Append("|"); i++; } if (strReps.Length > 1) sb.Append(displayFormat ? "]" : ")"); if (node.Annotation.Optional) sb.Append("?"); } } if (!displayFormat) sb.Append("$"); return sb.ToString(); }
public BoundaryDefinition(string strRep, CharacterDefinitionTable charDefTable) { m_strRep = strRep; m_charDefTable = charDefTable; }
private AllomorphEnvironment LoadAllomorphEnvironment(XElement envElem, ConstraintType type, CharacterDefinitionTable defaultTable) { var variables = new Dictionary<string, Tuple<string, SymbolicFeature>>(); Pattern<Word, ShapeNode> leftEnv = LoadPhoneticTemplate(envElem.Elements("LeftEnvironment").Elements("PhoneticTemplate").SingleOrDefault(), variables, defaultTable); Pattern<Word, ShapeNode> rightEnv = LoadPhoneticTemplate(envElem.Elements("RightEnvironment").Elements("PhoneticTemplate").SingleOrDefault(), variables, defaultTable); return new AllomorphEnvironment(_spanFactory, type, leftEnv, rightEnv); }
/// <summary> /// Adds the character definition table. /// </summary> /// <param name="charDefTable">The character definition table.</param> public void AddCharacterDefinitionTable(CharacterDefinitionTable charDefTable) { m_charDefTables.Add(charDefTable); }
private IEnumerable<AllomorphEnvironment> LoadAllomorphEnvironments(XElement envsElem, ConstraintType type, CharacterDefinitionTable defaultTable) { if (envsElem == null) yield break; foreach (XElement envElem in envsElem.Elements("Environment")) yield return LoadAllomorphEnvironment(envElem, type, defaultTable); }
public Segments(CharacterDefinitionTable table, string representation) : this(table, representation, table.Segment(representation)) { }
private void LoadMorphologicalLhs(XElement reqPhonInputElem, Dictionary<string, Tuple<string, SymbolicFeature>> variables, Dictionary<string, string> partNames, IList<Pattern<Word, ShapeNode>> lhs, CharacterDefinitionTable defaultTable, string partNamePrefix = null) { int i = 1; foreach (XElement pseqElem in reqPhonInputElem.Elements("PhoneticSequence")) { var id = (string) pseqElem.Attribute("id"); string name = null; if (!string.IsNullOrEmpty(id)) { name = (partNamePrefix ?? "") + i; partNames[id] = name; } lhs.Add(LoadPhoneticSequence(pseqElem, variables, defaultTable, name)); i++; } }
private CharacterDefinitionTable GetTable(XElement elem, CharacterDefinitionTable defaultTable) { string tableId = (string) elem.Attribute("characterDefinitionTable"); return tableId == null ? defaultTable : _tables[tableId]; }
public SegmentDefinition(string strRep, CharacterDefinitionTable charDefTable, IEnumerable<FeatureValue> featVals, FeatureSystem featSys) : this(strRep, charDefTable, new FeatureBundle(featVals, featSys)) { }
private RootAllomorph LoadRootAllomorph(XElement alloElem, CharacterDefinitionTable table) { var shapeStr = (string) alloElem.Element("PhoneticShape"); Segments segments = new Segments(table, shapeStr); if (segments.Shape.All(n => n.Type() == HCFeatureSystem.Boundary)) throw new InvalidShapeException(shapeStr, 0); var allomorph = new RootAllomorph(segments) { IsBound = (bool?) alloElem.Attribute("isBound") ?? false }; allomorph.Environments.AddRange(LoadAllomorphEnvironments(alloElem.Element("RequiredEnvironments"), ConstraintType.Require, table)); allomorph.Environments.AddRange(LoadAllomorphEnvironments(alloElem.Element("ExcludedEnvironments"), ConstraintType.Exclude, table)); var stemNameIDStr = (string) alloElem.Attribute("stemName"); if (!string.IsNullOrEmpty(stemNameIDStr)) allomorph.StemName = _stemNames[stemNameIDStr]; LoadProperties(alloElem.Element("Properties"), allomorph.Properties); return allomorph; }
private Pattern<Word, ShapeNode> LoadPhoneticTemplate(XElement ptempElem, Dictionary<string, Tuple<string, SymbolicFeature>> variables, CharacterDefinitionTable defaultTable = null, Dictionary<string, string> groupNames = null) { var pattern = new Pattern<Word, ShapeNode>(); if (ptempElem != null) { if ((string) ptempElem.Attribute("initialBoundaryCondition") == "true") pattern.Children.Add(new Constraint<Word, ShapeNode>(HCFeatureSystem.LeftSideAnchor)); foreach (PatternNode<Word, ShapeNode> node in LoadPatternNodes(ptempElem.Element("PhoneticSequence"), variables, defaultTable, groupNames)) pattern.Children.Add(node); if ((string) ptempElem.Attribute("finalBoundaryCondition") == "true") pattern.Children.Add(new Constraint<Word, ShapeNode>(HCFeatureSystem.RightSideAnchor)); } pattern.Freeze(); return pattern; }
private Pattern<Word, ShapeNode> LoadPhoneticSequence(XElement pseqElem, Dictionary<string, Tuple<string, SymbolicFeature>> variables, CharacterDefinitionTable defaultTable = null, string name = null) { if (pseqElem == null) return Pattern<Word, ShapeNode>.New().Value; var pattern = new Pattern<Word, ShapeNode>(name, LoadPatternNodes(pseqElem, variables, defaultTable, null)); pattern.Freeze(); return pattern; }
private IEnumerable<PatternNode<Word, ShapeNode>> LoadPatternNodes(XElement pseqElem, Dictionary<string, Tuple<string, SymbolicFeature>> variables, CharacterDefinitionTable defaultTable, Dictionary<string, string> groupNames) { foreach (XElement recElem in pseqElem.Elements()) { PatternNode<Word, ShapeNode> node = null; switch (recElem.Name.LocalName) { case "SimpleContext": SimpleContext simpleCtxt = LoadSimpleContext(recElem, variables); node = new Constraint<Word, ShapeNode>(simpleCtxt.FeatureStruct) {Tag = simpleCtxt}; break; case "Segment": case "BoundaryMarker": CharacterDefinition cd = _charDefs[(string) recElem.Attribute(recElem.Name.LocalName == "Segment" ? "segment" : "boundary")]; node = new Constraint<Word, ShapeNode>(cd.FeatureStruct) {Tag = cd}; break; case "OptionalSegmentSequence": var minStr = (string) recElem.Attribute("min"); int min = string.IsNullOrEmpty(minStr) ? 0 : int.Parse(minStr); var maxStr = (string) recElem.Attribute("max"); int max = string.IsNullOrEmpty(maxStr) ? -1 : int.Parse(maxStr); node = new Quantifier<Word, ShapeNode>(min, max, new Group<Word, ShapeNode>(LoadPatternNodes(recElem, variables, defaultTable, groupNames))); break; case "Segments": CharacterDefinitionTable segsTable = GetTable(recElem, defaultTable); var shapeStr = (string) recElem.Element("PhoneticShape"); var segments = new Segments(segsTable, shapeStr); node = new Group<Word, ShapeNode>(segments.Shape.Select(n => new Constraint<Word, ShapeNode>(n.Annotation.FeatureStruct))) {Tag = segments}; break; } Debug.Assert(node != null); var id = (string) recElem.Attribute("id"); string groupName; if (groupNames == null || string.IsNullOrEmpty(id) || !groupNames.TryGetValue(id, out groupName)) yield return node; else yield return new Group<Word, ShapeNode>(groupName, node); } }
private void LoadMorphologicalRhs(XElement phonOutputElem, Dictionary<string, Tuple<string, SymbolicFeature>> variables, Dictionary<string, string> partNames, IList<MorphologicalOutputAction> rhs, CharacterDefinitionTable defaultTable) { foreach (XElement partElem in phonOutputElem.Elements()) { switch (partElem.Name.LocalName) { case "CopyFromInput": rhs.Add(new CopyFromInput(partNames[(string) partElem.Attribute("index")])); break; case "InsertSimpleContext": rhs.Add(new InsertSimpleContext(LoadSimpleContext(partElem.Element("SimpleContext"), variables))); break; case "ModifyFromInput": rhs.Add(new ModifyFromInput(partNames[(string) partElem.Attribute("index")], LoadSimpleContext(partElem.Element("SimpleContext"), variables))); break; case "InsertSegments": string tableId = (string) partElem.Attribute("characterDefinitionTable"); CharacterDefinitionTable table = tableId == null ? defaultTable : _tables[tableId]; var shapeStr = (string) partElem.Element("PhoneticShape"); rhs.Add(new InsertSegments(new Segments(table, shapeStr))); break; } } }
private AffixProcessAllomorph LoadAffixProcessAllomorph(XElement msubruleElem, CharacterDefinitionTable defaultTable) { var allomorph = new AffixProcessAllomorph(); allomorph.Environments.AddRange(LoadAllomorphEnvironments(msubruleElem.Element("RequiredEnvironments"), ConstraintType.Require, defaultTable)); allomorph.Environments.AddRange(LoadAllomorphEnvironments(msubruleElem.Element("ExcludedEnvironments"), ConstraintType.Exclude, defaultTable)); var fs = new FeatureStruct(); XElement requiredHeadFeatElem = msubruleElem.Element("RequiredHeadFeatures"); if (requiredHeadFeatElem != null) fs.AddValue(_headFeature, LoadFeatureStruct(requiredHeadFeatElem, _language.SyntacticFeatureSystem)); XElement requiredFootFeatElem = msubruleElem.Element("RequiredFootFeatures"); if (requiredFootFeatElem != null) fs.AddValue(_footFeature, LoadFeatureStruct(requiredFootFeatElem, _language.SyntacticFeatureSystem)); fs.Freeze(); allomorph.RequiredSyntacticFeatureStruct = fs; LoadProperties(msubruleElem.Element("Properties"), allomorph.Properties); Dictionary<string, Tuple<string, SymbolicFeature>> variables = LoadVariables(msubruleElem.Element("VariableFeatures")); XElement inputElem = msubruleElem.Element("MorphologicalInput"); Debug.Assert(inputElem != null); allomorph.RequiredMprFeatures.UnionWith(LoadMprFeatures((string) inputElem.Attribute("requiredMPRFeatures"))); allomorph.ExcludedMprFeatures.UnionWith(LoadMprFeatures((string) inputElem.Attribute("excludedMPRFeatures"))); var partNames = new Dictionary<string, string>(); LoadMorphologicalLhs(inputElem, variables, partNames, allomorph.Lhs, defaultTable); XElement outputElem = msubruleElem.Element("MorphologicalOutput"); Debug.Assert(outputElem != null); allomorph.OutMprFeatures.UnionWith(LoadMprFeatures((string) outputElem.Attribute("MPRFeatures"))); allomorph.ReduplicationHint = GetReduplicationHint((string) outputElem.Attribute("redupMorphType")); LoadMorphologicalRhs(outputElem, variables, partNames, allomorph.Rhs, defaultTable); return allomorph; }
public SegmentDefinition(string strRep, CharacterDefinitionTable charDefTable, IEnumerable <FeatureValue> featVals, FeatureSystem featSys) : this(strRep, charDefTable, new FeatureBundle(featVals, featSys)) { }
private void LoadCharacterDefinitionTable(XElement charDefTableElem) { var table = new CharacterDefinitionTable(_spanFactory) { Name = (string) charDefTableElem.Element("Name") }; foreach (XElement segDefElem in charDefTableElem.Elements("SegmentDefinitions").Elements("SegmentDefinition").Where(IsActive)) { IEnumerable<string> reps = segDefElem.Elements("Representations").Elements("Representation").Select(e => (string) e); FeatureStruct fs = null; if (_language.PhonologicalFeatureSystem.Count > 0) fs = LoadFeatureStruct(segDefElem, _language.PhonologicalFeatureSystem); CharacterDefinition cd = table.AddSegment(reps, fs); _charDefs[(string) segDefElem.Attribute("id")] = cd; } foreach (XElement bdryDefElem in charDefTableElem.Elements("BoundaryDefinitions").Elements("BoundaryDefinition").Where(IsActive)) { IEnumerable<string> reps = bdryDefElem.Elements("Representations").Elements("Representation").Select(e => (string) e); CharacterDefinition cd = table.AddBoundary(reps); _charDefs[(string) bdryDefElem.Attribute("id")] = cd; } _language.CharacterDefinitionTables.Add(table); _tables[(string) charDefTableElem.Attribute("id")] = table; }
private bool TryLoadLexEntry(XElement entryElem, CharacterDefinitionTable table, out LexEntry entry) { var id = (string) entryElem.Attribute("id"); entry = new LexEntry {Gloss = (string) entryElem.Element("Gloss")}; var fs = new FeatureStruct(); var pos = (string) entryElem.Attribute("partOfSpeech"); if (!string.IsNullOrEmpty(pos)) fs.AddValue(_posFeature, ParsePartsOfSpeech(pos)); XElement headFeatElem = entryElem.Element("AssignedHeadFeatures"); if (headFeatElem != null) fs.AddValue(_headFeature, LoadFeatureStruct(headFeatElem, _language.SyntacticFeatureSystem)); XElement footFeatElem = entryElem.Element("AssignedFootFeatures"); if (footFeatElem != null) fs.AddValue(_footFeature, LoadFeatureStruct(footFeatElem, _language.SyntacticFeatureSystem)); fs.Freeze(); entry.SyntacticFeatureStruct = fs; entry.MprFeatures.UnionWith(LoadMprFeatures((string) entryElem.Attribute("ruleFeatures"))); var familyID = (string) entryElem.Attribute("family"); if (!string.IsNullOrEmpty(familyID)) { LexFamily family = _families[familyID]; family.Entries.Add(entry); } entry.IsPartial = (bool?) entryElem.Attribute("partial") ?? false; LoadProperties(entryElem.Element("Properties"), entry.Properties); foreach (XElement alloElem in entryElem.Elements("Allomorphs").Elements("Allomorph").Where(IsActive)) { try { RootAllomorph allomorph = LoadRootAllomorph(alloElem, table); entry.Allomorphs.Add(allomorph); _allomorphs[(string) alloElem.Attribute("id")] = allomorph; } catch (Exception e) { if (_errorHandler != null) _errorHandler(e, id); else throw; } } if (entry.Allomorphs.Count > 0) { _morphemes[id] = entry; return true; } entry = null; return false; }
private CompoundingSubrule LoadCompoundingSubrule(XElement compSubruleElem, CharacterDefinitionTable defaultTable) { var subrule = new CompoundingSubrule(); Dictionary<string, Tuple<string, SymbolicFeature>> variables = LoadVariables(compSubruleElem.Element("VariableFeatures")); XElement headElem = compSubruleElem.Element("HeadMorphologicalInput"); Debug.Assert(headElem != null); subrule.RequiredMprFeatures.UnionWith(LoadMprFeatures((string) headElem.Attribute("requiredMPRFeatures"))); subrule.ExcludedMprFeatures.UnionWith(LoadMprFeatures((string) headElem.Attribute("excludedMPRFeatures"))); var partNames = new Dictionary<string, string>(); LoadMorphologicalLhs(headElem, variables, partNames, subrule.HeadLhs, defaultTable, "head_"); XElement nonHeadElem = compSubruleElem.Element("NonHeadMorphologicalInput"); Debug.Assert(nonHeadElem != null); LoadMorphologicalLhs(nonHeadElem, variables, partNames, subrule.NonHeadLhs, defaultTable, "nonhead_"); XElement outputElem = compSubruleElem.Element("MorphologicalOutput"); Debug.Assert(outputElem != null); subrule.OutMprFeatures.UnionWith(LoadMprFeatures((string) outputElem.Attribute("MPRFeatures"))); LoadMorphologicalRhs(outputElem, variables, partNames, subrule.Rhs, defaultTable); return subrule; }
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; }
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 static string ToString(this IEnumerable<ShapeNode> nodes, CharacterDefinitionTable table, bool includeBdry) { var sb = new StringBuilder(); foreach (ShapeNode node in nodes) { if ((!includeBdry && node.Annotation.Type() == HCFeatureSystem.Boundary) || node.IsDeleted()) continue; IEnumerable<string> strReps = table.GetMatchingStrReps(node); string strRep = strReps.FirstOrDefault(); if (strRep != null) sb.Append(strRep); } return sb.ToString(); }
void LoadCharDefTable(XmlElement charDefTableNode) { string id = charDefTableNode.GetAttribute("id"); string name = charDefTableNode.SelectSingleNode("Name").InnerText; CharacterDefinitionTable charDefTable = null; #if IPA_CHAR_DEF_TABLE if (id == "ipa") charDefTable = new IPACharacterDefinitionTable(id, name, m_curMorpher); else charDefTable = new CharacterDefinitionTable(id, name, m_curMorpher); #else charDefTable = new CharacterDefinitionTable(id, name, m_curMorpher); #endif charDefTable.Encoding = charDefTableNode.SelectSingleNode("Encoding").InnerText; XmlNodeList segDefList = charDefTableNode.SelectNodes("SegmentDefinitions/SegmentDefinition[@isActive='yes']"); foreach (XmlNode segDefNode in segDefList) { XmlElement segDefElem = segDefNode as XmlElement; XmlElement repElem = segDefElem.SelectSingleNode("Representation") as XmlElement; string strRep = repElem.InnerText; charDefTable.AddSegmentDefinition(strRep, LoadFeatValues(segDefElem)); m_repIds[repElem.GetAttribute("id")] = strRep; } XmlNodeList bdryDefList = charDefTableNode.SelectNodes("BoundaryDefinitions/BoundarySymbol"); foreach (XmlNode bdryDefNode in bdryDefList) { XmlElement bdryDefElem = bdryDefNode as XmlElement; string strRep = bdryDefElem.InnerText; charDefTable.AddBoundaryDefinition(strRep); m_repIds[bdryDefElem.GetAttribute("id")] = strRep; } m_curMorpher.AddCharacterDefinitionTable(charDefTable); }
private void PrintTrace(Trace trace, int indent, HashSet <int> lineIndices) { _context.Out.Write(GetTraceTypeString(trace.Type)); _context.Out.Write(" ["); bool first = true; string ruleLabel = GetRuleLabelString(trace.Source); if (!string.IsNullOrEmpty(ruleLabel)) { if (trace.SubruleIndex >= 0) { _context.Out.Write("{0}: {1}({2})", ruleLabel, trace.Source.Name, trace.SubruleIndex); } else { _context.Out.Write("{0}: {1}", ruleLabel, trace.Source.Name); } first = false; } bool analysis = IsAnalysis(trace.Type); if (trace.Input != null) { if (!first) { _context.Out.Write(", "); } first = false; CharacterDefinitionTable table = trace.Input.Stratum.CharacterDefinitionTable; _context.Out.Write("Input: {0}", analysis ? trace.Input.Shape.ToRegexString(table, true) : trace.Input.Shape.ToString(table, true)); } if (trace.Output != null) { if (!first) { _context.Out.Write(", "); } first = false; CharacterDefinitionTable table = trace.Output.Stratum.CharacterDefinitionTable; _context.Out.Write("Output: {0}", analysis ? trace.Output.Shape.ToRegexString(table, true) : trace.Output.Shape.ToString(table, true)); } if (trace.FailureReason != FailureReason.None) { if (!first) { _context.Out.Write(", "); } _context.Out.Write("Reason: {0}", trace.FailureReason); } _context.Out.WriteLine("]"); if (!trace.IsLeaf) { int i = 0; foreach (Trace child in trace.Children) { PrintIndent(indent, lineIndices); _context.Out.WriteLine("|"); PrintIndent(indent, lineIndices); _context.Out.Write("+-"); if (i != trace.Children.Count - 1) { lineIndices.Add(indent); } PrintTrace(child, indent + 2, lineIndices); if (i != trace.Children.Count - 1) { lineIndices.Remove(indent); } i++; } } }
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; }