Chapter 5. Parser options

Create the parser options.

The initial logger will be a DefaultLogger initialized with readSystemProperties().

Create the parser options with an explicit logger.

Create a new set of options from an existing set.

Disable the specified pragma.

The user can selectively ignore pragmas in a grammar. This method specifies that a particular pragma should be disabled. The token “#all” disables all pragmas.

Disable the specified pragma.

The user can selectively ignore pragmas in a grammar. This method specifies that a particular pragma should be enabled. The token “#all” enables all pragmas.

Expose a state.

The Invisible XML processor adds state values to the root element to report conditions such as ambiguity or a prefix parse. These states can be suppressed.

Allow empty string to represent an alternative?

This is a purely stylistic option. Invisible XML allows the empty string to represent an empty alternative, S = “a” | . That defines S to be either @code{“a”} or empty, “nothing”. Another way to represent an empty alternative is with an empty pair of parentheses, S = “a” | () .. That’s more visually distinct and can be enforced with this option.

Allow multiple definitions?

A grammar with multiply defined symbols isn’t a problem for the underlying Earley parser, but it is forbidden by Invisible XML.

Allow undefined symbols?

A grammar with undefined symbols isn’t necessarily unusable. But Invisible XML forbids them.

Allow unproductive symbols?

An unproductive symbol is one which can never produce output in a valid parse.

Allow unreachable symbols?

A grammar with unreachable symbols isn’t forbidden by Invisible XML, but might still be an error.

Raise an exception if invalid XML characters are used in text or attribute values that are serialized.

Raise an exception if invalid XML names are used in nonterminals that are serialized.

Where’s the GraphViz ‘dot’ command?

If a UTF-8 input stream begins with a byte order mark (BOM), ignore it.

Ignore trailing whitespace?

If a parse fails where it would have succeeded if trailing whitespace was removed from the input, report success.

Get the parser logger.

The logger controls what messages are displayed, and how. This component is also used by higher-level components such as CoffeeFilter, CoffeePot, and CoffeeSacks.

Are ambiguities marked?

CoffeeGrinder doesn’t use this option, but it’s defined here so that it will be passed to CoffeeFilter. If ambiguities are to be marked, additional markup (attributes or processing instructions) are included in the forests returned in order to indicate where ambiguous choices were made).

Attempt to parse modular grammars?

Normalize line endings?

If line endings are normalized, all occurrences of #D, #D#A, #85, and #2028 in the input string are replaced with a single #A. This only applies to sequences of characters in the input.

Get the parser type.

The parser type will be “Earley” or “GLL”.

Enforce strict compliance to the Invisible XML specification.

In pedantic mode, the processor won’t allow grammar extensions, like pragmas, that are not yet officially incorporated into the specification.

Is prefix parsing enabled?

If an Earley parse fails, but some prefix of the input was successfully parsed, make that available for continuing the parse. This is optional mostly because it requires internally buffering some of the input tokens, but probably no more than a few.

Attempt to pretty print the result?

If the result is pretty printed, extra newlines and spaces for indentation will be added to the result.

Get the priority style.

Priorities can be computed on one of two styles: max or sum.

• If the priority style is max, the priority of any given node is the highest priority value in the subgraph rooted at that node.

• If the priority style is sum, the priority of any given node is the sum of the priorities of the nodes in the subgraph below it.

The default is max.

Get the progress monitor.

If a progress monitor is present, it will be called before, during, and after the parse.

Return the Earley chart even for a successful parse?

If this option is enabled, the chart will be returned even for a successful parse. (If the parse fails, the chart is always returned.)

The chart can only be returned if the Earley parser is used. The GLL parser doesn’t manage the parse with state charts in the same way.

Get the Saxon configuration that will be used by CoffeeFilter.

A processor is required when managing modular grammars.

Show the Earley chart in error results?

Where should parsing start?

Invisible XML defines the start symbol as the symbol defined by the first rule in the grammar. In practice, the parser can start with any symbol in the grammar. This option returns the start symbol, if one was specified, or null. If null is returned, the parser will use the default start symbol. An exception will be raised if the symbol named is not defined in the grammar.

If a grammar contains priority pragmas that uniquely determine the outcome of every potentially ambiguous choice, report that the grammar is ambiguous anyway.

Make sure the output ends with a newline?

If this option is true, a newline will be added to the end of the output.

Should validate VXML grammars?

Is the specified state suppressed?

The Invisible XML processor adds state values to the root element to report conditions such as ambiguity or a prefix parse. These states can be suppressed.

Is the specified pragma disabled?

The user can selectively disable pragmas in a grammar. This method determines whether the specified pragma is disabled.

Set the getAllowEmptyAlts() ()} property.

Set the getAllowMultipleDefinitions() property.

Set the getAllowUndefinedSymbols() property.

Allowing undefined symbols implies getAllowUnproductiveSymbols() and getAllowUndefinedSymbols(). An undefined symbol is always part of an unproductive rule and avoiding errors for undefined rules often introduces undefined symbols.

Set the getAllowUnproductiveSymbols() property.

Set the getAllowUnreachableSymbols() property.

Set the getAssertValidXmlCharacters() property.

Set the getAssertValidXmlNames() property.

Set the getGraphviz() property.

Setting the path to null disables SVG output.

Set the getIgnoreBOM() property.

Set the getIgnoreTrailingWhitespace() property.

Set the logger.

Shall ambiguities be marked?

Set the getModularity() property.

Enable normalizing line endings?

See getNormalizeLineEndings().

Set the parser type.

You must specify “Earley” or “GLL”.

Set the getPedantic() property.

In pedantic mode, the processor won’t allow grammar extensions, like pragmas, that are not yet officially incorporated into the specification. Enabling pedantic mode also resets the allowed grammar hygiene rules to their defaults.

Enable prefix parsing?

Set the getPrettyPrint() property.

Set the priority style.

The style can be max or sum.

Set the progress monitor.

Setting the monitor to null disables monitoring.

Set the return chart property.

See getReturnChart().

Set the Saxon configuration to be used by this instance of CoffeeFilter.

Set the getShowChart() property.

Set the getStartSymbol() property.

This option allows you to specify what the “seed” symbol should be for parsing. This will result in nonconformant parser behavior if the symbol specified isn’t the symbol defined by the first rule in the grammar.

Set the getStrictAmbiguity() property.

Set the getTrailingNewlineOnOutput() property.

Set the getValidateVxml() property.

Suppress a state.

The Invisible XML processor adds state values to the root element to report conditions such as ambiguity or a prefix parse. These states can be suppressed.