Productionclass

Our root class for grammar productions. (A “production” represents a match to a syntax rule, as defined with a ‘grammar’ template.)

The language module’s grammar rules can define certain special properties on any production match object, and we’ll find them in the course of building the command from the match tree:

endOfSentence=true - define this on a production for a sentence-ending verb conjunction. In English (and most Western languages), this can be used with rules that match punctuation marks like periods, exclamation points, and question marks, since these marks typically end a sentence. The parser distinguishes between the grammar rules for the first clause in a sentence vs subsequent clauses. It starts a new input line with the first-in-sentence rule, then uses the additional clause rule for each subsequent clause. When a clause ends with a sentence-ending mark, though, we’ll treat the next clause as a sentence opener again.

class Production : object

Superclass Tree (in declaration order)

Production
` object`

Subclass Tree

Global Objects

(none)

Summary of Properties

determiner nounPhraseRole npClass parent

Summary of Methods

addNounListItem build findAction findChild findParent getNounPhraseRole getText getTokens grammarInfoForBuild isChildOf noteEndOfSentence visitLiteral visitProd

Properties

determiner

parser.t[3487]

The determiner that this production applies to the noun phrase it’s part of, as a Determiner object. If this is non-nil, this Determiner will be set in the current NounPhrase when we visit this production in the build process.

nounPhraseRole

parser.t[3446]

My assigned noun phrase role, as a NounRole object. This must be explicitly set for the top node in a noun slot (which can be a noun list production, a single noun production, a topic, etc).

In a positional language grammar, the predicate production will mark its immediate child in each noun phrase slot by setting this according to the role that the sub-tree plays in the predicate grammar. Non-positional languages that use grammatical case or other ways of encoding the role information must set this some other way.

npClass

parser.t[3432]

The NounPhrase subclass to use for noun phrases within this sub-tree. By default, we look to our parent; if we don’t have a parent, we use the base NounPhrase class.

Special phrase types (topics, literals, and numbers) have their own NounPhrase subclasses. This is important because the resolution rules for these phrase types differ from the regular object resolution rules.

parent

parser.t[3502]

My parent production. The low-level GrammarProd mechanism doesn’t set this up, so we set it up ourselves in the course of building out the tree. In build(), just before we visit each sub-production, we set the sub-production’s ‘parent’ property to point back to the parent production. This property is therefore always set while we’re traversing the child’s tree, but won’t necessarily be set yet if we’re not currently working somewhere within the child’s tree. That means that you can always look at ‘parent’ within your own build() routine or a child build() routine, but you can’t necessarily look at it across the tree or within your own children.

Methods

addNounListItem (cmd, prod)

parser.t[3404]

Add a new NounPhrase item to the list under construction. Certain productions are associated with specific functional slots in the abstract command - direct object, indirect object, EXCEPT list, etc. This routine is for such production subclasses to override, to direct new noun phrases into the appropriate slot lists. In a grammar, the functional role is typically at a higher level in the tree, with ordinary noun phrases plugged in underneath.

Our default handling is to first check our nounPhraseRole property; if it’s set, it tells us the role that this sub-tree plays in the predicate (direct object, indirect object, accessory). We use that information to add the new NounPhrase to the Command list that we’re building for our assigned role.

If nounPhraseRole is nil, then we simply pass the request up to our parent. Eventually we should reach a node encoding the function slot.

build (cmd, np)

parser.t[3329]

Build the command for this production and its children. By default, we’ll simply traverse into our children.

findAction ( )

parser.t[3538]

Find the action. This finds the child of type VerbProduction, then retrieves the action from the verb production.

findChild (cls)

parser.t[3550]

Find a child of a given class.

findParent (func)

parser.t[3509]

Find a parent matching a given test. We’ll scan up the parent tree, looking for the nearest parent p for which func(p) returns true, returning p. If we can’t find one, we return nil.

getNounPhraseRole ( )

parser.t[3452]

Get our noun phrase role. If we don’t have a role defined directly, we’ll inherit the role from our parent node.

getText ( )

parser.t[3304]

get the original text of the command for this match

getTokens ( )

parser.t[3315]

get my original token list, in canonical tokenizer format

grammarInfoForBuild ( )

parser.t[3379]

Get the grammar match list for build() purposes. By default, this simply returns the grammarInfo() results, which are automatically generated by the compiler to return a list of the “->prop” values from the matched grammar rule. Some rules might want to modify that default value list, so we provide this routine as an override hook.

isChildOf (prod)

parser.t[3520]

Is this production a child of the given production?

noteEndOfSentence (cmd, prod)

parser.t[3416]

Note an end-of-sentence marker. We’ll simply notify our parent by default.

visitLiteral (cmd, np, tok)

parser.t[3463]

Visit a literal token child in our sub-tree. This is called during the build process for each literal token in our child list. By default, we add the token to the command’s current noun phrase.

visitProd (cmd, np, prod)

parser.t[3475]

Visit a production object in our list. This is called during the build process for each production object in our child list. By default, we simply build the child production recursively.

Adv3Lite Library Reference Manual
Generated on 15/03/2023 from adv3Lite version 1.6.1