Beispiel #1
0
        /**
         * This method performs the morphology for verbs.
         *
         * @param element
         *            the <code>InflectedWordElement</code>.
         * @param baseWord
         *            the <code>WordElement</code> as created from the lexicon
         *            entry.
         * @return a <code>StringElement</code> representing the word after
         *         inflection.
         */

        public static INLGElement doVerbMorphology(InflectedWordElement element, WordElement baseWord)
        {
            string realised    = null;
            var    numberValue = element.getFeature(Feature.NUMBER.ToString());
            var    personValue = element.getFeature(Feature.PERSON.ToString());
            var    tenseValue  = element.getFeatureTense(Feature.TENSE.ToString());


            var formValue    = element.getFeature(Feature.FORM.ToString());
            var patternValue = element.getFeature(LexicalFeature.DEFAULT_INFL);

            // base form from baseWord if it exists, otherwise from element
            var baseForm = getBaseForm(element, baseWord);

            if (element.getFeatureAsBoolean(Feature.NEGATED.ToString()) || Form.BARE_INFINITIVE.Equals(formValue))
            {
                realised = baseForm;
            }
            else if (Form.PRESENT_PARTICIPLE.Equals(formValue))
            {
                realised = element.getFeatureAsString(LexicalFeature.PRESENT_PARTICIPLE);

                if (realised == null && baseWord != null)
                {
                    realised = baseWord.getFeatureAsString(LexicalFeature.PRESENT_PARTICIPLE);
                }

                if (realised == null)
                {
                    if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
                    {
                        realised = buildDoublePresPartVerb(baseForm);
                    }
                    else
                    {
                        realised = buildRegularPresPartVerb(baseForm);
                    }
                }
            }
            else if (Tense.PAST.Equals(tenseValue) || Form.PAST_PARTICIPLE.Equals(formValue))
            {
                if (Form.PAST_PARTICIPLE.Equals(formValue))
                {
                    realised = element.getFeatureAsString(LexicalFeature.PAST_PARTICIPLE);

                    if (realised == null && baseWord != null)
                    {
                        realised = baseWord.getFeatureAsString(LexicalFeature.PAST_PARTICIPLE);
                    }

                    if (realised == null)
                    {
                        if ("be".equalsIgnoreCase(baseForm))
                        {
                            realised = "been";
                        }
                        else if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
                        {
                            realised = buildDoublePastVerb(baseForm);
                        }
                        else
                        {
                            realised = buildRegularPastVerb(baseForm, numberValue, personValue);
                        }
                    }
                }
                else
                {
                    realised = element.getFeatureAsString(LexicalFeature.PAST);

                    if (realised == null && baseWord != null)
                    {
                        realised = baseWord.getFeatureAsString(LexicalFeature.PAST);
                    }

                    if (realised == null)
                    {
                        if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
                        {
                            realised = buildDoublePastVerb(baseForm);
                        }
                        else
                        {
                            realised = buildRegularPastVerb(baseForm, numberValue, personValue);
                        }
                    }
                }
            }
            else if ((numberValue == null || NumberAgreement.SINGULAR.Equals(numberValue)) && (personValue == null ||
                                                                                               Person.THIRD.Equals(
                                                                                                   personValue)) &&
                     (Tense.PRESENT.Equals(tenseValue)))
            {
                realised = element.getFeatureAsString(LexicalFeature.PRESENT3S);

                if (realised == null && baseWord != null && !"be".equalsIgnoreCase(baseForm))
                {
                    realised = baseWord.getFeatureAsString(LexicalFeature.PRESENT3S);
                }
                if (realised == null)
                {
                    realised = buildPresent3SVerb(baseForm);
                }
            }
            else
            {
                if ("be".equalsIgnoreCase(baseForm))
                {
                    if (Person.FIRST.Equals(personValue) && (NumberAgreement.SINGULAR.Equals(numberValue) ||
                                                             numberValue == null))
                    {
                        realised = "am";
                    }
                    else
                    {
                        realised = "are";
                    }
                }
                else
                {
                    realised = baseForm;
                }
            }
            var realisedElement = new StringElement(realised);

            realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
                                       element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
            return(realisedElement);
        }