Class ConfigBuilder

Overrides: object.__init__

(inherited documentation)

Decorators:

• @property

Decorators:

• @property

Raise an error if the first match fails. If eos is True then this requires that the entire input is matched, otherwise it only requires that the matcher succeed. The exception includes information about the deepest read to the stream (which is a good indication of where any error occurs).

This is part of the default configuration. It can be removed with no_full_first_match().

Combined nested And() and Or() matchers. This does not change the parser semantics, but improves efficiency.

This is part of the default configuration. It can be removed with no_flatten.

Compile simple matchers to NFA regular expressions. This improves efficiency and should not change the parser semantics.

This is part of the default configuration. It can be removed with no_compile_regexp.

Rearrange arguments to Or() so that left-recursive matchers are tested last. This improves efficiency, but may alter the parser semantics (the ordering of multiple results with ambiguous grammars may change).

conservative refers to the algorithm used to detect loops; False may classify some left--recursive loops as right--recursive.

Detect the use of Token() and modify the parser to use the lexer. If tokens are not used, this has no effect on parsing.

This is part of the default configuration. It can be disabled with no_lexer.

Combine simple matchers so that they are evaluated without trampolining. This improves efficiency (particularly because it reduces the number of matchers that can be memoized).

This is part of the default configuration. It can be removed with no_direct_eval.

Combine transforms (functions applied to results) with matchers. This may improve efficiency.

This is part of the default configuration. It can be removed with no_compose_transforms.

This configuration attempts to detect which memoizer is most effective for each matcher. As such it is a general "fix" for left-recursive grammars and is suggested in the warning shown when the right-only memoizer detects left recursion.

Lepl does not guarantee that all left-recursive grammars are handled correctly. The corrections applied may be incomplete and can be inefficient. It is always better to re-write a grammar to avoid left-recursion. One way to improve efficiency, at the cost of less accurate matching, is to specify a non-zero d parameter - this is the maximum iteration depth that will be used (by default, when d is zero, it is the length of the remaining input, which can be very large).

Add memoization that may detect and stabilise left-recursion. This makes the parser more robust (so it can handle more grammars) but also more complex (and probably slower).

config.auto_memoize() will also add memoization, but will select left/right memoization depending on the path through the parser.

Lepl does not guarantee that all left-recursive grammars are handled correctly. The corrections applied may be incomplete and can be inefficient. It is always better to re-write a grammar to avoid left-recursion. One way to improve efficiency, at the cost of less accurate matching, is to specify a non-zero d parameter - this is the maximum iteration depth that will be used (by default, when d is zero, it is the length of the remaining input, which can be very large).

Add memoization that can make some complex parsers (with a lot of backtracking) more efficient. This also detects left-recursive grammars and displays a suitable warning.

This is included in the default configuration. For simple grammars it may make things slower; it can be disabled by config.no_memoize().

Configure "offside parsing". This enables lexing and adds extra tokens to mark the start and end of lines. If block_policy is specified then the line start token will also include spaces which can be used by the Block() and BLine() matchers to do offside (whitespace-aware) parsing.

discard is the regular expression to use to identify spaces between tokens (by default, spaces and tabs).

The remaining parameters are used only if at least one of block_policy and block_start is given.

block_policy decides how indentation if calculated. See explicit etc in lepl.lexer.blocks.matchers.

block_start is the initial indentation (by default, zero). If set to lepl.lexer.lines.matchers.NO_BLOCKS indentation will not be checked (useful for tests).

tabsize is used only if block_policy is given. It is the number of spaces used to replace a leading tab (no replacement if None).

Add a monitor to trace results using TraceStack().

This is not used by default as it has a cost at runtime.

Add a monitor to correctly insert the transforms needed when using the TraceVariables() context:

with TraceVariables():

...

This is used by default as it has no runtime cost (once the parser is created).

Reduce memory use (at the expense of backtracking).

This will:
- Add a monitor to manage resources.  See `GeneratorManager()`.
- Disable direct evaluation (more trampolining gives more scope
  for removing generators)
- Disable the full first match error (which requires a copy of the
  input for the error message)
- Disable memoisation (which would keep input in memory)

This reduces memory usage, but makes the parser less reliable.
Usually a value like 100 (the default) for the queue length will make 
memory use insignificant and still give a useful first parse.

Note that, although the parser will use less memory, it may run
more slowly (as extra work needs to be done to "clean out" the 
stored values).

Control when the stream can be cached internally (this is used for debugging and error messages) - streams are cached for debugging when the value is greater than zero. The value is incremented each time a new stream is constructed (eg when constructing tokens).

A value of 1 implies that a stream would be always cached. A value of 0 might be used when iterating over a file with the lexer - the iteration is not cached, but individual tokens will be.