diff --git a/Build/mkall.targets b/Build/mkall.targets index f549811001..44f6b09526 100644 --- a/Build/mkall.targets +++ b/Build/mkall.targets @@ -236,7 +236,7 @@ 9.4.0.1-beta 11.0.0-beta0131 70.1.123 - 3.6.6 + 3.6.7 1.1.1-beta0001 bt393 diff --git a/Build/nuget-common/packages.config b/Build/nuget-common/packages.config index bbc782831f..bcb3a2caac 100644 --- a/Build/nuget-common/packages.config +++ b/Build/nuget-common/packages.config @@ -63,8 +63,8 @@ - - + + diff --git a/DistFiles/Language Explorer/Configuration/Parts/Morphology.fwlayout b/DistFiles/Language Explorer/Configuration/Parts/Morphology.fwlayout index 719519c6d8..9858871d87 100644 --- a/DistFiles/Language Explorer/Configuration/Parts/Morphology.fwlayout +++ b/DistFiles/Language Explorer/Configuration/Parts/Morphology.fwlayout @@ -43,18 +43,22 @@ + + + + diff --git a/DistFiles/Language Explorer/Configuration/Parts/MorphologyParts.xml b/DistFiles/Language Explorer/Configuration/Parts/MorphologyParts.xml index b6d1f4e68e..21190e798d 100644 --- a/DistFiles/Language Explorer/Configuration/Parts/MorphologyParts.xml +++ b/DistFiles/Language Explorer/Configuration/Parts/MorphologyParts.xml @@ -667,6 +667,11 @@ + + + + + @@ -2106,6 +2111,14 @@ + + + + + + + + diff --git a/Src/LexText/ParserCore/FwXmlTraceManager.cs b/Src/LexText/ParserCore/FwXmlTraceManager.cs index a0ebf5478c..6a7702c0ec 100644 --- a/Src/LexText/ParserCore/FwXmlTraceManager.cs +++ b/Src/LexText/ParserCore/FwXmlTraceManager.cs @@ -13,6 +13,8 @@ using SIL.Machine.Annotations; using System.Collections.Generic; using System.Text; +using SIL.Machine.Rules; +using SIL.Core.ClearShare; namespace SIL.FieldWorks.WordWorks.Parser { @@ -91,6 +93,40 @@ public void MorphologicalRuleNotUnapplied(IMorphologicalRule rule, int subruleIn { } + public void CompoundingRuleNotUnapplied(IMorphologicalRule rule, int subruleIndex, Word input, FailureReason reason, object obj) + { + var trace = new XElement("CompoundingRuleAnalysisTrace", + CreateMorphologicalRuleElement(rule)); + var crule = rule as CompoundingRule; + if (crule != null) + { + var stremProdRestricts = obj as MprFeatureSet; + if (stremProdRestricts != null) + { + trace.Add(new XElement("FailureReason", new XAttribute("type", "missingProdRestrict"), + new XElement("StemProdRestricts", stremProdRestricts.Select(f => new XElement("MprFeature", f))), + new XElement("RuleProdRestricts", crule.NonHeadProdRestrictionsMprFeatures.Select(f => new XElement("MprFeature", f))))); + } + } + trace.Add(new XElement("Output", "*None*")); + ((XElement)input.CurrentTrace).Add(trace); + } + + public void CompoundingRuleNotApplied(IMorphologicalRule rule, int subruleIndex, Word input, FailureReason reason, object failureObj) + { + var trace = new XElement("CompoundingRuleSynthesisTrace", + CreateMorphologicalRuleElement(rule)); + var crule = rule as CompoundingRule; + if (crule != null) + { + trace.Add(new XElement("FailureReason", new XAttribute("type", "missingProdRestrict"), + new XElement("StemProdRestricts", input.MprFeatures.Select(f => new XElement("MprFeature", f))), + new XElement("RuleProdRestricts", crule.HeadProdRestrictionsMprFeatures.Select(f => new XElement("MprFeature", f))))); + } + trace.Add(new XElement("Output", "*None*")); + ((XElement)input.CurrentTrace).Add(trace); + } + public void LexicalLookup(Stratum stratum, Word input) { var trace = new XElement("LexLookupTrace", diff --git a/Src/LexText/ParserCore/HCLoader.cs b/Src/LexText/ParserCore/HCLoader.cs index c0f2479aa7..f713960b4d 100644 --- a/Src/LexText/ParserCore/HCLoader.cs +++ b/Src/LexText/ParserCore/HCLoader.cs @@ -177,7 +177,10 @@ private void LoadLanguage() var prodRestrictsGroup = new MprFeatureGroup { Name = "exceptionFeatures", MatchType = MprFeatureGroupMatchType.All }; foreach (ICmPossibility prodRestrict in m_cache.LanguageProject.MorphologicalDataOA.ProdRestrictOA.ReallyReallyAllPossibilities) + { LoadMprFeature(prodRestrict, prodRestrictsGroup); + + } if (prodRestrictsGroup.MprFeatures.Count > 0) m_language.MprFeatureGroups.Add(prodRestrictsGroup); @@ -1838,12 +1841,18 @@ private CompoundingRule LoadEndoCompoundingRule(IMoEndoCompound compoundRule) { var headRequiredFS = new FeatureStruct(); var nonheadRequiredFS = new FeatureStruct(); + var headProdResticts = new MprFeatureSet(); + var nonheadProdResticts = new MprFeatureSet(); if (compoundRule.HeadLast) { if (compoundRule.RightMsaOA.PartOfSpeechRA != null) headRequiredFS.AddValue(m_posFeature, LoadAllPartsOfSpeech(compoundRule.RightMsaOA.PartOfSpeechRA)); if (compoundRule.LeftMsaOA.PartOfSpeechRA != null) nonheadRequiredFS.AddValue(m_posFeature, LoadAllPartsOfSpeech(compoundRule.LeftMsaOA.PartOfSpeechRA)); + if (compoundRule.RightMsaOA.ProdRestrictRC.Count > 0) + CreateProdRestricts(compoundRule.RightMsaOA.ProdRestrictRC, headProdResticts); + if (compoundRule.LeftMsaOA.ProdRestrictRC.Count > 0) + CreateProdRestricts(compoundRule.LeftMsaOA.ProdRestrictRC, nonheadProdResticts); } else { @@ -1851,6 +1860,10 @@ private CompoundingRule LoadEndoCompoundingRule(IMoEndoCompound compoundRule) nonheadRequiredFS.AddValue(m_posFeature, LoadAllPartsOfSpeech(compoundRule.RightMsaOA.PartOfSpeechRA)); if (compoundRule.LeftMsaOA.PartOfSpeechRA != null) headRequiredFS.AddValue(m_posFeature, LoadAllPartsOfSpeech(compoundRule.LeftMsaOA.PartOfSpeechRA)); + if (compoundRule.RightMsaOA.ProdRestrictRC.Count > 0) + CreateProdRestricts(compoundRule.RightMsaOA.ProdRestrictRC, nonheadProdResticts); + if (compoundRule.LeftMsaOA.ProdRestrictRC.Count > 0) + CreateProdRestricts(compoundRule.LeftMsaOA.ProdRestrictRC, headProdResticts); } headRequiredFS.Freeze(); nonheadRequiredFS.Freeze(); @@ -1870,6 +1883,8 @@ private CompoundingRule LoadEndoCompoundingRule(IMoEndoCompound compoundRule) Name = compoundRule.Name.BestAnalysisAlternative.Text, HeadRequiredSyntacticFeatureStruct = headRequiredFS, NonHeadRequiredSyntacticFeatureStruct = nonheadRequiredFS, + HeadProdRestrictionsMprFeatures = headProdResticts, + NonHeadProdRestrictionsMprFeatures = nonheadProdResticts, OutSyntacticFeatureStruct = outFS, Properties = { { HCParser.CRuleID, compoundRule.Hvo } } }; @@ -1894,6 +1909,14 @@ private CompoundingRule LoadEndoCompoundingRule(IMoEndoCompound compoundRule) return hcCompoundRule; } + private void CreateProdRestricts(ILcmReferenceCollection ruleProdRestricts, MprFeatureSet prodResticts) + { + foreach (var prodRstrict in ruleProdRestricts) + { + prodResticts.Add(m_mprFeatures[prodRstrict]); + } + } + private IEnumerable LoadExoCompoundingRule(IMoExoCompound compoundRule) { var rightRequiredFS = new FeatureStruct(); @@ -1908,6 +1931,12 @@ private IEnumerable LoadExoCompoundingRule(IMoExoCompound compo if (compoundRule.ToMsaOA.PartOfSpeechRA != null) outFS.AddValue(m_posFeature, m_posFeature.PossibleSymbols["pos" + compoundRule.ToMsaOA.PartOfSpeechRA.Hvo]); outFS.Freeze(); + var headProdResticts = new MprFeatureSet(); + var nonheadProdResticts = new MprFeatureSet(); + if (compoundRule.RightMsaOA.ProdRestrictRC.Count > 0) + CreateProdRestricts(compoundRule.RightMsaOA.ProdRestrictRC, headProdResticts); + if (compoundRule.LeftMsaOA.ProdRestrictRC.Count > 0) + CreateProdRestricts(compoundRule.LeftMsaOA.ProdRestrictRC, nonheadProdResticts); var headPattern = new Pattern("head", AnyPlus()); headPattern.Freeze(); @@ -1919,6 +1948,8 @@ private IEnumerable LoadExoCompoundingRule(IMoExoCompound compo Name = compoundRule.Name.BestAnalysisAlternative.Text, HeadRequiredSyntacticFeatureStruct = rightRequiredFS, NonHeadRequiredSyntacticFeatureStruct = leftRequiredFS, + HeadProdRestrictionsMprFeatures = headProdResticts, + NonHeadProdRestrictionsMprFeatures = nonheadProdResticts, OutSyntacticFeatureStruct = outFS, Properties = { { HCParser.CRuleID, compoundRule.Hvo } } }; @@ -1944,6 +1975,8 @@ private IEnumerable LoadExoCompoundingRule(IMoExoCompound compo Name = compoundRule.Name.BestAnalysisAlternative.Text, HeadRequiredSyntacticFeatureStruct = leftRequiredFS, NonHeadRequiredSyntacticFeatureStruct = rightRequiredFS, + HeadProdRestrictionsMprFeatures = nonheadProdResticts, + NonHeadProdRestrictionsMprFeatures = headProdResticts, OutSyntacticFeatureStruct = outFS, Properties = { { HCParser.CRuleID, compoundRule.Hvo } } }; diff --git a/Src/LexText/ParserCore/ParserCoreTests/HCLoaderTests.cs b/Src/LexText/ParserCore/ParserCoreTests/HCLoaderTests.cs index 4dfe09b700..2e2a6017f6 100644 --- a/Src/LexText/ParserCore/ParserCoreTests/HCLoaderTests.cs +++ b/Src/LexText/ParserCore/ParserCoreTests/HCLoaderTests.cs @@ -944,6 +944,27 @@ public void EndoCompoundRule() Assert.That(subrule.HeadLhs.Select(p => p.ToString()), Is.EqualTo(new[] {AnyPlus})); Assert.That(subrule.NonHeadLhs.Select(p => p.ToString()), Is.EqualTo(new[] {AnyPlus})); Assert.That(subrule.Rhs.Select(a => a.ToString()), Is.EqualTo(new[] {"", "+", ""})); + + // test for exception "features" + compoundRule.LeftMsaOA.ProdRestrictRC.Add(AddExceptionFeature("Left prod restrict")); + LoadLanguage(); + + Assert.That(m_lang.Strata[0].MorphologicalRules.Count, Is.EqualTo(1)); + hcCompoundRule = (CompoundingRule)m_lang.Strata[0].MorphologicalRules[0]; + + Assert.That(hcCompoundRule.HeadProdRestrictionsMprFeatures.Count, Is.EqualTo(0)); + Assert.That(hcCompoundRule.NonHeadProdRestrictionsMprFeatures.Count, Is.EqualTo(1)); + Assert.That(hcCompoundRule.NonHeadProdRestrictionsMprFeatures.ElementAt(0).Name, Is.EqualTo("Left prod restrict")); + + compoundRule.RightMsaOA.ProdRestrictRC.Add(AddExceptionFeature("Right prod restrict")); + LoadLanguage(); + + Assert.That(m_lang.Strata[0].MorphologicalRules.Count, Is.EqualTo(1)); + hcCompoundRule = (CompoundingRule)m_lang.Strata[0].MorphologicalRules[0]; + + Assert.That(hcCompoundRule.NonHeadProdRestrictionsMprFeatures.Count, Is.EqualTo(1)); + Assert.That(hcCompoundRule.HeadProdRestrictionsMprFeatures.Count, Is.EqualTo(1)); + Assert.That(hcCompoundRule.HeadProdRestrictionsMprFeatures.ElementAt(0).Name, Is.EqualTo("Right prod restrict")); } [Test] @@ -984,6 +1005,28 @@ public void ExoCompoundRule() Assert.That(subrule.NonHeadLhs.Select(p => p.ToString()), Is.EqualTo(new[] {AnyPlus})); Assert.That(subrule.Rhs.Select(a => a.ToString()), Is.EqualTo(new[] {"", "+", ""})); Assert.That(subrule.OutMprFeatures.Select(mf => mf.ToString()), Is.EquivalentTo(new[] {"inflClass"})); + + // test for exception "features" + compoundRule.LeftMsaOA.ProdRestrictRC.Add(AddExceptionFeature("Left prod restrict")); + LoadLanguage(); + + Assert.That(m_lang.Strata[0].MorphologicalRules.Count, Is.EqualTo(2)); + hcCompoundRule = (CompoundingRule)m_lang.Strata[0].MorphologicalRules[0]; + + Assert.That(hcCompoundRule.HeadProdRestrictionsMprFeatures.Count, Is.EqualTo(0)); + Assert.That(hcCompoundRule.NonHeadProdRestrictionsMprFeatures.Count, Is.EqualTo(1)); + Assert.That(hcCompoundRule.NonHeadProdRestrictionsMprFeatures.ElementAt(0).Name, Is.EqualTo("Left prod restrict")); + + compoundRule.RightMsaOA.ProdRestrictRC.Add(AddExceptionFeature("Right prod restrict")); + LoadLanguage(); + + Assert.That(m_lang.Strata[0].MorphologicalRules.Count, Is.EqualTo(2)); + hcCompoundRule = (CompoundingRule)m_lang.Strata[0].MorphologicalRules[0]; + + Assert.That(hcCompoundRule.NonHeadProdRestrictionsMprFeatures.Count, Is.EqualTo(1)); + Assert.That(hcCompoundRule.HeadProdRestrictionsMprFeatures.Count, Is.EqualTo(1)); + Assert.That(hcCompoundRule.HeadProdRestrictionsMprFeatures.ElementAt(0).Name, Is.EqualTo("Right prod restrict")); + } [Test] diff --git a/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTests.cs b/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTests.cs index af8e44cc52..274eb2d33d 100644 --- a/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTests.cs +++ b/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTests.cs @@ -40,6 +40,7 @@ public class M3ToXAmpleTransformerTests string m_sM3FXTIrregularlyInflectedFormsDump; string m_sM3FXTQuechuaMYLDump; string m_sM3FXTEmiFLExDump; + string m_sM3FXTCompundRulesWithExceptionFeaturesFLExDump; private string m_sAbazaOrderClassPlayDump; readonly Dictionary m_mapXmlDocs = new Dictionary(); @@ -87,6 +88,7 @@ private void SetUpM3FXTDump() m_sAbazaOrderClassPlayDump = Path.Combine(m_sTestPath, "Abaza-OrderclassPlay.xml"); m_sM3FXTQuechuaMYLDump = Path.Combine(m_sTestPath, "QuechuaMYLFxtResult.xml"); m_sM3FXTEmiFLExDump = Path.Combine(m_sTestPath, "emi-flexFxtResult.xml"); + m_sM3FXTCompundRulesWithExceptionFeaturesFLExDump = Path.Combine(m_sTestPath, "CompundRulesWithExceptionFeatures.xml"); SetupXmlDocument(m_sM3FXTDump); SetupXmlDocument(m_sM3FXTCircumfixDump); @@ -105,6 +107,7 @@ private void SetUpM3FXTDump() SetupXmlDocument(m_sAbazaOrderClassPlayDump); SetupXmlDocument(m_sM3FXTQuechuaMYLDump); SetupXmlDocument(m_sM3FXTEmiFLExDump); + SetupXmlDocument(m_sM3FXTCompundRulesWithExceptionFeaturesFLExDump); } private void SetupXmlDocument(string filepath) @@ -182,6 +185,7 @@ public void CreateXAmpleWordGrammarFile() ApplyTransform(m_sM3FXTAffixAlloFeatsDump, m_gramTransform, "AffixAlloFeatsWordGrammar.txt"); ApplyTransform(m_sM3FXTLatinDump, m_gramTransform, "LatinWordGrammar.txt"); ApplyTransform(m_sM3FXTQuechuaMYLDump, m_gramTransform, "QuechuaMYLgram.txt"); + ApplyTransform(m_sM3FXTCompundRulesWithExceptionFeaturesFLExDump, m_gramTransform, "CompundRulesWithExceptionFeaturesWordGrammar.txt"); } private void ApplyTransform(string sInput, XslCompiledTransform transform, string sExpectedOutput) { diff --git a/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTestsDataFiles/CompundRulesWithExceptionFeatures.xml b/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTestsDataFiles/CompundRulesWithExceptionFeatures.xml new file mode 100644 index 0000000000..3e17450871 --- /dev/null +++ b/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTestsDataFiles/CompundRulesWithExceptionFeatures.xml @@ -0,0 +1,723 @@ + + + + Adverb + An adverb, narrowly defined, is a part of speech whose members modify verbs for such categories as time, manner, place, or direction. An adverb, broadly defined, is a part of speech whose members modify any constituent class of words other than nouns, such as verbs, adjectives, adverbs, phrases, clauses, or sentences. Under this definition, the possible type of modification depends on the class of the constituent being modified. + adv + 0 + + + + + + + + + Noun + A noun is a broad classification of parts of speech which include substantives and nominals. + n + 2 + + + + + + + + + Pro-form + A pro-form is a part of speech whose members usually substitute for other constituents, including phrases, clauses, or sentences, and whose meaning is recoverable from the linguistic or extralinguistic context. + pro-form + 0 + + + + + + + + + + Pronoun + A pronoun is a pro-form which functions like a noun and substitutes for a noun or noun phrase. + pro + 0 + + + + + + + + + Verb + A verb is a part of speech whose members typically signal events and actions; constitute, singly or in a phrase, a minimal predicate in a clause; govern the number and types of other constituents which may occur in the clause; and, in inflectional languages, may be inflected for tense, aspect, voice, modality, or agreement with other constituents in person, number, or grammatical gender. + v + 2 + + + + + + + + + + + + + Consonants + Consonants + C + + + + + + + + + + + + + + + + + + + + + Vowels + Vowels + V + + + + + + + + + + + Main phoneme set + Main phoneme set + + + a + low central unrounded vowel + + + a + + + + + + + b + voiced bilabial stop + + + b + + + + + + + d + voiced alveolar stop + + + d + + + + + + + e + mid front unrounded vowel + + + e + + + + + + + f + voiceless labiodental fricative + + + f + + + + + + + g + voiced velar stop + + + g + + + + + + + i + high front unrounded vowel + + + i + + + + + + + j + palatal approximant + + + j + + + + + + + k + voiceless velar stop + + + k + + + + + + + l + alveolar lateral + + + l + + + + + + + m + bilabial nasal + + + m + + + + + + + n + alveolar nasal + + + n + + + + + + + o + mid back rounded vowel + + + o + + + + + + + p + voiceless bilabial stop + + + p + + + + + + + r + alveolar flap + + + r + + + + + + + s + voiceless alveolar fricative + + + s + + + + + + + t + voiceless alveolar stop + + + t + + + + + + + u + high back rounded vowel + + + u + + + + + + + v + voiced labiodental fricative + + + v + + + + + + + w + labiovelar approximant + + + w + + + + + + + x + voiceless velar fricative + + + x + + + + + + + z + voiced alveolar fricative + + + z + + + + + + + ŋ + velar nasal + + + ŋ + + + + + + + + + + + + + + + + + + + # + + + # + + + + + + + + + + + + + + + + + + + + 5 + 1 + 5 + 0 + 1 + 10 + + XAmple + + + + + Noun-verb + *** + + + + + + Verb-Noun + *** + + + + + + non-headed + fake one + + + + + + + + + Left-headed noun incorporation + Is OK for this noun to be incorporated in a left-headed compound + lni + + + Right-headed noun incorporation + Is OK for this noun to be incorporated in a right-headed compound + rni + + + Extra exception feature + Used for testing only + xt + + + + + discontiguous phrase + dis phr + A discontiguous phrase has discontiguous constituents which (a) are separated from each other by one or more intervening constituents, and (b) are considered either (i) syntactically contiguous and unitary, or (ii) realizing the same, single meaning. An example is French ne...pas. + 0 + + + infixing interfix + ifxnfx + An infixing interfix is an infix that can occur between two roots or stems. + 0 + + + suffixing interfix + sfxnfx + A suffixing interfix is a suffix that can occur between two roots or stems. + 0 + + + particle + part + A particle is a word that does not belong to one of the main classes of words, is invariable in form, and typically has grammatical or pragmatic meaning. + 0 + + + phrase + phr + A phrase is a syntactic structure that consists of more than one word but lacks the subject-predicate organization of a clause. + 0 + + + prefixing interfix + pfxnfx + A prefixing interfix is a prefix that can occur between two roots or stems. + 0 + + + clitic + clit + A clitic is a morpheme that has syntactic characteristics of a word, but shows evidence of being phonologically bound to another word. Orthographically, it stands alone. + 0 + + + infix + ifx + An infix is an affix that is inserted within a root or stem. + 0 + + + prefix + pfx + A prefix is an affix that is joined before a root or stem. + 0 + + + simulfix + smfx + A simulfix is a change or replacement of vowels or consonants (usually vowels) which changes the meaning of a word. (Note: the parser does not currently handle simulfixes.) + 0 + + + suffix + sfx + A suffix is an affix that is attached to the end of a root or stem. + 0 + + + suprafix + spfx + A suprafix is a kind of affix in which a suprasegmental is superimposed on one or more syllables of the root or stem, signalling a particular morphosyntactic operation. (Note: the parser does not currently handle suprafixes.) + 0 + + + circumfix + cfx + A circumfix is an affix made up of two separate parts which surround and attach to a root or stem. + 0 + + + enclitic + enclit + An enclitic is a clitic that is phonologically joined at the end of a preceding word to form a single unit. Orthographically, it may attach to the preceding word. + 0 + + + proclitic + proclit + A proclitic is a clitic that precedes the word to which it is phonologically joined. Orthographically, it may attach to the following word. + 0 + + + bound root + bd root + A bound root is a root which cannot occur as a separate word apart from any other morpheme. + 0 + + + root + ubd root + A root is the portion of a word that (i) is common to a set of derived or inflected forms, if any, when all affixes are removed, (ii) is not further analyzable into meaningful elements, being morphologically simple, and, (iii) carries the principal portion of meaning of the words in which it functions. + 0 + + + bound stem + bd stem + A bound stem is a stem which cannot occur as a separate word apart from any other morpheme. + 0 + + + stem + ubd stem + "A stem is the root or roots of a word, together with any derivational affixes, to which inflectional affixes are added." (LinguaLinks Library). A stem "may consist solely of a single root morpheme (i.e. a 'simple' stem as in man), or of two root morphemes (e.g. a 'compound' stem, as in blackbird), or of a root morpheme plus a derivational affix (i.e. a 'complex' stem, as in manly, unmanly, manliness). All have in common the notion that it is to the stem that inflectional affixes are attached." (Crystal, 1997:362) + 4 + + + + + Irregularly Inflected Form + irreg. infl. + An Irregularly Inflected Form is an inflected form of the lexeme that is different from what you would expect from the normal rules of the grammar. + *** + .irr.infl + + + + Past + pst. + The past tense form of a verb that does not take the regular inflectional affix for past tense. + *** + .pst + + + + Plural + pl. + The plural form of a noun that does not take the regular inflectional affix for plural. + *** + .pl + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + dog + *** + + + water + *** + + + pat + *** + + + drink + *** + + + + +
slurp
+ + +
wawa
+ + +
dag
+ + +
kit
+ + + + + + + Infl + *** + Infl + + + + + + + + + + \ No newline at end of file diff --git a/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTestsDataFiles/CompundRulesWithExceptionFeaturesWordGrammar.txt b/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTestsDataFiles/CompundRulesWithExceptionFeaturesWordGrammar.txt new file mode 100644 index 0000000000..01d3b8f70f --- /dev/null +++ b/Src/LexText/ParserCore/ParserCoreTests/M3ToXAmpleTransformerTestsDataFiles/CompundRulesWithExceptionFeaturesWordGrammar.txt @@ -0,0 +1,832 @@ + +| DO NOT EDIT THIS FILE DIRECTLY! +| + +| ------------------------------------------------------------ +| TOP-LEVEL WORD +| ------------------------------------------------------------ +rule {Top-level cliticless word} + OrthographicWord = Word + | percolation + = + = + +rule {Top-level word with one or more proclitics and enclitics} + OrthographicWord = Proclitics Word Enclitics + | percolation + = + = + = + = + | drip (pass down) + = + = + +rule {Top-level word with one or more proclitics} + OrthographicWord = Proclitics Word + | percolation + = + = + = + | drip (pass down) + = + +rule {Top-level word with one or more enclitics} + OrthographicWord = Word Enclitics + | percolation + = + = + = + | drip (pass down) + = + + +| ------------------------------------------------------------ +| CLITICS +| ------------------------------------------------------------ +rule {One or more proclitics} + Proclitics_1 = proclitic (Proclitics_2) + | percolation + = + | drip (pass down) + = + | constraints + = + = + +rule {One or more enclitics} + Enclitics_1 = (Enclitics_2) enclitic + | percolation + = + | drip (pass down) + = + | constraints + = + = + + +| ------------------------------------------------------------ +| WORD +| ------------------------------------------------------------ +rule {clitic word} + Word = clitic + | percolation + = + = + +rule {Fully analyzed word} + Word = Full + | percolation + = + = + == [requiresInflection : -] / | doesn't require inflection or + [inflected : +] | is inflected + +rule {Partially analyzed word} + Word = Partial + | percolation + = + = + +| ------------------------------------------------------------ +| FULLY ANALYZED WORD PORTION +| ------------------------------------------------------------ + +rule {Fully analyzed stem with no inflectional template} + Full = Stem + | percolation + = + = + = + = + | constraint + = - | this Full word category is not inflected + = - | prevent a non-final template from immediately being inflected without any intervening derivation or compounding + +| ------------------------------------------------------------ +| STEM +| ------------------------------------------------------------ + +rule {Stem consisting of a single root} + Stem = root + | percolation + = + = + = + = + = + = + = + == ~[rootCat : unknown] | root category has to be overt + + +rule {Stem with a derivational prefix} + Stem_1 = derivPfx Stem_2 + | percolation + = | default to Stem 2 (in case deriv prefix has no category) + <= | use priority union to override anything in Stem_2 + = + = + = | default to stem 2 (in case deriv prefix has no to category) + <= | use deriv prefix when it has a category + = + = + <= + = + <= + <= + = - | This stem can now be inflected + | constraints + = + = + = + = + { + + = + = + / + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {Stem with a derivational suffix} + Stem_1 = Stem_2 derivSfx + | percolation + = | default to Stem 2 (in case deriv suffix has no to category) + <= | use priority union to override anything in Stem_2 + = + = + = | default to stem 2 (in case deriv suffix has no to category) + <= | use deriv suffix when it has a category + = + = + <= + = + <= + <= + = - | This stem can now be inflected + | constraints + = + = + = + = + { + + = + = + / + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } +rule {Stem with a derivational circumfix} + Stem_1 = derivCircumPfx Stem_2 derivCircumSfx + | percolation + = | default to Stem 2 (in case deriv circumfixes have no to category) + <= | use priority union to override anything in Stem_2 + <= + = + = + = + = | default to stem 2 (in case deriv prefix has no category) + <= | use deriv prefix when it has a category + <= | use deriv suffix when it has a category + = + = + <= + <= + = + <= + <= + <= + <= + = - | This stem can now be inflected + | constraints + = + = + = + = + = + = + = + = + { + + = + = + = + = + / + = 6433 + = 6433 + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {Stem with a derivational circumfix where the rightmost part is an infix (and so may end up as a prefix} + Stem_1 = derivCircumPfx_1 derivCircumPfx_2 Stem_2 + | percolation + = | default to Stem 2 (in case deriv circumfixes have no to category) + <= | use priority union to override anything in Stem_2 + <= + = + = + = + = | default to stem 2 (in case deriv prefix has no category) + <= | use deriv prefix when it has a category + <= | use deriv suffix when it has a category + = + = + <= + <= + = + <= + <= + <= + <= + = - | This stem can now be inflected + | constraints + = + = + = + = + = + = + = + = + | rightmost "prefix" must be an infix + == [morphType : infix] + { + + = + = + = + = + / + = 6433 + = 6433 + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {Stem via compound rule 44} + Stem_1 = Stem_2 Stem_3 + | percolation + = + = + = + = + = + | for stem names, use priority union to handle case of compound within a compound; last one wins + <= + + = - | This stem can now be inflected + | constraints + + == [exception:[2602:+]] / + [exception:[7041:+]] + = 6584 + = 5355 +rule {Stem via compound rule 1485} + Stem_1 = Stem_2 Stem_3 + | percolation + = + = + = + = + = + | for stem names, use priority union to handle case of compound within a compound; last one wins + <= + + = - | This stem can now be inflected + | constraints + + == [exception:[6638:+]] + = 5355 + = 6584 +rule {Stem via compound rule 3623} + Stem_1 = Stem_2 Stem_3 + | percolation + = 2838 + + = - + + = 0 + = - | This stem can now be inflected + | constraints + + == [exception:[7041:+]] + = 2838 + = 5355 +| ------------------------------------------------------------ +| PARTIALLY ANALYZED WORD PORTION +| ------------------------------------------------------------ + + | an unmarked root +rule {A root unmarked for category is a partial analysis} +Partial = root + | percolation + = + | constraint + = unknown + + | affixes on an unmarked root +rule {One or more prefixes and suffixes on an unmarked stem} +Partial_1 = Prefs Partial_2 Suffs + | percolation + = + | constraint + = unknown + + | prefixes on an unmarked root +rule {One or more prefixes on an unmarked stem} +Partial_1 = Prefs Partial_2 + | percolation + = + | constraint + = unknown + + | suffixes on an unmarked root +rule {One or more suffixes on an unmarked stem} +Partial_1 = Partial_2 Suffs + | percolation + = + | constraint + = unknown + +rule {Derivational circumfix on an unmarked stem} +Partial_1 = derivCircumPfx Partial_2 derivCircumSfx + | percolation + = + | constraint + = unknown +rule {Derivational circumfix on an unmarked stem where second is an infix} +Partial_1 = derivCircumPfx_1 derivCircumPfx_2 Partial_2 + | percolation + = + | constraint + = unknown + | rightmost "prefix" must be an infix + == [morphType : infix] + +rule {Unclassifed circumfix on an unmarked stem} +Partial_1 = circumPfx Partial_2 circumSfx + | percolation + = + | constraint + = unknown + rule {Unclassifed circumfix on an unmarked stem where second is an infix} + Partial_1 = circumPfx_1 circumPfx_2 Partial_2 + | percolation + = + | constraint + = unknown + | rightmost "prefix" must be an infix + == [morphType : infix] + +rule {An unanalyzed prefix added to a sequence of prefixes; no compound rules} + Prefs_1 = prefix (Prefs_2) + | no percolation or constraints + +rule {A derivational prefix added to a sequence of prefixes; the derivational prefix may be next to the stem} + Prefs_1 = derivPfx (Prefs_2) + | no percolation or constraints + +rule {An unanalyzed suffix added to a sequence of suffixes; no compound rules} + Suffs_1 = (Suffs_2) suffix + | no percolation or constraints + +rule {A derivational suffix added to a sequence of suffixes; the derivational suffix may be next to the stem} + Suffs_1 = (Suffs_2) derivSfx + | no percolation or constraints + + | affixes on otherwise fully analyzed + | these never allow derivational affixes next to the stem +rule {One or more unanalyzed prefixes and suffixes on a fully analyzed stem} + Partial = Prefixes Full Suffixes + | percolation + = + = + | constraints + + { + + = + = + = + = + / + = 6433 + = 6433 + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {One or more unanalyzed prefixes on a fully analyzed stem} + Partial = Prefixes Full + | percolation + = + = + | constraints + + { + + = + = + / + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {One or more unanalyzed suffixes on a fully analyzed stem} + Partial = Full Suffixes + | percolation + = + = + | constraints + + { + + = + = + / + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {Unanalyzed circumfix on a fully analyzed stem} + Partial = circumPfx Full circumSfx + | percolation + = + = + | constraints + + { + + = + = + = + = + / + = 6433 + = 6433 + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + | (Note: we do not allow for a derivational circumfix to attach to a Full in order to produce a partial - that would be an error.) +rule {Unanalyzed circumfix on a fully analyzed stem where second is an infix} + Partial = circumPfx_1 circumPfx_2 Full + | percolation + = + = + | constraints + | rightmost "prefix" must be an infix + == [morphType : infix] + + { + + = + = + = + = + / + = 6433 + = 6433 + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + | (Note: we do not allow for a derivational circumfix to attach to a Full in order to produce a partial - that would be an error.) + + | affixes on partial with non-final inflection +rule {One or more unanalyzed prefixes and suffixes on partial} + Partial_1 = Prefs Partial_2 Suffs + | percolation + = + = + | constraints + == ~[synCat:unknown] + +rule {One or more unanalyzed prefixes on partial} + Partial_1 = Prefs Partial_2 + | percolation + = + = + | constraints + == ~[synCat:unknown] + +rule {One or more unanalyzed suffixes on partial} + Partial_1 = Partial_2 Suffs + | percolation + = + = + | constraints + == ~[synCat:unknown] + +rule {Unanalyzed circumfix on partial} + Partial_1 = circumPfx Partial_2 circumSfx + | percolation + = + = + | constraints + == ~[synCat:unknown] +rule {Unanalyzed circumfix on partial, where second part is an infix} + Partial_1 = circumPfx_1 circumPfx_2 Partial_2 + | percolation + = + = + | constraints + == ~[synCat:unknown] + | rightmost "prefix" must be an infix + == [morphType : infix] + +rule {Derivational circumfix on partial} + Partial_1 = derivCircumPfx Partial_2 derivCircumSfx + | percolation + = + = + | constraints + == ~[synCat:unknown] +rule {Derivational circumfix on partial, where second part is an infix} + Partial_1 = derivCircumPfx_1 derivCircumPfx_2 Partial_2 + | percolation + = + = + | constraints + == ~[synCat:unknown] + | rightmost "prefix" must be an infix + == [morphType : infix] + +rule {An unanalyzed prefix added to a sequence of prefixes} + Prefixes_1 = prefix (Prefixes_2) + | percolation + = | keep the same category + | constraints + + { + + = + / + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {A derivational prefix added to a sequence of prefixes; the derivational cannot be next to the stem} + Prefixes_1 = derivPfx Prefixes_2 + | percolation + = + | constraints + { + + = + / + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {A derivational prefix added to a partial analysis} +Partial_1 = derivPfx Partial_2 + | percolation + = + | constraints +{ + + = + = + / + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {An unanalyzed suffix added to a sequence of suffixes} + Suffixes_1 = (Suffixes_2) suffix + | percolation + = | keep the same category + | constraints + + { + + = + / + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {A derivational suffix added to a sequence of suffixes; the derivational cannot be next to the stem} + Suffixes_1 = Suffixes_2 derivSfx + | percolation + = + | constraints + { + + = + / + = 6433 +{ + + = 6433 / + = 6354 +} + + } + +rule {A derivational suffix added to a partial analysis} +Partial_1 = Partial_2 derivSfx + | percolation + = + | constraints +{ + + = + = + / + = 6433 + = 6433 +{ + + = 6433 / + = 6354 +} + + } + + +rule {Partially analyzed stem that's been inflected with empty template} + Partial = PartialInflected + | percolation + = + | constraints + = + = + + = + + = + + + +| ------------------------------------------------------------ +| TEMPLATES +| ------------------------------------------------------------ +Let W be [] +Let W/W be [] +Let Prt be [] +Let Linker be [] +Let Proclitic be [] +Let Enclitic be [] +Let Bound be [] + +Let ExcpFeat6638Plus be [exception:[6638:+]] +Let ExcpFeat6638Minus be [exception:[6638:-]] +Let FromExcpFeat6638Plus be [fromException:[6638:+]] +Let FromExcpFeat6638Minus be [fromException:[6638:-]] + +Let ToExcpFeat6638Plus be [toException:[6638:+ 7041:!- 2602:!- ]] +Let ToExcpFeat6638Minus be [toException:[6638:-]] +Let ExcpFeat7041Plus be [exception:[7041:+]] +Let ExcpFeat7041Minus be [exception:[7041:-]] +Let FromExcpFeat7041Plus be [fromException:[7041:+]] +Let FromExcpFeat7041Minus be [fromException:[7041:-]] + +Let ToExcpFeat7041Plus be [toException:[7041:+ 6638:!- 2602:!- ]] +Let ToExcpFeat7041Minus be [toException:[7041:-]] +Let ExcpFeat2602Plus be [exception:[2602:+]] +Let ExcpFeat2602Minus be [exception:[2602:-]] +Let FromExcpFeat2602Plus be [fromException:[2602:+]] +Let FromExcpFeat2602Minus be [fromException:[2602:-]] + +Let ToExcpFeat2602Plus be [toException:[2602:+ 6638:!- 7041:!- ]] +Let ToExcpFeat2602Minus be [toException:[2602:-]] +Let DefaultExcpFeatures be [exception:[6638:!- 7041:!- 2602:!- ]] + +Let RootPOS0 be [rootCat:unknown] +Let CliticPOS0 be [rootCat:unknown] +Let RootPOS2838 be [rootCat:2838 + requiresInflection : -] [DefaultExcpFeatures] +Let MSEnvPOS2838 be {[envCat:2838]} +Let FromPOS2838 be [fromCat:2838] + +Let ToPOS2838 be [toCat:2838 + requiresInflection : -] +Let CliticPOS2838 be {[rootCat:2838]} +Let CFP2838 be {[fromCat:2838]} +Let RootPOS6584 be [rootCat:6584 + requiresInflection : -] [DefaultExcpFeatures] +Let MSEnvPOS6584 be {[envCat:6584]} +Let FromPOS6584 be [fromCat:6584] + +Let ToPOS6584 be [toCat:6584 + requiresInflection : -] +Let CliticPOS6584 be {[rootCat:6584]} +Let CFP6584 be {[fromCat:6584]} +Let RootPOS6433 be [rootCat:6433 + requiresInflection : -] [DefaultExcpFeatures] +Let MSEnvPOS6433 be {[envCat:6433][envCat:6354]} +Let FromPOS6433 be [fromCat:6433] + +Let ToPOS6433 be [toCat:6433 + requiresInflection : -] +Let CliticPOS6433 be {[rootCat:6433][rootCat:6354]} +Let CFP6433 be {[fromCat:6433][fromCat:6354]} +Let RootPOS6354 be [rootCat:6354 + requiresInflection : -] [DefaultExcpFeatures] +Let MSEnvPOS6354 be {[envCat:6354]} +Let FromPOS6354 be [fromCat:6354] + +Let ToPOS6354 be [toCat:6354 + requiresInflection : -] +Let CliticPOS6354 be {[rootCat:6354]} +Let CFP6354 be {[fromCat:6354]} +Let RootPOS5355 be [rootCat:5355 + requiresInflection : -] [DefaultExcpFeatures] +Let MSEnvPOS5355 be {[envCat:5355]} +Let FromPOS5355 be [fromCat:5355] + +Let ToPOS5355 be [toCat:5355 + requiresInflection : -] +Let CliticPOS5355 be {[rootCat:5355]} +Let CFP5355 be {[fromCat:5355]} + + + + +Let IrregInflForm65 be [] +Let IrregInflForm5211 be [] +Let IrregInflForm6356 be [] +Let Infix be [morphType:infix] +Let prefixinginterfix be {[cat:prefix] + [cat:interfix]} +Let suffixinginterfix be {[cat:suffix] + [cat:interfix]} diff --git a/Src/LexText/ParserUI/HCTrace.cs b/Src/LexText/ParserUI/HCTrace.cs index be61fabf00..6f5cfb7417 100644 --- a/Src/LexText/ParserUI/HCTrace.cs +++ b/Src/LexText/ParserUI/HCTrace.cs @@ -4,6 +4,7 @@ using System; using System.IO; +using System.Linq; using System.Xml.Linq; using System.Xml.Xsl; using SIL.LCModel; @@ -26,6 +27,7 @@ private static ParserTraceUITransform TraceTransform public string CreateResultPage(PropertyTable propertyTable, XDocument result, bool isTrace) { + result = FixAnyDoubleQuotes(result); var args = new XsltArgumentList(); var loadErrorUri = new Uri(Path.Combine(Path.GetTempPath(), propertyTable.GetValue("cache").ProjectId.Name + "HCLoadErrors.xml")); @@ -33,5 +35,25 @@ public string CreateResultPage(PropertyTable propertyTable, XDocument result, bo args.AddParam("prmShowTrace", "", isTrace.ToString().ToLowerInvariant()); return TraceTransform.Transform(propertyTable, result, isTrace ? "HCTrace" : "HCParse", args); } + + /// + /// Convert any &quot; sequences in the form to " so it displays correctly + /// + /// The HermitCrab XML result + /// Corrected result + private static XDocument FixAnyDoubleQuotes(XDocument result) + { + var forms = result.Descendants("Wordform"); + var form = forms.FirstOrDefault(); + if (form != null) + { + var attr = form.Attribute("form"); + if (attr != null) + { + result = XAmpleTrace.FixAnyDoubleQuotes(result, attr.Value); + } + } + return result; + } } } diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep00.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep00.xml new file mode 100644 index 0000000000..5965293339 --- /dev/null +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep00.xml @@ -0,0 +1,30 @@ + + +
dagslurp
+ + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep01.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep01.xml new file mode 100644 index 0000000000..200d96570a --- /dev/null +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep01.xml @@ -0,0 +1,124 @@ + + +
dagslurp
+ + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + Left-headed noun incorporation + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'n'. + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + Verb OK with Adverb + + + + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'v'. + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + \ No newline at end of file diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep02.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep02.xml new file mode 100644 index 0000000000..152148b63f --- /dev/null +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/dagslurpStep02.xml @@ -0,0 +1,276 @@ + + +
dagslurp
+ + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + Left-headed noun incorporation + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + Verb OK with Adverb + + + + + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + Left-headed noun incorporation + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'v'. + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'n'. + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + Verb OK with Adverb + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'n'. + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'v'. + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + Left-headed noun incorporation + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + Verb OK with Adverb + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'n'. + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + Verb OK with Adverb + + + + + + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + Left-headed noun incorporation + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'v'. + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'n'. + + RootPOS6604 ExcpFeat6658Plus + dag (dog): dag + dag + dog + dag + + + Left-headed noun incorporation + + + + + + A root can only be a "Partial" when its category is unknown, but the category here is 'v'. + + RootPOS5375 ExcpFeat2891Plus + slurp (drink): slurp + slurp + drink + slurp + + + Verb OK with Adverb + + + + + + \ No newline at end of file diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03.xml index f1c843d2c4..50800a4db1 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03.xml @@ -13,12 +13,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (n) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - @@ -53,21 +47,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -102,21 +84,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -182,21 +152,9 @@ In applying the compound rule "noun-transitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -231,21 +189,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -342,12 +288,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (n) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - @@ -382,21 +322,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -431,21 +359,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -511,21 +427,9 @@ In applying the compound rule "noun-transitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -560,21 +464,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03BadCats.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03BadCats.xml index 1d4474d69c..a17ae3f1b6 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03BadCats.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/nihinlikximuraStep03BadCats.xml @@ -13,12 +13,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - @@ -53,21 +47,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -102,21 +84,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -151,12 +121,6 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - @@ -191,21 +155,9 @@ In applying the compound rule "noun-transitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -240,21 +192,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -352,12 +292,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - @@ -392,21 +326,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -441,21 +363,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -490,12 +400,6 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - @@ -530,21 +434,9 @@ In applying the compound rule "noun-transitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -579,21 +471,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - lik (to.eat): hinliksa - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03.xml index a9dbb2004d..bfddacc39f 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03.xml @@ -9,12 +9,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (adv) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -45,21 +39,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -90,21 +72,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -135,21 +105,9 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "verb-adverb ": The category (adv) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -180,12 +138,6 @@ In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -299,12 +251,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (adv) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -335,21 +281,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -380,21 +314,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -425,21 +347,9 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "verb-adverb ": The category (adv) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -470,12 +380,6 @@ In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03BadCats.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03BadCats.xml index 5696484aba..369708620a 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03BadCats.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyalonadkoStep03BadCats.xml @@ -9,21 +9,9 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (adv) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -54,21 +42,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -99,21 +75,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -144,21 +108,9 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "verb-adverb ": The category (adv) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -189,21 +141,9 @@ In applying the compound rule "noun-transitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (intrans) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -234,12 +174,6 @@ In applying the compound rule "noun-Intransitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - @@ -326,12 +260,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (adv) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -362,21 +290,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -407,21 +323,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -452,21 +356,9 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "verb-adverb ": The category (adv) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -497,12 +389,6 @@ In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - nad (to.sleep): nadra - - - @@ -533,12 +419,6 @@ In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - nad (to.sleep): nadra - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03.xml index 54439f8cc2..714a72cc37 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03.xml @@ -36,21 +36,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -81,21 +69,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -126,12 +102,6 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - @@ -162,12 +132,6 @@ In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -198,12 +162,6 @@ In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -317,21 +275,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -362,21 +308,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -407,12 +341,6 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - @@ -443,12 +371,6 @@ In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -479,12 +401,6 @@ In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03BadCats.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03BadCats.xml index b8fbffaf26..12117ecc5f 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03BadCats.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyaloximuraStep03BadCats.xml @@ -9,12 +9,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (adv) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -45,21 +39,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -90,21 +72,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -135,21 +105,9 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (n) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "verb-adverb ": The category (adv) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -180,12 +138,6 @@ In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -216,12 +168,6 @@ In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (huh?) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -308,12 +254,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - @@ -344,21 +284,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (adv) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -389,21 +317,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "adj-noun with linker ": The category (n) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -434,12 +350,6 @@ In applying the compound rule "verb-adverb ": The category (v) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - @@ -470,21 +380,9 @@ In applying the compound rule "noun-transitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - @@ -515,21 +413,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (n) of the left-hand member of the compound rule is incompatible with the category (huh?) of the left-hand stem: - - - yalo (mat): yalo - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (adv) of the right-hand stem: - - - ximu (slowly): ximu - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwupeStemNameNotSetCompoundFailStep02Result.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwupeStemNameNotSetCompoundFailStep02Result.xml index b3fc4f534d..24a29b91df 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwupeStemNameNotSetCompoundFailStep02Result.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwupeStemNameNotSetCompoundFailStep02Result.xml @@ -138,16 +138,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (N) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - @@ -212,28 +202,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (Adv) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (N) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - @@ -298,28 +269,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "adj-noun with linker ": The category (N) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - @@ -446,28 +398,9 @@ In applying the compound rule "noun-transitive verb ": The category (N) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - @@ -532,28 +465,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (N) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwusaStemNameSetCompoundStep02Result.xml b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwusaStemNameSetCompoundStep02Result.xml index 60e6def4fa..7021c624af 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwusaStemNameSetCompoundStep02Result.xml +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingInputsAndResults/niyuyiyximuwusaStemNameSetCompoundStep02Result.xml @@ -152,16 +152,6 @@ In applying the compound rule "noun-adverb -> intransitive verb, ic:2": The category (N) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - @@ -233,28 +223,9 @@ In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (Adv) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "adverb-noun --> intransitive verb, ic:2": The category (N) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - @@ -326,28 +297,9 @@ In applying the compound rule "adj-noun with linker ": The category (adj) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "adj-noun with linker ": The category (N) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - @@ -488,28 +440,9 @@ In applying the compound rule "noun-transitive verb ": The category (N) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "noun-transitive verb ": The category (trans) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - @@ -581,28 +514,9 @@ In applying the compound rule "noun-Intransitive verb ": The category (N) of the left-hand member of the compound rule is incompatible with the category (trans) of the left-hand stem: - - - yiy (testing): wow - yiy - Present tense or 2nd Person - testing - wow - - - In applying the compound rule "noun-Intransitive verb ": The category (intrans) of the right-hand member of the compound rule is incompatible with the category (Adv) of the right-hand stem: - - - ximu (slowly): ximu - ximu - slowly - ximu - - - diff --git a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingTests.cs b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingTests.cs index 2d8b0a568f..864c4cc982 100644 --- a/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingTests.cs +++ b/Src/LexText/ParserUI/ParserUITests/WordGrammarDebuggingTests.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2003-2024 SIL International +// Copyright (c) 2003-2025 SIL International // This software is licensed under the LGPL, version 2.1 or later // (http://www.gnu.org/licenses/lgpl-2.1.html) @@ -302,6 +302,9 @@ public void StemEqualsRoot() // Exocentric ApplyTransform("niyaloximuraStep00.xml", "niyaloximuraStep01.xml"); ApplyTransform("niyaloximuraStep01.xml", "niyaloximuraStep02.xml"); + // Compound rule with exception "features" + ApplyTransform("dagslurpStep00.xml", "dagslurpStep01.xml"); + ApplyTransform("dagslurpStep01.xml", "dagslurpStep02.xml"); // Inflectional templates ApplyTransform("biliStep00BadInflection.xml", "biliStep01BadInflection.xml"); // required prefix slot, optional prefix slot, stem, optional suffix slots diff --git a/Src/LexText/ParserUI/TryAWordDlg.cs b/Src/LexText/ParserUI/TryAWordDlg.cs index 3eac2c4afe..6cc603ee6b 100644 --- a/Src/LexText/ParserUI/TryAWordDlg.cs +++ b/Src/LexText/ParserUI/TryAWordDlg.cs @@ -418,6 +418,7 @@ public void TryIt() sWord = new System.Xml.Linq.XText(sWord).ToString(); // LT-10373 XML special characters cause a crash; change it so HTML/XML works sWord = sWord.Replace("\"", """); // LT-10373 same for double quote sWord = sWord.Replace(' ', '.'); // LT-7334 to allow for phrases; do this at the last minute + sWord = sWord.Replace("\"", """); // LT-10373 a double quote causes a crash; change it so HTML/XML works m_parserListener.Connection.TryAWordDialogIsRunning = true; // make sure this is set properly m_tryAWordResult = m_parserListener.Connection.BeginTryAWord(sWord, DoTrace, selectedTraceMorphs); // waiting for result, so disable Try It button @@ -445,6 +446,7 @@ private void CreateResultPage(XDocument result) else { IParserTrace trace = null; + switch (m_cache.LanguageProject.MorphologicalDataOA.ActiveParser) { case "XAmple": diff --git a/Src/LexText/ParserUI/XAmpleTrace.cs b/Src/LexText/ParserUI/XAmpleTrace.cs index 3213389f35..1a9cc99dc6 100644 --- a/Src/LexText/ParserUI/XAmpleTrace.cs +++ b/Src/LexText/ParserUI/XAmpleTrace.cs @@ -13,6 +13,7 @@ // XAmpleTrace - Deal with results of an XAmple trace // +using System.Linq; using System.Xml.Linq; using XCore; @@ -60,6 +61,7 @@ public string CreateResultPage(PropertyTable propertyTable, XDocument result, bo { transform = TraceTransform; baseName = "XAmpleTrace"; + result = FixAnyDoubleQuotes(result); } else { @@ -68,5 +70,35 @@ public string CreateResultPage(PropertyTable propertyTable, XDocument result, bo } return transform.Transform(propertyTable, result, baseName); } + + /// + /// Convert any &quot; sequences in the form to " so it displays correctly + /// + /// The XAmple XML result + /// Corrected result + private static XDocument FixAnyDoubleQuotes(XDocument result) + { + var forms = result.Descendants("form"); + var elem = forms.FirstOrDefault(); + if (elem != null) + { + result = FixAnyDoubleQuotes(result, elem.Value); + } + return result; + } + + public static XDocument FixAnyDoubleQuotes(XDocument result, string nodeValue) + { + if (nodeValue != null && nodeValue.Contains(""")) + { + // The Contains method above compared to what is replaced below appears odd + // but what is really "&quot;" is treated as """ in the node. + string fixedQuote = result.ToString().Replace("&quot;", """); + XDocument fixedResult = XDocument.Parse(fixedQuote); + result = fixedResult; + } + + return result; + } } } diff --git a/Src/Transforms/Application/FxtM3MorphologySketch.xsl b/Src/Transforms/Application/FxtM3MorphologySketch.xsl index 5f25bf4c11..4b7fa4c41c 100644 --- a/Src/Transforms/Application/FxtM3MorphologySketch.xsl +++ b/Src/Transforms/Application/FxtM3MorphologySketch.xsl @@ -1023,6 +1023,8 @@ Main template

+ + @@ -1042,6 +1044,18 @@ Main template + + + + + + + + + + + + @@ -1244,7 +1258,7 @@ Main template

- + @@ -5506,6 +5520,54 @@ OutputPOSAsNameWithRef + + + + +

+ The + + stem must be marked with + + + + at least one of the following exception"features": + + ' + + + + ' + + + , + + + and + + + . + + + + + + the ' + + + + ' exception "feature." + + +

+ <Stem_1 blocksInflection> = - | This stem can now be inflected | constraints - + + + + + <Stem_2> == + + [exception:[ + + :+]] + + / + + + + + + + <Stem_3> == + + [exception:[ + + :+]] + + / + + + <Stem_1 exception > <= + diff --git a/Src/Transforms/Application/FxtM3ParserToXAmpleWordGrammarDebuggingXSLT.xsl b/Src/Transforms/Application/FxtM3ParserToXAmpleWordGrammarDebuggingXSLT.xsl index 15fb6afa53..1e00e8ba29 100644 --- a/Src/Transforms/Application/FxtM3ParserToXAmpleWordGrammarDebuggingXSLT.xsl +++ b/Src/Transforms/Application/FxtM3ParserToXAmpleWordGrammarDebuggingXSLT.xsl @@ -22,8 +22,9 @@ Preamble - - @@ -1187,6 +1188,8 @@ Ignore text template + + @@ -2049,7 +2052,99 @@ Ignore text template - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + TestProdRestricts + Params: stemProdRestricts + memberProdRestricts + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + TestCompatibleProdRestricts + + stemProdRestricts + + + memberProdRestricts + + + + $memberProdRestricts = ',' + + $sSuccess + + + + + TestCompatibleProdRestrict + + sList + $stemProdRestricts + + + memberProdRestricts + $memberProdRestricts + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + TestProdRestrict + Params: sList + memberProdRestricts + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + TestCompatibleProdRestrict + + sList + + + memberProdRestricts + + + string-length($sList) > 0 + + sFirst + substring-before(substring($sList,1),',') + + + sRest + substring-after(substring($sList,1),',') + + + string-length($sFirst) > 0 + + + contains($memberProdRestricts,$sFirst) + + $sSuccess + + + + + TestCompatibleProdRestrict + + sList + $sRest + + + memberProdRestricts + $memberProdRestricts + + + + + + + + + @@ -2124,21 +2219,196 @@ Ignore text template $sLeftCategoriesAreCompatible = $sSuccess and $sRightCategoriesAreCompatible = $sSuccess - - ApplyCompoundRule - - LeftMember - $LeftMember - - - RightMember - $RightMember - - - sRuleHvo - - - + + sLeftProdRestrictCompatible + + TestCompatibleProdRestricts + + stemProdRestricts + , + + productivityRestriction + + @id + + , + + + + memberProdRestricts + , + + + , + + + + + + sRightProdRestrictCompatible + + TestCompatibleProdRestricts + + stemProdRestricts + , + + following-sibling::stem/productivityRestriction + + @id + + , + + + + memberProdRestricts + , + + + , + + + + + + + $sLeftProdRestrictCompatible = $sSuccess and $sRightProdRestrictCompatible = $sSuccess + + ApplyCompoundRule + + LeftMember + $LeftMember + + + RightMember + $RightMember + + + sRuleHvo + + + + + + + $sLeftProdRestrictCompatible != $sSuccess + + ReportCompoundRuleFailure + + sPreface + In applying the compound rule " + + ": + + + sFirstItemComponent + exception 'feature(s)' + + + sFirstItemComponentAbbr + + iCount + count(productivityRestriction) + + + productivityRestriction + + name + + + position() < $iCount + , + + + + + sFirstItemDescription + left-hand stem + + + sFirstItemValue + $LeftMember + + + sSecondItemComponent + exception 'feature(s)' + + + sSecondItemComponentAbbr + + + + + , + + + + + sSecondItemDescription + left-hand member of the compound rule + + + + + $sRightProdRestrictCompatible != $sSuccess + + ReportCompoundRuleFailure + + sPreface + In applying the compound rule " + + ": + + + sFirstItemComponent + exception 'feature(s)' + + + sFirstItemComponentAbbr + + iCount + count(following-sibling::stem/productivityRestriction) + + + following-sibling::stem/productivityRestriction + + name + + + position() < $iCount + , + + + + + sFirstItemDescription + right-hand stem + + + sFirstItemValue + $RightMember + + + sSecondItemComponent + exception 'feature(s)' + + + sSecondItemComponentAbbr + + + + + , + + + + + sSecondItemDescription + right-hand member of the compound rule + + + + + @@ -3135,7 +3405,6 @@ Ignore text template : - diff --git a/Src/Transforms/Presentation/FormatHCTrace.xsl b/Src/Transforms/Presentation/FormatHCTrace.xsl index 9989c1b758..5f33277f7d 100644 --- a/Src/Transforms/Presentation/FormatHCTrace.xsl +++ b/Src/Transforms/Presentation/FormatHCTrace.xsl @@ -107,8 +107,8 @@ Main template - - + + @@ -824,6 +824,11 @@ function Toggle(node, path, imgOffset) + + + + + This null affix can only attach to an irregularly inflected form. @@ -1044,7 +1049,7 @@ ShowMorph - + @@ -1245,6 +1250,13 @@ ShowMorph + @@ -1304,6 +1316,56 @@ ShowMorph + + + + + + + The stem has the following + + : + + + + + + + + + + The stem does not have any + + , + + + but this rule only applies when the stem has at least one of the following + + : + + + + + + + and + + + or + + + + + + + +