/** * The main method for realising noun phrases. * * @param parent * the <code>SyntaxProcessor</code> that called this method. * @param phrase * the <code>PhraseElement</code> to be realised. * @return the realised <code>NLGElement</code>. */ internal static NLGElement realise(SyntaxProcessor parent, PhraseElement phrase) { ListElement realisedElement = null; if (phrase != null && !phrase.getFeatureAsBoolean(Feature.ELIDED)) { realisedElement = new ListElement(); if (phrase.getFeatureAsBoolean(Feature.PRONOMINAL)) { realisedElement.addComponent(createPronoun(parent, phrase)); } else { realiseSpecifier(phrase, parent, realisedElement); realisePreModifiers(phrase, parent, realisedElement); realiseHeadNoun(phrase, parent, realisedElement); PhraseHelper.realiseList(parent, realisedElement, phrase.getFeatureAsElementList(InternalFeature.COMPLEMENTS), DiscourseFunction.COMPLEMENT); PhraseHelper.realiseList(parent, realisedElement, phrase.PostModifiers, DiscourseFunction.POST_MODIFIER); } } return(realisedElement); }
/** * 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); } } } } }
/** * 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); } }
/** * Adds the subjects to the beginning of the clause unless the clause is * infinitive, imperative or passive, or the subjects split the verb. * * @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 */ private static void addSubjectsToFront(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGElement splitVerb) { if (!Form.INFINITIVE.Equals(phrase.getFeature(Feature.FORM)) && !Form.IMPERATIVE.Equals(phrase.getFeature(Feature.FORM)) && !phrase.getFeatureAsBoolean(Feature.PASSIVE) && splitVerb == null) { realisedElement.addComponents(realiseSubjects(phrase, parent).Children); } }
/** * Adds <em>to</em> to the end of interrogatives concerning indirect * objects. For example, <em>who did John give the flower <b>to</b></em>. * * @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 addEndingTo(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGFactory phraseFactory) { if (InterrogativeType.WHO_INDIRECT_OBJECT.Equals(phrase.getFeature(Feature.INTERROGATIVE_TYPE))) { NLGElement word = phraseFactory.createWord("to", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PREPOSITION)); //$NON-NLS-1$ realisedElement.addComponent(parent.realise(word)); } }
/** * Adds a <em>do</em> verb to the realisation of this 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 addDoAuxiliary(PhraseElement phrase, SyntaxProcessor parent, NLGFactory phraseFactory, ListElement realisedElement) { PhraseElement doPhrase = phraseFactory.createVerbPhrase("do"); //$NON-NLS-1$ doPhrase.setFeature(Feature.TENSE, phrase.getFeature(Feature.TENSE)); doPhrase.setFeature(Feature.PERSON, phrase.getFeature(Feature.PERSON)); doPhrase.setFeature(Feature.NUMBER, phrase.getFeature(Feature.NUMBER)); realisedElement.addComponent(parent.realise(doPhrase)); }
/** * Realises the pre-modifiers of the noun phrase. Before being realised, * pre-modifiers undergo some basic sorting based on adjective ordering. * * @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 realisePreModifiers(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement) { IList <NLGElement> preModifiers = phrase.PreModifiers; if (phrase.getFeatureAsBoolean(Feature.ADJECTIVE_ORDERING)) { preModifiers = sortNPPreModifiers(preModifiers); } PhraseHelper.realiseList(parent, realisedElement, preModifiers, DiscourseFunction.PRE_MODIFIER); }
/** * 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); } }
/** * Creates the appropriate pronoun if the subject of the noun phrase is * pronominal. * * @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. * @return the <code>NLGElement</code> representing the pronominal. */ private static NLGElement createPronoun(SyntaxProcessor parent, PhraseElement phrase) { string pronoun = "it"; //$NON-NLS-1$ NLGFactory phraseFactory = phrase.Factory; object personValue = phrase.getFeature(Feature.PERSON); if (Person.FIRST.Equals(personValue)) { pronoun = "I"; //$NON-NLS-1$ } else if (Person.SECOND.Equals(personValue)) { pronoun = "you"; //$NON-NLS-1$ } else { object genderValue = phrase.getFeature(LexicalFeature.GENDER); if (Gender.FEMININE.Equals(genderValue)) { pronoun = "she"; //$NON-NLS-1$ } else if (Gender.MASCULINE.Equals(genderValue)) { pronoun = "he"; //$NON-NLS-1$ } } // AG: createWord now returns WordElement; so we embed it in an // inflected word element here NLGElement element; NLGElement proElement = phraseFactory.createWord(pronoun, new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN)); if (proElement is WordElement) { element = new InflectedWordElement((WordElement)proElement); element.setFeature(LexicalFeature.GENDER, ((WordElement)proElement).getFeature(LexicalFeature.GENDER)); // Ehud - also copy over person element.setFeature(Feature.PERSON, ((WordElement)proElement).getFeature(Feature.PERSON)); } else { element = proElement; } element.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.SPECIFIER); element.setFeature(Feature.POSSESSIVE, phrase.getFeature(Feature.POSSESSIVE)); element.setFeature(Feature.NUMBER, phrase.getFeature(Feature.NUMBER)); if (phrase.hasFeature(InternalFeature.DISCOURSE_FUNCTION)) { element.setFeature(InternalFeature.DISCOURSE_FUNCTION, phrase.getFeature(InternalFeature.DISCOURSE_FUNCTION)); } return(element); }
/** * Pushes the particles of the main verb onto the verb group stack. * * @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 vgComponents * the stack of verb components in the verb group. */ private static void pushParticles(PhraseElement phrase, SyntaxProcessor parent, Stack <NLGElement> vgComponents) { object particle = phrase.getFeature(Feature.PARTICLE); if (particle is string) { vgComponents.Push(new StringElement((string)particle)); } else if (particle is NLGElement) { vgComponents.Push(parent.realise((NLGElement)particle)); } }
/** * The main method for controlling the syntax realisation of clauses. * * @param parent * the parent <code>SyntaxProcessor</code> that called this * method. * @param phrase * the <code>PhraseElement</code> representation of the clause. * @return the <code>NLGElement</code> representing the realised clause. */ internal static NLGElement realise(SyntaxProcessor parent, PhraseElement phrase) { ListElement realisedElement = null; NLGFactory phraseFactory = phrase.Factory; NLGElement splitVerb = null; bool interrogObj = false; if (phrase != null) { realisedElement = new ListElement(); NLGElement verbElement = phrase.getFeatureAsElement(InternalFeature.VERB_PHRASE); if (verbElement == null) { verbElement = phrase.getHead(); } checkSubjectNumberPerson(phrase, verbElement); checkDiscourseFunction(phrase); copyFrontModifiers(phrase, verbElement); addComplementiser(phrase, parent, realisedElement); addCuePhrase(phrase, parent, realisedElement); if (phrase.hasFeature(Feature.INTERROGATIVE_TYPE)) { object inter = phrase.getFeature(Feature.INTERROGATIVE_TYPE); interrogObj = (InterrogativeType.WHAT_OBJECT.Equals(inter) || InterrogativeType.WHO_OBJECT.Equals(inter) || InterrogativeType.HOW_PREDICATE.Equals(inter) || InterrogativeType.HOW.Equals(inter) || InterrogativeType.WHY.Equals(inter) || InterrogativeType.WHERE.Equals(inter)); splitVerb = realiseInterrogative(phrase, parent, realisedElement, phraseFactory, verbElement); } else { PhraseHelper.realiseList(parent, realisedElement, phrase.getFeatureAsElementList(InternalFeature.FRONT_MODIFIERS), DiscourseFunction.FRONT_MODIFIER); } addSubjectsToFront(phrase, parent, realisedElement, splitVerb); NLGElement passiveSplitVerb = addPassiveComplementsNumberPerson(phrase, parent, realisedElement, verbElement); if (passiveSplitVerb != null) { splitVerb = passiveSplitVerb; } // realise verb needs to know if clause is object interrogative realiseVerb(phrase, parent, realisedElement, splitVerb, verbElement, interrogObj); addPassiveSubjects(phrase, parent, realisedElement, phraseFactory); addInterrogativeFrontModifiers(phrase, parent, realisedElement); addEndingTo(phrase, parent, realisedElement, phraseFactory); } return(realisedElement); }
/** * Performs the realisation for YES/NO types of questions. This may involve * adding an optional <em>do</em> auxiliary verb to the beginning of the * clause. The method also determines if there is a subject that will split * the verb group of the clause. For example, the clause * <em>the man <b>should give</b> the woman the flower</em> has the verb * group indicated in <b>bold</b>. The phrase is rearranged as yes/no * question as * <em><b>should</b> the man <b>give</b> the woman the flower</em> with the * subject <em>the man</em> splitting the verb group. * * * @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. * @param verbElement * the <code>NLGElement</code> representing the verb phrase for * this clause. * @param subjects * the <code>List</code> of subjects in the clause. * @return an <code>NLGElement</code> representing a subject that should * split the verb */ private static NLGElement realiseYesNo(PhraseElement phrase, SyntaxProcessor parent, NLGElement verbElement, NLGFactory phraseFactory, ListElement realisedElement) { NLGElement splitVerb = null; if (!(verbElement is VPPhraseSpec && VerbPhraseHelper.isCopular(((VPPhraseSpec)verbElement).getVerb())) && !phrase.getFeatureAsBoolean(Feature.PROGRESSIVE) && !phrase.hasFeature(Feature.MODAL) && !Tense.FUTURE.Equals(phrase.getFeature(Feature.TENSE)) && !phrase.getFeatureAsBoolean(Feature.NEGATED) && !phrase.getFeatureAsBoolean(Feature.PASSIVE)) { addDoAuxiliary(phrase, parent, phraseFactory, realisedElement); } else { splitVerb = realiseSubjects(phrase, parent); } return(splitVerb); }
/** * Checks to see if this clause is a subordinate clause. If it is then the * complementiser is added as a component to the realised element * <b>unless</b> the complementiser has been suppressed. * * @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 addComplementiser(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement) { NLGElement currentElement; if (ClauseStatus.SUBORDINATE.Equals(phrase.getFeature(InternalFeature.CLAUSE_STATUS)) && !phrase.getFeatureAsBoolean(Feature.SUPRESSED_COMPLEMENTISER)) { currentElement = parent.realise(phrase.getFeatureAsElement(Feature.COMPLEMENTISER)); if (currentElement != null) { realisedElement.addComponent(currentElement); } } }
/** * This is the main controlling method for handling interrogative clauses. * The actual steps taken are dependent on the type of question being asked. * The method also determines if there is a subject that will split the verb * group of the clause. For example, the clause * <em>the man <b>should give</b> the woman the flower</em> has the verb * group indicated in <b>bold</b>. The phrase is rearranged as yes/no * question as * <em><b>should</b> the man <b>give</b> the woman the flower</em> with the * subject <em>the man</em> splitting the verb group. * * @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. * @param verbElement * the <code>NLGElement</code> representing the verb phrase for * this clause. * @return an <code>NLGElement</code> representing a subject that should * split the verb */ private static NLGElement realiseInterrogative(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGFactory phraseFactory, NLGElement verbElement) { NLGElement splitVerb = null; if (phrase.Parent != null) { phrase.Parent.setFeature(InternalFeature.INTERROGATIVE, true); } object type = phrase.getFeature(Feature.INTERROGATIVE_TYPE); if (type is InterrogativeType) { switch ((InterrogativeType)type) { case InterrogativeType.YES_NO: splitVerb = realiseYesNo(phrase, parent, verbElement, phraseFactory, realisedElement); break; case InterrogativeType.WHO_SUBJECT: case InterrogativeType.WHAT_SUBJECT: realiseInterrogativeKeyWord(((InterrogativeType)type).getString(), new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN), parent, realisedElement, phraseFactory); //$NON-NLS-1$ phrase.removeFeature(InternalFeature.SUBJECTS); break; case InterrogativeType.HOW_MANY: realiseInterrogativeKeyWord("how", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN), parent, realisedElement, phraseFactory); //$NON-NLS-1$ realiseInterrogativeKeyWord("many", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ADVERB), parent, realisedElement, phraseFactory); //$NON-NLS-1$ break; case InterrogativeType.HOW: case InterrogativeType.WHY: case InterrogativeType.WHERE: case InterrogativeType.WHO_OBJECT: case InterrogativeType.WHO_INDIRECT_OBJECT: case InterrogativeType.WHAT_OBJECT: splitVerb = realiseObjectWHInterrogative(((InterrogativeType)type).getString(), phrase, parent, realisedElement, phraseFactory); break; case InterrogativeType.HOW_PREDICATE: splitVerb = realiseObjectWHInterrogative("how", phrase, parent, realisedElement, phraseFactory); break; default: break; } } return(splitVerb); }
/** * 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); } } } } }
/** * 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 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); } }
/** * 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); } } }
/** * The main method for realising phrases. * * @param parent * the <code>SyntaxProcessor</code> that called this method. * @param phrase * the <code>PhraseElement</code> to be realised. * @return the realised <code>NLGElement</code>. */ internal static NLGElement realise(SyntaxProcessor parent, PhraseElement phrase) { ListElement realisedElement = null; if (phrase != null) { realisedElement = new ListElement(); realiseList(parent, realisedElement, phrase.PreModifiers, DiscourseFunction.PRE_MODIFIER); realiseHead(parent, phrase, realisedElement); realiseComplements(parent, phrase, realisedElement); realiseList(parent, realisedElement, phrase.PostModifiers, DiscourseFunction.POST_MODIFIER); } return(realisedElement); }
/** * 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); } } } }
/** * 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); } }
/** * 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); } }
/** * 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); } } }
/** * Realises the subjects for 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. */ private static ListElement realiseSubjects(PhraseElement phrase, SyntaxProcessor parent) { NLGElement currentElement = null; ListElement realisedElement = new ListElement(); foreach (NLGElement subject in phrase.getFeatureAsElementList(InternalFeature.SUBJECTS)) { subject.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.SUBJECT); if (Form.GERUND.Equals(phrase.getFeature(Feature.FORM)) && !phrase.getFeatureAsBoolean(Feature.SUPPRESS_GENITIVE_IN_GERUND)) { subject.setFeature(Feature.POSSESSIVE, true); } currentElement = parent.realise(subject); if (currentElement != null) { realisedElement.addComponent(currentElement); } } return(realisedElement); }
/** * The main method for realising verb phrases. * * @param parent * the <code>SyntaxProcessor</code> that called this method. * @param phrase * the <code>PhraseElement</code> to be realised. * @return the realised <code>NLGElement</code>. */ internal static NLGElement realise(SyntaxProcessor parent, PhraseElement phrase) { ListElement realisedElement = null; Stack <NLGElement> vgComponents = null; Stack <NLGElement> mainVerbRealisation = new Stack <NLGElement>(); Stack <NLGElement> auxiliaryRealisation = new Stack <NLGElement>(); if (phrase != null) { vgComponents = createVerbGroup(parent, phrase); splitVerbGroup(vgComponents, mainVerbRealisation, auxiliaryRealisation); realisedElement = new ListElement(); if (!phrase.hasFeature(InternalFeature.REALISE_AUXILIARY) || phrase.getFeatureAsBoolean(InternalFeature.REALISE_AUXILIARY)) { realiseAuxiliaries(parent, realisedElement, auxiliaryRealisation); PhraseHelper.realiseList(parent, realisedElement, phrase.PreModifiers, DiscourseFunction.PRE_MODIFIER); realiseMainVerb(parent, phrase, mainVerbRealisation, realisedElement); } else if (isCopular(phrase.getHead())) { realiseMainVerb(parent, phrase, mainVerbRealisation, realisedElement); PhraseHelper.realiseList(parent, realisedElement, phrase.PreModifiers, DiscourseFunction.PRE_MODIFIER); } else { PhraseHelper.realiseList(parent, realisedElement, phrase.PreModifiers, DiscourseFunction.PRE_MODIFIER); realiseMainVerb(parent, phrase, mainVerbRealisation, realisedElement); } realiseComplements(parent, phrase, realisedElement); PhraseHelper.realiseList(parent, realisedElement, phrase.PostModifiers, DiscourseFunction.POST_MODIFIER); } return(realisedElement); }
/** * 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); } } }
/** * The main method for realising coordinated phrases. * * @param parent * the <code>SyntaxProcessor</code> that called this method. * @param phrase * the <code>CoordinatedPhrase</code> to be realised. * @return the realised <code>NLGElement</code>. */ internal static NLGElement realise(SyntaxProcessor parent, CoordinatedPhraseElement phrase) { ListElement realisedElement = null; if (phrase != null) { realisedElement = new ListElement(); PhraseHelper.realiseList(parent, realisedElement, phrase.PreModifiers, DiscourseFunction.PRE_MODIFIER); CoordinatedPhraseElement coordinated = new CoordinatedPhraseElement(); IList <NLGElement> children = phrase.Children; string conjunction = phrase.getFeatureAsString(Feature.CONJUNCTION); coordinated.setFeature(Feature.CONJUNCTION, conjunction); coordinated.setFeature(Feature.CONJUNCTION_TYPE, phrase.getFeature(Feature.CONJUNCTION_TYPE)); InflectedWordElement conjunctionElement = null; if (children != null && children.Any()) { if (phrase.getFeatureAsBoolean(Feature.RAISE_SPECIFIER)) { raiseSpecifier(children); } NLGElement child = phrase.LastCoordinate; child.setFeature(Feature.POSSESSIVE, phrase.getFeature(Feature.POSSESSIVE)); child = children[0]; setChildFeatures(phrase, child); coordinated.addCoordinate(parent.realise(child)); for (int index = 1; index < children.Count; index++) { child = children[index]; setChildFeatures(phrase, child); if (phrase.getFeatureAsBoolean(Feature.AGGREGATE_AUXILIARY)) { child.setFeature(InternalFeature.REALISE_AUXILIARY, false); } if (child.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.CLAUSE))) { child.setFeature(Feature.SUPRESSED_COMPLEMENTISER, phrase.getFeature(Feature.SUPRESSED_COMPLEMENTISER)); } //skip conjunction if it's null or empty string if (!ReferenceEquals(conjunction, null) && conjunction.Length > 0) { conjunctionElement = new InflectedWordElement(conjunction, new LexicalCategory(LexicalCategory.LexicalCategoryEnum.CONJUNCTION)); conjunctionElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.CONJUNCTION); coordinated.addCoordinate(conjunctionElement); } coordinated.addCoordinate(parent.realise(child)); } realisedElement.addComponent(coordinated); } PhraseHelper.realiseList(parent, realisedElement, phrase.PostModifiers, DiscourseFunction.POST_MODIFIER); PhraseHelper.realiseList(parent, realisedElement, phrase.Complements, DiscourseFunction.COMPLEMENT); } return(realisedElement); }
/** * Realises the key word of the interrogative. For example, <em>who</em>, * <em>what</em> * * @param keyWord * the key word of the interrogative. * @param cat * the category (usually pronoun, but not in the case of * "how many") * @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 realiseInterrogativeKeyWord(string keyWord, LexicalCategory cat, SyntaxProcessor parent, ListElement realisedElement, NLGFactory phraseFactory) { if (!ReferenceEquals(keyWord, null)) { NLGElement question = phraseFactory.createWord(keyWord, cat); NLGElement currentElement = parent.realise(question); if (currentElement != null) { realisedElement.addComponent(currentElement); } } }
/** * Realises the complements of passive clauses; also sets number, person for * passive * * @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 verbElement * the <code>NLGElement</code> representing the verb phrase for * this clause. */ private static NLGElement addPassiveComplementsNumberPerson(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGElement verbElement) { object passiveNumber = null; object passivePerson = null; NLGElement currentElement = null; NLGElement splitVerb = null; NLGElement verbPhrase = phrase.getFeatureAsElement(InternalFeature.VERB_PHRASE); // count complements to set plural feature if more than one int numComps = 0; bool coordSubj = false; if (phrase.getFeatureAsBoolean(Feature.PASSIVE) && verbPhrase != null && !InterrogativeType.WHAT_OBJECT.Equals(phrase.getFeature(Feature.INTERROGATIVE_TYPE))) { // complements of a clause are stored in the VPPhraseSpec foreach (NLGElement subject in verbPhrase.getFeatureAsElementList(InternalFeature.COMPLEMENTS)) { // AG: complement needn't be an NP // subject.isA(PhraseCategory.NOUN_PHRASE) && if (DiscourseFunction.OBJECT.Equals(subject.getFeature(InternalFeature.DISCOURSE_FUNCTION))) { subject.setFeature(Feature.PASSIVE, true); numComps++; currentElement = parent.realise(subject); if (currentElement != null) { currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.OBJECT); if (phrase.hasFeature(Feature.INTERROGATIVE_TYPE)) { splitVerb = currentElement; } else { realisedElement.addComponent(currentElement); } } // flag if passive subject is coordinated with an "and" if (!coordSubj && subject is CoordinatedPhraseElement) { string conj = ((CoordinatedPhraseElement)subject).Conjunction; coordSubj = (!ReferenceEquals(conj, null) && conj.Equals("and")); } if (passiveNumber == null) { passiveNumber = subject.getFeature(Feature.NUMBER); } else { passiveNumber = NumberAgreement.PLURAL; } if (Person.FIRST.Equals(subject.getFeature(Feature.PERSON))) { passivePerson = Person.FIRST; } else if (Person.SECOND.Equals(subject.getFeature(Feature.PERSON)) && !Person.FIRST.Equals(passivePerson)) { passivePerson = Person.SECOND; } else if (passivePerson == null) { passivePerson = Person.THIRD; } if (Form.GERUND.Equals(phrase.getFeature(Feature.FORM)) && !phrase.getFeatureAsBoolean(Feature.SUPPRESS_GENITIVE_IN_GERUND)) { subject.setFeature(Feature.POSSESSIVE, true); } } } } if (verbElement != null) { if (passivePerson != null) { verbElement.setFeature(Feature.PERSON, passivePerson); // below commented out. for non-passive, number and person set // by checkSubjectNumberPerson // } else { // verbElement.setFeature(Feature.PERSON, phrase // .getFeature(Feature.PERSON)); } if (numComps > 1 || coordSubj) { verbElement.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); } else if (passiveNumber != null) { verbElement.setFeature(Feature.NUMBER, passiveNumber); } } return(splitVerb); }
/** * Controls the realisation of <em>wh</em> object questions. * * @param keyword * the wh word * @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. * @param subjects * the <code>List</code> of subjects in the clause. * @return an <code>NLGElement</code> representing a subject that should * split the verb */ private static NLGElement realiseObjectWHInterrogative(string keyword, PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement, NLGFactory phraseFactory) { NLGElement splitVerb = null; realiseInterrogativeKeyWord(keyword, new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN), parent, realisedElement, phraseFactory); //$NON-NLS-1$ // if (!Tense.FUTURE.equals(phrase.getFeature(Feature.TENSE)) && !copular) { if (!hasAuxiliary(phrase) && !VerbPhraseHelper.isCopular(phrase)) { addDoAuxiliary(phrase, parent, phraseFactory, realisedElement); } else if (!phrase.getFeatureAsBoolean(Feature.PASSIVE)) { splitVerb = realiseSubjects(phrase, parent); } return(splitVerb); }