/** * Iterates through a <code>List</code> of <code>NLGElement</code>s * realisation each element and adding it to the on-going realisation of * this clause. * * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the clause. * @param elementList * the <code>List</code> of <code>NLGElement</code>s to be * realised. * @param function * the <code>DiscourseFunction</code> each element in the list is * to take. If this is <code>null</code> then the function is not * set and any existing discourse function is kept. */ internal static void realiseList(SyntaxProcessor parent, ListElement realisedElement, IList <NLGElement> elementList, DiscourseFunction function) { // AG: Change here: the original list structure is kept, i.e. rather // than taking the elements of the list and putting them in the realised // element, we now add the realised elements to a new list and put that // in the realised element list. This preserves constituency for // orthography and morphology processing later. ListElement realisedList = new ListElement(); NLGElement currentElement = null; foreach (NLGElement eachElement in elementList) { currentElement = parent.realise(eachElement); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, function); if (eachElement.getFeatureAsBoolean(Feature.APPOSITIVE)) { currentElement.setFeature(Feature.APPOSITIVE, true); } // realisedElement.addComponent(currentElement); realisedList.addComponent(currentElement); } } if (realisedList.Children.Any()) { realisedElement.addComponent(realisedList); } }
/** * Realises the verb part of the clause. * * @param phrase * the <code>PhraseElement</code> representing this clause. * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the clause. * @param splitVerb * an <code>NLGElement</code> representing the subjects that * should split the verb * @param verbElement * the <code>NLGElement</code> representing the verb phrase for * this clause. * @param whObj * whether the VP is part of an object WH-interrogative */ private static void realiseVerb(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGElement splitVerb, NLGElement verbElement, bool whObj) { setVerbFeatures(phrase, verbElement); NLGElement currentElement = parent.realise(verbElement); if (currentElement != null) { if (splitVerb == null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.VERB_PHRASE); realisedElement.addComponent(currentElement); } else { if (currentElement is ListElement) { IList <NLGElement> children = currentElement.Children; currentElement = children[0]; currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.VERB_PHRASE); realisedElement.addComponent(currentElement); realisedElement.addComponent(splitVerb); for (int eachChild = 1; eachChild < children.Count; eachChild++) { currentElement = children[eachChild]; currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.VERB_PHRASE); realisedElement.addComponent(currentElement); } } else { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.VERB_PHRASE); if (whObj) { realisedElement.addComponent(currentElement); realisedElement.addComponent(splitVerb); } else { realisedElement.addComponent(splitVerb); realisedElement.addComponent(currentElement); } } } } }
/** * Utility method to set the discourse function for phrase components, * unless set by user * * @param function * the function * @param phrase * the phrase */ private void checkFunction(DiscourseFunction function, NLGElement phrase) { if (!phrase.hasFeature(InternalFeature.DISCOURSE_FUNCTION)) { phrase.setFeature(InternalFeature.DISCOURSE_FUNCTION, function); } }
/** * Checks to see if the phrase is in imperative, infinitive or bare * infinitive form. If it is then no morphology is done on the main verb. * * @param formValue * the <code>Form</code> of the phrase. * @param frontVG * the first verb in the verb group. */ private static void checkImperativeInfinitive(object formValue, NLGElement frontVG) { if ((Form.IMPERATIVE.Equals(formValue) || Form.INFINITIVE.Equals(formValue) || Form.BARE_INFINITIVE.Equals(formValue)) && frontVG != null) { frontVG.setFeature(InternalFeature.NON_MORPH, true); } }
/** * Perform aggregation on a single phrase. This method only works on a * {@link simplenlg.framework.CoordinatedPhraseElement}, in which case it * calls {@link #apply(List)} on the children of the coordinated phrase, * returning a coordinated phrase whose children are the result. * * @param phrase * @return aggregated result */ public virtual NLGElement apply(NLGElement phrase) { NLGElement result = null; if (phrase is CoordinatedPhraseElement) { IList <NLGElement> children = ((CoordinatedPhraseElement)phrase).Children; IList <NLGElement> aggregated = apply(children); if (aggregated.Count == 1) { result = aggregated[0]; } else { result = factory.createCoordinatedPhrase(); foreach (NLGElement agg in aggregated) { ((CoordinatedPhraseElement)result).addCoordinate(agg); } } } if (result != null) { foreach (string feature in phrase.AllFeatureNames) { result.setFeature(feature, phrase.getFeature(feature)); } } return(result); }
/** * Realises the subjects of a passive clause. * * @param phrase * the <code>PhraseElement</code> representing this clause. * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the clause. * @param phraseFactory * the phrase factory to be used. */ private static void addPassiveSubjects(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGFactory phraseFactory) { NLGElement currentElement = null; if (phrase.getFeatureAsBoolean(Feature.PASSIVE)) { IList <NLGElement> allSubjects = phrase.getFeatureAsElementList(InternalFeature.SUBJECTS); if (allSubjects.Any() || phrase.hasFeature(Feature.INTERROGATIVE_TYPE)) { realisedElement.addComponent(parent.realise(phraseFactory.createPrepositionPhrase("by"))); //$NON-NLS-1$ } foreach (NLGElement subject in allSubjects) { subject.setFeature(Feature.PASSIVE, true); if (subject.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)) || subject is CoordinatedPhraseElement) { currentElement = parent.realise(subject); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.SUBJECT); realisedElement.addComponent(currentElement); } } } } }
/** * Adds the <em>be</em> verb to the front of the group. * * @param frontVG * the first verb in the verb group. * @param vgComponents * the stack of verb components in the verb group. * @param frontForm * the form the current front verb is to take. * @return the new element for the front of the group. */ private static NLGElement addBe(NLGElement frontVG, Stack <NLGElement> vgComponents, Form frontForm) { if (frontVG != null) { frontVG.setFeature(Feature.FORM, frontForm); vgComponents.Push(frontVG); } return(new InflectedWordElement("be", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB))); //$NON-NLS-1$ }
/** * Realises the cue phrase for the clause if it exists. * * @param phrase * the <code>PhraseElement</code> representing this clause. * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the clause. */ private static void addCuePhrase(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement) { NLGElement currentElement = parent.realise(phrase.getFeatureAsElement(Feature.CUE_PHRASE)); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.CUE_PHRASE); realisedElement.addComponent(currentElement); } }
/** * Realises the head element of the phrase. * * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param realisedElement * the current realisation of the noun phrase. */ private static void realiseHead(SyntaxProcessor parent, PhraseElement phrase, ListElement realisedElement) { NLGElement head = phrase.getHead(); if (head != null) { if (phrase.hasFeature(Feature.IS_COMPARATIVE)) { head.setFeature(Feature.IS_COMPARATIVE, phrase.getFeature(Feature.IS_COMPARATIVE)); } else if (phrase.hasFeature(Feature.IS_SUPERLATIVE)) { head.setFeature(Feature.IS_SUPERLATIVE, phrase.getFeature(Feature.IS_SUPERLATIVE)); } head = parent.realise(head); head.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.HEAD); realisedElement.addComponent(head); } }
/** * Checks to see if the specifier can be raised and then raises it. In order * to be raised the specifier must be the same on all coordinates. For * example, <em>the cat and the dog</em> will be realised as * <em>the cat and dog</em> while <em>the cat and any dog</em> will remain * <em>the cat and any dog</em>. * * @param children * the <code>List</code> of coordinates in the * <code>CoordinatedPhraseElement</code> */ private static void raiseSpecifier(IList <NLGElement> children) { bool allMatch = true; NLGElement child = children[0]; NLGElement specifier = null; string test = null; if (child != null) { specifier = child.getFeatureAsElement(InternalFeature.SPECIFIER); if (specifier != null) { // AG: this assumes the specifier is an InflectedWordElement or // phrase. // it could be a Wordelement, in which case, we want the // baseform test = (specifier is WordElement) ? ((WordElement)specifier).BaseForm : specifier.getFeatureAsString(LexicalFeature.BASE_FORM); } if (!ReferenceEquals(test, null)) { int index = 1; while (index < children.Count && allMatch) { child = children[index]; if (child == null) { allMatch = false; } else { specifier = child.getFeatureAsElement(InternalFeature.SPECIFIER); string childForm = (specifier is WordElement) ? ((WordElement)specifier).BaseForm : specifier.getFeatureAsString(LexicalFeature.BASE_FORM); if (!test.Equals(childForm)) { allMatch = false; } } index++; } if (allMatch) { for (int eachChild = 1; eachChild < children.Count; eachChild++) { child = children[eachChild]; child.setFeature(InternalFeature.RAISED, true); } } } } }
/** * Elide the leftmost consitutents in the phrase list, that is, all phrases * except the rightmost. */ public virtual void elideLeftmost() { for (int i = phrases.Count - 2; i >= 0; i--) { NLGElement phrase = phrases[i]; if (phrase != null) { phrase.setFeature(Feature.ELIDED, true); } } }
/** * Elide the rightmost constituents in the phrase list, that is, all phrases * except the first. */ public virtual void elideRightmost() { for (int i = 1; i < phrases.Count; i++) { NLGElement phrase = phrases[i]; if (phrase != null) { phrase.setFeature(Feature.ELIDED, true); } } }
/** * Copies the front modifiers of the clause to the list of post-modifiers of * the verb only if the phrase has infinitive form. * * @param phrase * the <code>PhraseElement</code> representing this clause. * @param verbElement * the <code>NLGElement</code> representing the verb phrase for * this clause. */ private static void copyFrontModifiers(PhraseElement phrase, NLGElement verbElement) { IList <NLGElement> frontModifiers = phrase.getFeatureAsElementList(InternalFeature.FRONT_MODIFIERS); object clauseForm = phrase.getFeature(Feature.FORM); // bug fix by Chris Howell (Agfa) -- do not overwrite existing post-mods in the VP if (verbElement != null) { IList <NLGElement> phrasePostModifiers = phrase.getFeatureAsElementList(InternalFeature.POSTMODIFIERS); if (verbElement is PhraseElement) { IList <NLGElement> verbPostModifiers = verbElement.getFeatureAsElementList(InternalFeature.POSTMODIFIERS); foreach (NLGElement eachModifier in phrasePostModifiers) { // need to check that VP doesn't already contain the // post-modifier // this only happens if the phrase has already been realised // and later modified, with realiser called again. In that // case, postmods will be copied over twice if (!verbPostModifiers.Contains(eachModifier)) { ((PhraseElement)verbElement).addPostModifier(eachModifier); } } } } // if (verbElement != null) { // verbElement.setFeature(InternalFeature.POSTMODIFIERS, phrase // .getFeature(InternalFeature.POSTMODIFIERS)); // } if (Form.INFINITIVE.Equals(clauseForm)) { phrase.setFeature(Feature.SUPRESSED_COMPLEMENTISER, true); foreach (NLGElement eachModifier in frontModifiers) { if (verbElement is PhraseElement) { ((PhraseElement)verbElement).addPostModifier(eachModifier); } } phrase.removeFeature(InternalFeature.FRONT_MODIFIERS); if (verbElement != null) { verbElement.setFeature(InternalFeature.NON_MORPH, true); } } }
// intercept and override setFeature, to set VP features as needed /** * adds a feature, possibly to the underlying VP as well as the SPhraseSpec * itself * * @see simplenlg.framework.NLGElement#setFeature(java.lang.String, * java.lang.Object) */ public override void setFeature(string featureName, object featureValue) { base.setFeature(featureName, featureValue); if (vpFeatures.Contains(featureName)) { NLGElement verbPhrase = (NLGElement)getFeatureAsElement(InternalFeature.VERB_PHRASE); if (verbPhrase != null || verbPhrase is VPPhraseSpec) { verbPhrase.setFeature(featureName, featureValue); } } }
public virtual void testTwoPossessiveFeature_PastTense() { phraseFactory.Lexicon = lexicon; // Create the pronoun 'she' NLGElement she = phraseFactory.createWord("she", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN)); // Set possessive on the pronoun to make it 'her' she.setFeature(Feature.POSSESSIVE, true); // Create a noun phrase with the subject lover and the determiner as she PhraseElement herLover = phraseFactory.createNounPhrase(she, "lover"); herLover.Plural = true; // Create the pronoun 'he' NLGElement he = phraseFactory.createNounPhrase(new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN), "he"); he.Plural = true; // Create a clause to say 'they be her lovers' PhraseElement clause = phraseFactory.createClause(he, "be", herLover); clause.setFeature(Feature.POSSESSIVE, true); // Add the cue phrase need the comma as orthography // currently doesn't handle this. // This could be expanded to be a noun phrase with determiner // 'two' and noun 'week', set to plural and with a premodifier of // 'after' clause.setFeature(Feature.CUE_PHRASE, "after two weeks,"); // Add the 'for a fortnight' as a post modifier. Alternatively // this could be added as a prepositional phrase 'for' with a // complement of a noun phrase ('a' 'fortnight') clause.addPostModifier("for a fortnight"); // Set 'be' to 'was' as past tense clause.setFeature(Feature.TENSE, Tense.PAST); // Add the clause to a sentence. DocumentElement sentence1 = docFactory.createSentence(clause); // Realise the sentence NLGElement realised = realiser.realise(sentence1); Assert.AreEqual("After two weeks, they were her lovers for a fortnight.", realised.Realisation); //$NON-NLS-1$ }
private void recursiveElide(NLGElement component) { if (component is ListElement) { foreach (NLGElement subcomponent in component.getFeatureAsElementList(InternalFeature.COMPONENTS)) { recursiveElide(subcomponent); } } else { component.setFeature(Feature.ELIDED, true); } }
/* * (non-Javadoc) * * @see simplenlg.framework.NLGElement#setFeature(java.lang.String, boolean) */ public override void setFeature(string featureName, bool featureValue) { base.setFeature(featureName, featureValue); if (vpFeatures.Contains(featureName)) { //PhraseElement verbPhrase = (PhraseElement) getFeatureAsElement(InternalFeature.VERB_PHRASE); //AG: bug fix: VP could be coordinate phrase, so cast to NLGElement not PhraseElement NLGElement verbPhrase = (NLGElement)getFeatureAsElement(InternalFeature.VERB_PHRASE); if (verbPhrase != null || verbPhrase is VPPhraseSpec) { verbPhrase.setFeature(featureName, featureValue); } } }
/** * Pushes the front verb on to the stack if the phrase has a modal. * * @param hasModal * the phrase has a modal * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param frontVG * the first verb in the verb group. * @param vgComponents * the stack of verb components in the verb group. * @return the new element for the front of the group. */ private static NLGElement pushIfModal(bool hasModal, PhraseElement phrase, NLGElement frontVG, Stack <NLGElement> vgComponents) { NLGElement newFront = frontVG; if (hasModal && !phrase.getFeatureAsBoolean(InternalFeature.IGNORE_MODAL)) { if (frontVG != null) { frontVG.setFeature(InternalFeature.NON_MORPH, true); vgComponents.Push(frontVG); } newFront = null; } return(newFront); }
/** * Realises the auxiliary verbs in the verb group. * * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the noun phrase. * @param auxiliaryRealisation * the stack of auxiliary verbs. */ private static void realiseAuxiliaries(SyntaxProcessor parent, ListElement realisedElement, Stack <NLGElement> auxiliaryRealisation) { NLGElement aux = null; NLGElement currentElement = null; while (auxiliaryRealisation.Any()) { aux = auxiliaryRealisation.Pop(); currentElement = parent.realise(aux); if (currentElement != null) { realisedElement.addComponent(currentElement); currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.AUXILIARY); } } }
/** * Realises the main group of verbs in the phrase. * * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param mainVerbRealisation * the stack of the main verbs in the phrase. * @param realisedElement * the current realisation of the noun phrase. */ private static void realiseMainVerb(SyntaxProcessor parent, PhraseElement phrase, Stack <NLGElement> mainVerbRealisation, ListElement realisedElement) { NLGElement currentElement = null; NLGElement main = null; while (mainVerbRealisation.Any()) { main = mainVerbRealisation.Pop(); main.setFeature(Feature.INTERROGATIVE_TYPE, phrase.getFeature(Feature.INTERROGATIVE_TYPE)); currentElement = parent.realise(main); if (currentElement != null) { realisedElement.addComponent(currentElement); } } }
/** * Realises the complements of this phrase. * * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param realisedElement * the current realisation of the noun phrase. */ private static void realiseComplements(SyntaxProcessor parent, PhraseElement phrase, ListElement realisedElement) { ListElement indirects = new ListElement(); ListElement directs = new ListElement(); ListElement unknowns = new ListElement(); object discourseValue = null; NLGElement currentElement = null; foreach (NLGElement complement in phrase.getFeatureAsElementList(InternalFeature.COMPLEMENTS)) { discourseValue = complement.getFeature(InternalFeature.DISCOURSE_FUNCTION); currentElement = parent.realise(complement); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.COMPLEMENT); if (DiscourseFunction.INDIRECT_OBJECT.Equals(discourseValue)) { indirects.addComponent(currentElement); } else if (DiscourseFunction.OBJECT.Equals(discourseValue)) { directs.addComponent(currentElement); } else { unknowns.addComponent(currentElement); } } } InterrogativeType?interrogativeType = (InterrogativeType?)phrase.getFeature(Feature.INTERROGATIVE_TYPE); if (interrogativeType == null || !((InterrogativeType)interrogativeType).isIndirectObject()) { realisedElement.addComponents(indirects.Children); } if (!phrase.getFeatureAsBoolean(Feature.PASSIVE)) { if (interrogativeType == null || !((InterrogativeType)interrogativeType).isObject()) { realisedElement.addComponents(directs.Children); } realisedElement.addComponents(unknowns.Children); } }
/** * Adds <em>have</em> to the stack. * * @param frontVG * the first verb in the verb group. * @param vgComponents * the stack of verb components in the verb group. * @param modal * the modal to be used. * @param tenseValue * the <code>Tense</code> of the phrase. * @return the new element for the front of the group. */ private static NLGElement addHave(NLGElement frontVG, Stack <NLGElement> vgComponents, string modal, Tense tenseValue) { NLGElement newFront = frontVG; if (frontVG != null) { frontVG.setFeature(Feature.FORM, Form.PAST_PARTICIPLE); vgComponents.Push(frontVG); } newFront = new InflectedWordElement("have", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)); //$NON-NLS-1$ newFront.setFeature(Feature.TENSE, tenseValue); if (!ReferenceEquals(modal, null)) { newFront.setFeature(InternalFeature.NON_MORPH, true); } return(newFront); }
/** * Realises the head noun of the noun phrase. * * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the noun phrase. */ private static void realiseHeadNoun(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement) { NLGElement headElement = phrase.getHead(); if (headElement != null) { headElement.setFeature(Feature.ELIDED, phrase.getFeature(Feature.ELIDED)); headElement.setFeature(LexicalFeature.GENDER, phrase.getFeature(LexicalFeature.GENDER)); headElement.setFeature(InternalFeature.ACRONYM, phrase.getFeature(InternalFeature.ACRONYM)); headElement.setFeature(Feature.NUMBER, phrase.getFeature(Feature.NUMBER)); headElement.setFeature(Feature.PERSON, phrase.getFeature(Feature.PERSON)); headElement.setFeature(Feature.POSSESSIVE, phrase.getFeature(Feature.POSSESSIVE)); headElement.setFeature(Feature.PASSIVE, phrase.getFeature(Feature.PASSIVE)); headElement.setFeature(Feature.IS_CAPITALIZED, phrase.getFeature(Feature.IS_CAPITALIZED)); NLGElement currentElement = parent.realise(headElement); currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.SUBJECT); realisedElement.addComponent(currentElement); } }
/** * Adds the front modifiers to the end of the clause when dealing with * interrogatives. * * @param phrase * the <code>PhraseElement</code> representing this clause. * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the clause. */ private static void addInterrogativeFrontModifiers(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement) { NLGElement currentElement = null; if (phrase.hasFeature(Feature.INTERROGATIVE_TYPE)) { foreach (NLGElement subject in phrase.getFeatureAsElementList(InternalFeature.FRONT_MODIFIERS)) { currentElement = parent.realise(subject); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.FRONT_MODIFIER); realisedElement.addComponent(currentElement); } } } }
/** * Adds <em>not</em> to the stack if the phrase is negated. * * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param vgComponents * the stack of verb components in the verb group. * @param frontVG * the first verb in the verb group. * @param hasModal * the phrase has a modal * @return the new element for the front of the group. */ private static NLGElement createNot(PhraseElement phrase, Stack <NLGElement> vgComponents, NLGElement frontVG, bool hasModal) { NLGElement newFront = frontVG; if (phrase.getFeatureAsBoolean(Feature.NEGATED)) { NLGFactory factory = phrase.Factory; // before adding "do", check if this is an object WH interrogative // in which case, don't add anything as it's already done by ClauseHelper object interrType = phrase.getFeature(Feature.INTERROGATIVE_TYPE); bool addDo = !(InterrogativeType.WHAT_OBJECT.Equals(interrType) || InterrogativeType.WHO_OBJECT.Equals(interrType)); if (vgComponents.Any() || frontVG != null && isCopular(frontVG)) { vgComponents.Push(new InflectedWordElement("not", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ADVERB))); //$NON-NLS-1$ } else { if (frontVG != null && !hasModal) { frontVG.setFeature(Feature.NEGATED, true); vgComponents.Push(frontVG); } vgComponents.Push(new InflectedWordElement("not", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ADVERB))); //$NON-NLS-1$ if (addDo) { if (factory != null) { newFront = factory.createInflectedWord("do", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)); } else { newFront = new InflectedWordElement("do", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)); //$NON-NLS-1$ } } } } return(newFront); }
/** * Pushes the front verb onto the stack of verb components. * * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param vgComponents * the stack of verb components in the verb group. * @param frontVG * the first verb in the verb group. * @param formValue * the <code>Form</code> of the phrase. * @param interrogative * <code>true</code> if the phrase is interrogative. */ private static void pushFrontVerb(PhraseElement phrase, Stack <NLGElement> vgComponents, NLGElement frontVG, object formValue, bool interrogative) { object interrogType = phrase.getFeature(Feature.INTERROGATIVE_TYPE); if (Form.GERUND.Equals(formValue)) { frontVG.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE); vgComponents.Push(frontVG); } else if (Form.PAST_PARTICIPLE.Equals(formValue)) { frontVG.setFeature(Feature.FORM, Form.PAST_PARTICIPLE); vgComponents.Push(frontVG); } else if (Form.PRESENT_PARTICIPLE.Equals(formValue)) { frontVG.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE); vgComponents.Push(frontVG); } else if ((!(formValue == null || Form.NORMAL.Equals(formValue)) || interrogative) && !isCopular(phrase.getHead()) && vgComponents.Count == 0) { // AG: fix below: if interrogative, only set non-morph feature in // case it's not WHO_SUBJECT OR WHAT_SUBJECT if (!(InterrogativeType.WHO_SUBJECT.Equals(interrogType) || InterrogativeType.WHAT_SUBJECT.Equals(interrogType))) { frontVG.setFeature(InternalFeature.NON_MORPH, true); } vgComponents.Push(frontVG); } else { NumberAgreement?numToUse = determineNumber(phrase.Parent, phrase); frontVG.setFeature(Feature.TENSE, phrase.getFeature(Feature.TENSE)); frontVG.setFeature(Feature.PERSON, phrase.getFeature(Feature.PERSON)); frontVG.setFeature(Feature.NUMBER, numToUse); //don't push the front VG if it's a negated interrogative WH object question if (!(phrase.getFeatureAsBoolean(Feature.NEGATED) && (InterrogativeType.WHO_OBJECT.Equals(interrogType) || InterrogativeType.WHAT_OBJECT.Equals(interrogType)))) { vgComponents.Push(frontVG); } } }
/** * Realises the specifier of the noun phrase. * * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param realisedElement * the current realisation of the noun phrase. */ private static void realiseSpecifier(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement) { NLGElement specifierElement = phrase.getFeatureAsElement(InternalFeature.SPECIFIER); if (specifierElement != null && !phrase.getFeatureAsBoolean(InternalFeature.RAISED) && !phrase.getFeatureAsBoolean(Feature.ELIDED)) { if (!specifierElement.isA(new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN)) && specifierElement.Category != PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE) { specifierElement.setFeature(Feature.NUMBER, phrase.getFeature(Feature.NUMBER)); } NLGElement currentElement = parent.realise(specifierElement); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.SPECIFIER); realisedElement.addComponent(currentElement); } } }
public virtual void correctPluralizationWithPossessives() { NPPhraseSpec sisterNP = nlgFactory.createNounPhrase("sister"); NLGElement word = nlgFactory.createInflectedWord("Albert Einstein", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.NOUN)); word.setFeature(LexicalFeature.PROPER, true); NPPhraseSpec possNP = nlgFactory.createNounPhrase(word); possNP.setFeature(Feature.POSSESSIVE, true); sisterNP.setSpecifier(possNP); Assert.AreEqual("Albert Einstein's sister", realiser.realise(sisterNP).Realisation); sisterNP.Plural = true; Assert.AreEqual("Albert Einstein's sisters", realiser.realise(sisterNP).Realisation); sisterNP.Plural = false; possNP.setFeature(LexicalFeature.GENDER, Gender.MASCULINE); possNP.setFeature(Feature.PRONOMINAL, true); Assert.AreEqual("his sister", realiser.realise(sisterNP).Realisation); sisterNP.Plural = true; Assert.AreEqual("his sisters", realiser.realise(sisterNP).Realisation); }
/** * Realises the complements of the phrase adding <em>and</em> where * appropriate. * * @param parent * the parent <code>SyntaxProcessor</code> that will do the * realisation of the complementiser. * @param phrase * the <code>PhraseElement</code> representing this noun phrase. * @param realisedElement * the current realisation of the noun phrase. */ private static void realiseComplements(SyntaxProcessor parent, PhraseElement phrase, ListElement realisedElement) { bool firstProcessed = false; NLGElement currentElement = null; foreach (NLGElement complement in phrase.getFeatureAsElementList(InternalFeature.COMPLEMENTS)) { currentElement = parent.realise(complement); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.COMPLEMENT); if (firstProcessed) { realisedElement.addComponent(new InflectedWordElement("and", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.CONJUNCTION))); //$NON-NLS-1$ } else { firstProcessed = true; } realisedElement.addComponent(currentElement); } } }
public override NLGElement realise(NLGElement element) { StringBuilder debug = new StringBuilder(); if (this.debug) { Console.WriteLine("INITIAL TREE\n"); //$NON-NLS-1$ Console.WriteLine(element.printTree(null)); debug.Append("INITIAL TREE<br/>"); debug.Append(element.printTree(" ").Replace("\n", "<br/>")); } NLGElement postSyntax = syntax.realise(element); if (this.debug) { Console.WriteLine("<br/>POST-SYNTAX TREE<br/>"); //$NON-NLS-1$ Console.WriteLine(postSyntax.printTree(null)); debug.Append("<br/>POST-SYNTAX TREE<br/>"); debug.Append(postSyntax.printTree(" ").Replace("\n", "<br/>")); } NLGElement postMorphology = morphology.realise(postSyntax); if (this.debug) { Console.WriteLine("\nPOST-MORPHOLOGY TREE\n"); //$NON-NLS-1$ Console.WriteLine(postMorphology.printTree(null)); debug.Append("<br/>POST-MORPHOLOGY TREE<br/>"); debug.Append(postMorphology.printTree(" ").Replace("\n", "<br/>")); } NLGElement postOrthography = orthography.realise(postMorphology); if (this.debug) { Console.WriteLine("\nPOST-ORTHOGRAPHY TREE\n"); //$NON-NLS-1$ Console.WriteLine(postOrthography.printTree(null)); debug.Append("<br/>POST-ORTHOGRAPHY TREE<br/>"); debug.Append(postOrthography.printTree(" ").Replace("\n", "<br/>")); } NLGElement postFormatter = null; if (formatter != null) { postFormatter = formatter.realise(postOrthography); if (this.debug) { Console.WriteLine("\nPOST-FORMATTER TREE\n"); //$NON-NLS-1$ Console.WriteLine(postFormatter.printTree(null)); debug.Append("<br/>POST-FORMATTER TREE<br/>"); debug.Append(postFormatter.printTree(" ").Replace("\n", "<br/>")); } } else { postFormatter = postOrthography; } if (this.debug) { postFormatter.setFeature("debug", debug.ToString()); } return(postFormatter); }