reqlang-expr 0.5.0

A tiny (bytecode compiled, stack VM interpreted) expression language for reqlang's templating engine.
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Parser and associated types

use crate::errors::ExprError;
use crate::ast;
use crate::lexer::Token;
use lalrpop_util::ParseError;

grammar<'err>(errors: &'err mut Vec<ParseError<usize, Token, (ExprError, std::ops::Range<usize>)>>);

pub Expr: ast::Expr = {
    ExprIdentifier,
    ExprCall,
    ExprString,
    ExprBool,
    <e:!> => {
        errors.push(e.error);
        ast::Expr::Error
    }
};

// Boolean Expressions

ExprBool: ast::Expr = {
    "true" => ast::Expr::Bool(ast::ExprBool(true).into()),
    "false" => ast::Expr::Bool(ast::ExprBool(false).into()),
};

// String Expressions

ExprString: ast::Expr = {
    string => ast::Expr::String(ast::ExprString(<>).into())
};

// Call Expressions

CallCallee = ExprS;
CallArgs = Args<ExprS>;
ExprCall: ast::Expr = {
    "(" <callee:CallCallee> <args:CallArgs> ")" => ast::Expr::Call(ast::ExprCall {
        callee,
        args
    }.into())
}

// Identifier Expressions

ExprIdentifier: ast::Expr = <name:identifier> =>
    ast::Expr::Identifier(ast::ExprIdentifier(name).into());

// Utility Types

ExprS = Spanned<Expr>;

Spanned<T>: (T, std::ops::Range<usize>) = <l:@L> <t:T> <r:@R> =>
    (t, l..r);

#[inline]
Args<E>: Vec<E> = {
    <first:E> <mut args:(<E>)*> => {
        args.insert(0, first);
        args
    },
    () => Vec::new(),
}

extern {
    type Location = usize;
    type Error = (ExprError, std::ops::Range<usize>);

    enum Token {
        "(" => Token::LParan,
        ")" => Token::RParan,
        "true" => Token::True,
        "false" => Token::False,
        string => Token::String(<String>),
        identifier => Token::Identifier(<String>),
    }
}