### 6 releases (breaking)

Uses old Rust 2015

0.5.0 | Nov 23, 2019 |
---|---|

0.4.0 | Oct 10, 2019 |

0.3.0 | May 16, 2016 |

0.2.0 | Mar 7, 2016 |

0.0.1 | Nov 13, 2014 |

#**54** in Parser tooling

**98** downloads per month

Used in **9** crates
(8 directly)

**MIT/Apache**

135KB

3.5K
SLoC

## cfg •

Rust library for manipulating context-free grammars. You can check the documentation here.

## Analyzing and modifying grammars

The following features are implemented thus far:

- cycle detection and elimination,
- useless rule detection and elimination,
- grammar binarization,
- nulling rule elimination for binarized grammars,
- FIRST and FOLLOW set computation,
- minimal distance computation,
- unused symbol removal.

## Building grammars

includes an interface that simplifies grammar construction.`cfg`

### Generating symbols

The easiest way of generating symbols is with the

method. The library is unaware
of the start symbol.`sym`

`let` `mut` grammar`:` Cfg `=` `Cfg``::`new`(``)``;`
`let` `(`start`,` expr`,` identifier`,` number`,`
plus`,` multiply`,` power`,` l_paren`,` r_paren`,` digit`)` `=` grammar`.``sym``(``)``;`

### Building grammar rules

Rules have a LHS symbol and zero or more RHS symbols.

`grammar``.``rule``(`start`)``.``rhs``(``[`expr`]``)`
`.``rhs``(``[`identifier`,` l_paren`,` expr`,` r_paren`]``)``;`

### Building sequence rules

Sequence rules have a LHS symbol, a RHS symbol, a range of repetitions, and optional separation. Aside from separation, they closely resemble regular expression repetitions.

`grammar``.``sequence``(`number`)``.``inclusive``(``1``,` `None``)``.``rhs``(`digit`)``;`

### Building precedenced rules

Precedenced rules are the most convenient way to describe operators. Once
built, they are immediately rewritten into basic grammar rules, and unique
symbols are generated. Operator associativity can be set to

or
`Right`

. It's `Group`

by default.`Left`

`use` `cfg``::``precedence``::``Associativity``::``{`Right`,` Group`}``;`
grammar`.``precedenced_rule``(`expr`)`
`.``rhs``(``[`number`]``)`
`.``rhs``(``[`identifier`]``)`
`.``associativity``(`Group`)`
`.``rhs``(``[`l_paren`,` expr`,` r_paren`]``)`
`.``lower_precedence``(``)`
`.``associativity``(`Right`)`
`.``rhs``(``[`expr`,` power`,` expr`]``)`
`.``lower_precedence``(``)`
`.``rhs``(``[`expr`,` multiply`,` expr`]``)`
`.``lower_precedence``(``)`
`.``rhs``(``[`expr`,` plus`,` expr`]``)``;`

## Using a custom grammar representation

Your grammar type has to implement several traits:

`RuleContainer``ContextFree``ContextFreeRef``ContextFreeMut`

## License

Dual-licensed for compatibility with the Rust project.

Licensed under the Apache License Version 2.0: http://www.apache.org/licenses/LICENSE-2.0, or the MIT license: http://opensource.org/licenses/MIT, at your option.

#### Dependencies

~0.7–1.3MB

~30K SLoC