parse

sqparse

Function parse 

Source 
pub fn parse<'s>(items: &'s [TokenItem<'s>]) -> Result<Program<'s>, ParseError>
Expand description

Parses an input token list into a syntax tree.

ยงExample

use sqparse::{Flavor, parse, tokenize};

let source = r#"
global function MyFunction

struct {
    int a
} file

string function MyFunction( List<number> values ) {
    values.push(1 + 2)
}
"#;
let tokens = tokenize(source, Flavor::SquirrelRespawn).unwrap();

let program = parse(&tokens).unwrap();
assert_eq!(program.statements.len(), 3);
Examples found in repository?
examples/print_parser_error.rs (line 6)
3fn main() {
4    let source = include_str!("print_parser_error_script.nut");
5    let tokens = tokenize(source, Flavor::SquirrelRespawn).unwrap();
6    let parse_err = parse(&tokens).unwrap_err();
7
8    println!(
9        "{}",
10        parse_err.display(source, &tokens, Some("print_parser_error_script.nut"))
11    );
12}
More examples
Hide additional examples
examples/print_ast.rs (line 14)
3fn main() {
4    let source = include_str!("print_ast_script.nut");
5
6    let tokens = match tokenize(source, Flavor::SquirrelRespawn) {
7        Ok(tokens) => tokens,
8        Err(err) => {
9            eprintln!("{}", err.display(source, Some("print_ast_script.nut")));
10            return;
11        }
12    };
13
14    let ast = match parse(&tokens) {
15        Ok(ast) => ast,
16        Err(err) => {
17            eprintln!(
18                "{}",
19                err.display(source, &tokens, Some("print_ast_script.nut"))
20            );
21            return;
22        }
23    };
24
25    println!("{ast:#?}");
26}
examples/dryrun.rs (line 52)
5fn main() {
6    let mut args = std::env::args();
7    let exe = args.next().unwrap();
8
9    let base_path = match args.next() {
10        Some(arg) => PathBuf::from(arg),
11        None => {
12            eprintln!("Usage: {exe} [path]");
13            eprintln!();
14            eprintln!("Provide a path to a file to parse that file, or a path to a directory to");
15            eprintln!("recursively parse all .nut and .gnut files in the directory");
16            std::process::exit(1);
17        }
18    };
19
20    let mut total_size_bytes = 0;
21    let mut total_lex_secs = 0.;
22    let mut total_parse_secs = 0.;
23
24    visit(&base_path, &mut |path| {
25        let extension = path.extension().and_then(|val| val.to_str());
26        if !matches!(extension, Some("nut") | Some("gnut")) {
27            return;
28        }
29
30        println!("{}", path.display());
31
32        let file_text = match std::fs::read_to_string(path) {
33            Ok(text) => text,
34            Err(err) => {
35                println!("  could not read: {err}");
36                return;
37            }
38        };
39
40        let lex_start = Instant::now();
41        let tokens = match tokenize(&file_text, Flavor::SquirrelRespawn) {
42            Ok(tokens) => tokens,
43            Err(err) => {
44                eprintln!("{}", err.display(&file_text, path.to_str()));
45                std::process::exit(1);
46            }
47        };
48        let lex_secs = lex_start.elapsed().as_secs_f64();
49        println!("  tokenize: {lex_secs}s");
50
51        let parse_start = Instant::now();
52        if let Err(err) = parse(&tokens) {
53            eprintln!("{}", err.display(&file_text, &tokens, path.to_str()));
54            std::process::exit(1);
55        }
56        let parse_secs = parse_start.elapsed().as_secs_f64();
57        println!("  parse: {parse_secs}s");
58
59        total_size_bytes += file_text.bytes().len();
60        total_lex_secs += lex_secs;
61        total_parse_secs += parse_secs;
62    });
63
64    let total_mb = total_size_bytes as f64 / 1048576.;
65    println!("Finished!");
66    println!(
67        "Tokenize: {:.4}s, {:.2} MB/s",
68        total_lex_secs,
69        total_mb / total_lex_secs
70    );
71    println!(
72        "Parse: {:.4}s, {:.2} MB/s",
73        total_parse_secs,
74        total_mb / total_parse_secs
75    );
76}