public SynthesisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative, Pattern<Word, ShapeNode> lhs,
IEnumerable<RewriteSubrule> subrules)
: base(lhs.IsEmpty)
{
Pattern.Acceptable = match => CheckTarget(match, lhs);
if (lhs.IsEmpty)
{
Pattern.Children.Add(new Constraint<Word, ShapeNode>(FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
}
else
{
foreach (Constraint<Word, ShapeNode> constraint in lhs.Children.Cast<Constraint<Word, ShapeNode>>())
{
var newConstraint = constraint.DeepClone();
if (isIterative)
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(newConstraint);
}
}
Pattern.Freeze();
int i = 0;
foreach (RewriteSubrule subrule in subrules)
{
if (lhs.Children.Count == subrule.Rhs.Children.Count)
SubruleSpecs.Add(new FeatureSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, subrule, i));
else if (lhs.Children.Count > subrule.Rhs.Children.Count)
SubruleSpecs.Add(new NarrowSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, lhs.Children.Count, subrule, i));
else if (lhs.Children.Count == 0)
SubruleSpecs.Add(new EpenthesisSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, subrule, i));
i++;
}
}
public NarrowSynthesisRewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative,
int targetCount, RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, isIterative, subrule, index)
{
_rhs = subrule.Rhs;
_targetCount = targetCount;
}
public PatternRule(SpanFactory <TOffset> spanFactory, IPatternRuleSpec <TData, TOffset> ruleSpec,
MatcherSettings <TOffset> matcherSettings)
{
_spanFactory = spanFactory;
_ruleSpec = ruleSpec;
_matcher = new Matcher <TData, TOffset>(spanFactory, _ruleSpec.Pattern, matcherSettings);
}
public SynthesisRewriteRule(SpanFactory <ShapeNode> spanFactory, Morpher morpher, RewriteRule rule)
{
_morpher = morpher;
_rule = rule;
var settings = new MatcherSettings <ShapeNode>
{
Direction = rule.Direction,
Filter = ann => ann.Type().IsOneOf(HCFeatureSystem.Segment, HCFeatureSystem.Boundary, HCFeatureSystem.Anchor) && !ann.IsDeleted(),
UseDefaults = true
};
var ruleSpec = new SynthesisRewriteRuleSpec(spanFactory, settings, rule.ApplicationMode == RewriteApplicationMode.Iterative, _rule.Lhs, _rule.Subrules);
_patternRule = null;
switch (rule.ApplicationMode)
{
case RewriteApplicationMode.Iterative:
_patternRule = new IterativePhonologicalPatternRule(spanFactory, ruleSpec, settings);
break;
case RewriteApplicationMode.Simultaneous:
_patternRule = new SimultaneousPhonologicalPatternRule(spanFactory, ruleSpec, settings);
break;
}
}
public NarrowSynthesisRewriteSubruleSpec(MatcherSettings <ShapeNode> matcherSettings, bool isIterative,
int targetCount, RewriteSubrule subrule, int index)
: base(matcherSettings, isIterative, subrule, index)
{
_rhs = subrule.Rhs;
_targetCount = targetCount;
}
public AnalysisRewriteSubruleSpec(MatcherSettings <ShapeNode> matcherSettings, RewriteSubrule subrule,
Action <Match <Word, ShapeNode>, Range <ShapeNode>, VariableBindings> applyAction)
: base(matcherSettings, CreateEnvironmentPattern(subrule.LeftEnvironment),
CreateEnvironmentPattern(subrule.RightEnvironment))
{
_applyAction = applyAction;
}
public FeatureAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, Pattern<Word, ShapeNode> lhs, RewriteSubrule subrule)
: base(false)
{
var rhsAntiFSs = new List<FeatureStruct>();
foreach (Constraint<Word, ShapeNode> constraint in subrule.Rhs.Children.OfType<Constraint<Word, ShapeNode>>().Where(c => c.Type() == HCFeatureSystem.Segment))
rhsAntiFSs.Add(constraint.FeatureStruct.AntiFeatureStruct());
Pattern.Acceptable = match => IsUnapplicationNonvacuous(match, rhsAntiFSs);
_analysisRhs = new Pattern<Word, ShapeNode>();
int i = 0;
foreach (Tuple<PatternNode<Word, ShapeNode>, PatternNode<Word, ShapeNode>> tuple in lhs.Children.Zip(subrule.Rhs.Children))
{
var lhsConstraint = (Constraint<Word, ShapeNode>) tuple.Item1;
var rhsConstraint = (Constraint<Word, ShapeNode>) tuple.Item2;
if (lhsConstraint.Type() == HCFeatureSystem.Segment && rhsConstraint.Type() == HCFeatureSystem.Segment)
{
var targetConstraint = lhsConstraint.DeepClone();
targetConstraint.FeatureStruct.PriorityUnion(rhsConstraint.FeatureStruct);
targetConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(new Group<Word, ShapeNode>("target" + i) {Children = {targetConstraint}});
FeatureStruct fs = rhsConstraint.FeatureStruct.AntiFeatureStruct();
fs.Subtract(lhsConstraint.FeatureStruct.AntiFeatureStruct());
fs.AddValue(HCFeatureSystem.Type, HCFeatureSystem.Segment);
_analysisRhs.Children.Add(new Constraint<Word, ShapeNode>(fs));
i++;
}
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
protected SynthesisRewriteSubruleSpec(SpanFactory <ShapeNode> spanFactory, MatcherSettings <ShapeNode> matcherSettings, bool isIterative,
RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, subrule.LeftEnvironment, subrule.RightEnvironment)
{
_isIterative = isIterative;
_subrule = subrule;
_index = index;
}
protected SynthesisRewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative,
RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, subrule.LeftEnvironment, subrule.RightEnvironment)
{
_isIterative = isIterative;
_subrule = subrule;
_index = index;
}
public NarrowAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, Pattern<Word, ShapeNode> lhs, RewriteSubrule subrule)
: base(subrule.Rhs.IsEmpty)
{
_analysisRhs = lhs;
_targetCount = subrule.Rhs.Children.Count;
if (subrule.Rhs.IsEmpty)
Pattern.Children.Add(new Constraint<Word, ShapeNode>(FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
else
Pattern.Children.AddRange(subrule.Rhs.Children.DeepClone());
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
public EpenthesisAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, RewriteSubrule subrule)
: base(false)
{
Pattern.Acceptable = IsUnapplicationNonvacuous;
_targetCount = subrule.Rhs.Children.Count;
foreach (Constraint<Word, ShapeNode> constraint in subrule.Rhs.Children.Cast<Constraint<Word, ShapeNode>>())
{
var newConstraint = constraint.DeepClone();
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(newConstraint);
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
public SynthesisMetathesisRule(SpanFactory <ShapeNode> spanFactory, Morpher morpher, MetathesisRule rule)
{
_morpher = morpher;
_rule = rule;
var ruleSpec = new SynthesisMetathesisRuleSpec(spanFactory, rule.Pattern, rule.LeftSwitchName, rule.RightSwitchName);
var settings = new MatcherSettings <ShapeNode>
{
Direction = rule.Direction,
Filter = ann => ann.Type().IsOneOf(HCFeatureSystem.Segment, HCFeatureSystem.Boundary, HCFeatureSystem.Anchor) && !ann.IsDeleted(),
UseDefaults = true
};
_patternRule = new IterativePhonologicalPatternRule(spanFactory, ruleSpec, settings);
}
public EpenthesisAnalysisRewriteRuleSpec(MatcherSettings <ShapeNode> matcherSettings, RewriteSubrule subrule)
: base(false)
{
Pattern.Acceptable = IsUnapplicationNonvacuous;
_targetCount = subrule.Rhs.Children.Count;
foreach (Constraint <Word, ShapeNode> constraint in subrule.Rhs.Children.Cast <Constraint <Word, ShapeNode> >())
{
Constraint <Word, ShapeNode> newConstraint = constraint.Clone();
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(newConstraint);
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(matcherSettings, subrule, Unapply));
}
public SynthesisRewriteRuleSpec(MatcherSettings <ShapeNode> matcherSettings, bool isIterative,
Pattern <Word, ShapeNode> lhs, IEnumerable <RewriteSubrule> subrules)
: base(lhs.IsEmpty)
{
Pattern.Acceptable = match => CheckTarget(match, lhs);
if (lhs.IsEmpty)
{
Pattern.Children.Add(new Constraint <Word, ShapeNode>(
FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
}
else
{
foreach (Constraint <Word, ShapeNode> constraint in lhs.Children.Cast <Constraint <Word, ShapeNode> >())
{
var newConstraint = constraint.Clone();
if (isIterative)
{
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
}
Pattern.Children.Add(newConstraint);
}
}
Pattern.Freeze();
int i = 0;
foreach (RewriteSubrule subrule in subrules)
{
if (lhs.Children.Count == subrule.Rhs.Children.Count)
{
SubruleSpecs.Add(new FeatureSynthesisRewriteSubruleSpec(matcherSettings, isIterative, subrule, i));
}
else if (lhs.Children.Count > subrule.Rhs.Children.Count)
{
SubruleSpecs.Add(new NarrowSynthesisRewriteSubruleSpec(matcherSettings, isIterative,
lhs.Children.Count, subrule, i));
}
else if (lhs.Children.Count == 0)
{
SubruleSpecs.Add(new EpenthesisSynthesisRewriteSubruleSpec(matcherSettings, isIterative, subrule,
i));
}
i++;
}
}
public FeatureAnalysisRewriteRuleSpec(MatcherSettings <ShapeNode> matcherSettings, Pattern <Word, ShapeNode> lhs,
RewriteSubrule subrule)
: base(false)
{
var rhsAntiFSs = new List <FeatureStruct>();
foreach (Constraint <Word, ShapeNode> constraint in subrule.Rhs.Children
.OfType <Constraint <Word, ShapeNode> >().Where(c => c.Type() == HCFeatureSystem.Segment))
{
rhsAntiFSs.Add(constraint.FeatureStruct.AntiFeatureStruct());
}
Pattern.Acceptable = match => IsUnapplicationNonvacuous(match, rhsAntiFSs);
_analysisRhs = new Pattern <Word, ShapeNode>();
int i = 0;
foreach (Tuple <PatternNode <Word, ShapeNode>, PatternNode <Word, ShapeNode> > tuple in lhs.Children
.Zip(subrule.Rhs.Children))
{
var lhsConstraint = (Constraint <Word, ShapeNode>)tuple.Item1;
var rhsConstraint = (Constraint <Word, ShapeNode>)tuple.Item2;
if (lhsConstraint.Type() == HCFeatureSystem.Segment && rhsConstraint.Type() == HCFeatureSystem.Segment)
{
Constraint <Word, ShapeNode> targetConstraint = lhsConstraint.Clone();
targetConstraint.FeatureStruct.PriorityUnion(rhsConstraint.FeatureStruct);
targetConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(new Group <Word, ShapeNode>("target" + i)
{
Children = { targetConstraint }
});
FeatureStruct fs = rhsConstraint.FeatureStruct.AntiFeatureStruct();
fs.Subtract(lhsConstraint.FeatureStruct.AntiFeatureStruct());
fs.AddValue(HCFeatureSystem.Type, HCFeatureSystem.Segment);
_analysisRhs.Children.Add(new Constraint <Word, ShapeNode>(fs));
i++;
}
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(matcherSettings, subrule, Unapply));
}
public NarrowAnalysisRewriteRuleSpec(SpanFactory <ShapeNode> spanFactory, MatcherSettings <ShapeNode> matcherSettings, Pattern <Word, ShapeNode> lhs, RewriteSubrule subrule)
: base(subrule.Rhs.IsEmpty)
{
_analysisRhs = lhs;
_targetCount = subrule.Rhs.Children.Count;
if (subrule.Rhs.IsEmpty)
{
Pattern.Children.Add(new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
}
else
{
Pattern.Children.AddRange(subrule.Rhs.Children.DeepClone());
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
public AnalysisMetathesisRule(SpanFactory <ShapeNode> spanFactory, Morpher morpher, MetathesisRule rule)
{
_morpher = morpher;
_rule = rule;
var ruleSpec = new AnalysisMetathesisRuleSpec(rule.Pattern, rule.LeftSwitchName, rule.RightSwitchName);
var settings = new MatcherSettings <ShapeNode>
{
Direction = rule.Direction == Direction.LeftToRight ? Direction.RightToLeft : Direction.LeftToRight,
Filter = ann => ann.Type().IsOneOf(HCFeatureSystem.Segment, HCFeatureSystem.Anchor),
MatchingMethod = MatchingMethod.Unification,
UseDefaults = true,
// during analysis shape nodes can have features that are underspecified, so this must be non-deterministic
Nondeterministic = true
};
_patternRule = new IterativePhonologicalPatternRule(spanFactory, ruleSpec, settings);
}
protected RewriteSubruleSpec(SpanFactory <ShapeNode> spanFactory, MatcherSettings <ShapeNode> matcherSettings,
Pattern <Word, ShapeNode> leftEnv, Pattern <Word, ShapeNode> rightEnv)
{
if (leftEnv != null && !leftEnv.IsEmpty)
{
MatcherSettings <ShapeNode> leftEnvMatcherSettings = matcherSettings.DeepClone();
leftEnvMatcherSettings.Direction = Direction.RightToLeft;
leftEnvMatcherSettings.AnchoredToStart = true;
_leftEnvMatcher = new Matcher <Word, ShapeNode>(spanFactory, leftEnv, leftEnvMatcherSettings);
}
if (rightEnv != null && !rightEnv.IsEmpty)
{
MatcherSettings <ShapeNode> rightEnvMatcherSettings = matcherSettings.DeepClone();
rightEnvMatcherSettings.Direction = Direction.LeftToRight;
rightEnvMatcherSettings.AnchoredToStart = true;
_rightEnvMatcher = new Matcher <Word, ShapeNode>(spanFactory, rightEnv, rightEnvMatcherSettings);
}
}
protected RewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings,
Pattern<Word, ShapeNode> leftEnv, Pattern<Word, ShapeNode> rightEnv)
{
if (leftEnv != null && !leftEnv.IsEmpty)
{
MatcherSettings<ShapeNode> leftEnvMatcherSettings = matcherSettings.DeepClone();
leftEnvMatcherSettings.Direction = Direction.RightToLeft;
leftEnvMatcherSettings.AnchoredToStart = true;
_leftEnvMatcher = new Matcher<Word, ShapeNode>(spanFactory, leftEnv, leftEnvMatcherSettings);
}
if (rightEnv != null && !rightEnv.IsEmpty)
{
MatcherSettings<ShapeNode> rightEnvMatcherSettings = matcherSettings.DeepClone();
rightEnvMatcherSettings.Direction = Direction.LeftToRight;
rightEnvMatcherSettings.AnchoredToStart = true;
_rightEnvMatcher = new Matcher<Word, ShapeNode>(spanFactory, rightEnv, rightEnvMatcherSettings);
}
}
private void StemWords(Direction dir, IEnumerable <Word> words, IEnumerable <Affix> affixes)
{
var ruleSpec = new BatchPatternRuleSpec <Word, ShapeNode>();
foreach (Affix affix in affixes)
{
var pattern = new Pattern <Word, ShapeNode> {
Acceptable = CheckStemWholeWord
};
if (dir == Direction.LeftToRight)
{
pattern.Children.Add(new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.AnchorType).Value));
}
foreach (ShapeNode node in affix.Shape)
{
pattern.Children.Add(new Quantifier <Word, ShapeNode>(0, 1, new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.BoundaryType).Value)));
pattern.Children.Add(new Constraint <Word, ShapeNode>(node.Annotation.FeatureStruct.Clone()));
pattern.Children.Add(new Quantifier <Word, ShapeNode>(0, 1, new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.ToneLetterType).Value)));
}
if (dir == Direction.RightToLeft)
{
pattern.Children.Add(new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.AnchorType).Value));
}
string category = affix.Category;
ruleSpec.RuleSpecs.Add(new DefaultPatternRuleSpec <Word, ShapeNode>(pattern, MarkStem, word => category == null || word.Meaning.Category == category));
}
var matcherSettings = new MatcherSettings <ShapeNode>
{
Direction = dir,
Filter = ann => ann.Type().IsOneOf(CogFeatureSystem.ConsonantType, CogFeatureSystem.VowelType, CogFeatureSystem.AnchorType,
CogFeatureSystem.ToneLetterType, CogFeatureSystem.BoundaryType)
};
var rule = new PatternRule <Word, ShapeNode>(ruleSpec, matcherSettings);
foreach (Word word in words.Where(w => w.Shape.Count > 0))
{
rule.Apply(word);
}
}
public MultiplePatternRule(SpanFactory <TOffset> spanFactory, IPatternRuleSpec <TData, TOffset> ruleSpec, MatcherSettings <TOffset> matcherSettings)
: base(spanFactory, ruleSpec, matcherSettings)
{
}
protected PhonologicalPatternRule(SpanFactory <ShapeNode> spanFactory, IPhonologicalPatternRuleSpec ruleSpec, MatcherSettings <ShapeNode> matcherSettings)
{
_spanFactory = spanFactory;
_ruleSpec = ruleSpec;
_matcher = new Matcher <Word, ShapeNode>(spanFactory, _ruleSpec.Pattern, matcherSettings);
}
public IterativePhonologicalPatternRule(SpanFactory <ShapeNode> spanFactory, IPhonologicalPatternRuleSpec ruleSpec, MatcherSettings <ShapeNode> matcherSettings)
: base(spanFactory, ruleSpec, matcherSettings)
{
}
protected PhonologicalPatternRule(IPhonologicalPatternRuleSpec ruleSpec,
MatcherSettings <ShapeNode> matcherSettings)
{
_ruleSpec = ruleSpec;
_matcher = new Matcher <Word, ShapeNode>(_ruleSpec.Pattern, matcherSettings);
}
public SimultaneousPhonologicalPatternRule(SpanFactory <ShapeNode> spanFactory, IPhonologicalPatternRuleSpec ruleSpec, MatcherSettings <ShapeNode> matcherSettings)
: base(spanFactory, ruleSpec, matcherSettings)
{
_ruleSpec = ruleSpec;
}
public SimultaneousPhonologicalPatternRule(IPhonologicalPatternRuleSpec ruleSpec,
MatcherSettings <ShapeNode> matcherSettings)
: base(ruleSpec, matcherSettings)
{
_ruleSpec = ruleSpec;
}
public AnalysisRewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, RewriteSubrule subrule,
Action<Match<Word, ShapeNode>, Span<ShapeNode>, VariableBindings> applyAction)
: base(spanFactory, matcherSettings, CreateEnvironmentPattern(subrule.LeftEnvironment), CreateEnvironmentPattern(subrule.RightEnvironment))
{
_applyAction = applyAction;
}
public FeatureSynthesisRewriteSubruleSpec(MatcherSettings <ShapeNode> matcherSettings, bool isIterative,
RewriteSubrule subrule, int index)
: base(matcherSettings, isIterative, subrule, index)
{
_rhs = subrule.Rhs;
}
public IterativePhonologicalPatternRule(SpanFactory<ShapeNode> spanFactory, IPhonologicalPatternRuleSpec ruleSpec, MatcherSettings<ShapeNode> matcherSettings)
: base(spanFactory, ruleSpec, matcherSettings)
{
}
public FeatureSynthesisRewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative,
RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, isIterative, subrule, index)
{
_rhs = subrule.Rhs;
}
public EpenthesisSynthesisRewriteSubruleSpec(SpanFactory <ShapeNode> spanFactory, MatcherSettings <ShapeNode> matcherSettings, bool isIterative,
RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, isIterative, subrule, index)
{
_rhs = subrule.Rhs;
}
public PatternRule(IPatternRuleSpec <TData, TOffset> ruleSpec, MatcherSettings <TOffset> matcherSettings)
{
_ruleSpec = ruleSpec;
_matcher = new Matcher <TData, TOffset>(_ruleSpec.Pattern, matcherSettings);
}
public SimultaneousPhonologicalPatternRule(SpanFactory<ShapeNode> spanFactory, IPhonologicalPatternRuleSpec ruleSpec, MatcherSettings<ShapeNode> matcherSettings)
: base(spanFactory, ruleSpec, matcherSettings)
{
_ruleSpec = ruleSpec;
}
public IterativePhonologicalPatternRule(IPhonologicalPatternRuleSpec ruleSpec,
MatcherSettings <ShapeNode> matcherSettings)
: base(ruleSpec, matcherSettings)
{
}
public AnalysisRewriteRule(Morpher morpher, RewriteRule rule)
{
_morpher = morpher;
_rule = rule;
var settings = new MatcherSettings <ShapeNode>
{
Direction = rule.Direction == Direction.LeftToRight ? Direction.RightToLeft : Direction.LeftToRight,
Filter = ann => ann.Type().IsOneOf(HCFeatureSystem.Segment, HCFeatureSystem.Anchor),
MatchingMethod = MatchingMethod.Unification,
UseDefaults = true,
// during analysis shape nodes can have features that are underspecified, so this must be non-deterministic
Nondeterministic = true
};
_rules = new List <Tuple <ReapplyType, PhonologicalPatternRule> >();
foreach (RewriteSubrule sr in _rule.Subrules)
{
IPhonologicalPatternRuleSpec ruleSpec = null;
var mode = RewriteApplicationMode.Iterative;
var reapplyType = ReapplyType.Normal;
if (_rule.Lhs.Children.Count == sr.Rhs.Children.Count)
{
ruleSpec = new FeatureAnalysisRewriteRuleSpec(settings, rule.Lhs, sr);
if (_rule.ApplicationMode == RewriteApplicationMode.Simultaneous)
{
foreach (Constraint <Word, ShapeNode> constraint in sr.Rhs.Children
.Cast <Constraint <Word, ShapeNode> >())
{
if (constraint.Type() == HCFeatureSystem.Segment)
{
if (!IsUnifiable(constraint, sr.LeftEnvironment) ||
!IsUnifiable(constraint, sr.RightEnvironment))
{
reapplyType = ReapplyType.SelfOpaquing;
break;
}
}
}
}
}
else if (_rule.Lhs.Children.Count > sr.Rhs.Children.Count)
{
ruleSpec = new NarrowAnalysisRewriteRuleSpec(settings, _rule.Lhs, sr);
mode = RewriteApplicationMode.Simultaneous;
reapplyType = ReapplyType.Deletion;
}
else if (_rule.Lhs.Children.Count == 0)
{
ruleSpec = new EpenthesisAnalysisRewriteRuleSpec(settings, sr);
if (_rule.ApplicationMode == RewriteApplicationMode.Simultaneous)
{
reapplyType = ReapplyType.SelfOpaquing;
}
}
Debug.Assert(ruleSpec != null);
PhonologicalPatternRule patternRule = null;
switch (mode)
{
case RewriteApplicationMode.Iterative:
patternRule = new IterativePhonologicalPatternRule(ruleSpec, settings);
break;
case RewriteApplicationMode.Simultaneous:
patternRule = new SimultaneousPhonologicalPatternRule(ruleSpec, settings);
break;
}
_rules.Add(Tuple.Create(reapplyType, patternRule));
}
}
public MultiplePatternRule(IPatternRuleSpec<TData, TOffset> ruleSpec, MatcherSettings<TOffset> matcherSettings)
: base(ruleSpec, matcherSettings)
{
}
