ram 5.0.0

A library that helps to parse source code with finite state machines
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# Rustastic Automaton

This [Rust](http://www.rust-lang.org/) package allows you to ease the creation of a language lexer based on finite state machines.

You can build the documentation with `cargo doc` or [view it online](https://conradk.com/docs/rustastic-am/).

The source code is released under the MIT license.

I'd appreciate feedback if you use this library :-)

## Usage

Add `ram` as a dependency in Cargo.toml:

```toml
[dependencies]
ram = "5.0.0"
```

Import the `ram` crate and use the `Automaton` struct to create a language lexer. In this example, we are lexing a language that has no tokens other than the "End of source" token:

```rust
extern crate ram;

use ram::Automaton;

enum TokenType {
    End,
}

// Create the FSM (2 states, 0 or 1) that will parse the source code
let mut am = Automaton::new(0, 1);
// When the FSM hits the end of the source, go to state 1, the final state
am.find_end(TokenType::End as i32, 0, 1);

// Run the FSM with an empty string as the source code
let source_code = format!("");
let runner = am.run(source_code);

// Print the parsed tokens to the console
println!("{:?}", runner.tokens);
```

There are multiple `find_*` methods to your disposal, like `find_regex` or `find_whitespace` or
even `find_automaton`, which allows you to combine various finite state machines together
to create more powerful tokenizers.