fr 0.1.1

A programming language with an unusual compiler backend
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::compile::*;

grammar;


extern {
    type Location = usize;
    type Error = String;
}


pub Str: String = <s:r#""(\\.|[^"])*""#> => String::from(&s[1..s.len()-1]).replace("\\n","\n").replace("\\r","\r").replace("\\t","\t").replace("\\0","\0").replace("\\\"", "\"");
pub Char: char = <s:r#"'(\\.|[^"])'"#> => String::from(&s[1..s.len()-1]).replace("\\n","\n").replace("\\r","\r").replace("\\t","\t").replace("\\0","\0").replace("\\\"", "\"").chars().next().unwrap();

pub Num: Literal = {
    r"([0-9]+([.][0-9]*)?|[.][0-9]+)" => match <>.parse::<u8>() {
        Ok(val) => Literal::byte_int(val),
        Err(_) => Literal::unsigned_short(<>.parse::<u16>().unwrap()),
    },
}

pub Flag: Flag = {
    "#" "[" <FlagName> "]" => <>
}

pub FlagName: Flag = {
    "enable" "(" "brainfuck" ")" => Flag::EnableBrainFuck,
    "enable" "(" "size_warn" ")" => Flag::EnableSizeWarn
}

pub Value: Eval = {
    "(" <Value> ")" => <>,
    "*" <name: Value> => Eval::Deref(Deref::new(name)),
    <name: Ident> => Eval::Load(Load::new(name)),
    "&" <name: Ident> => Eval::Refer(Refer::new(Eval::Load(Load::new(name)))),
    <name: Ident> <args: List<"(", Value, ",", ")">> => Eval::Call(Call::new(name, args)),
    <Literal> => Eval::Literal(<>)
}

pub Expr: Expr = {
    <IfStatement> => <>,
    <WhileLoop> => <>,
    <Assign> ";" => <>,
    <Value> ";" => Expr::Eval(<>),
    "return" <ret: Value> ";" => Expr::Return(Return::new(ret))
}

pub Assign: Expr = {
    <lhs: Value> "=" <rhs: Value> => Expr::Assign(Assign::new(lhs, rhs)),
    "def" <lhs: Ident> "=" <rhs: Value> => Expr::Define(Define::new(lhs, rhs)),
}

pub Program: Program = {
    <flags: Flag*> <fndefs: FunctionDef+> => Program::new(flags, fndefs)
}

pub Body: Vec<Expr> = Expr* => <>;

pub Ident: String = {
    r"[a-zA-Z_][a-zA-Z0-9_]*" => <>.to_string()
}

pub WhileLoop: Expr = {
    "while" <condition:Ident> "{" <body:Body> "}" => Expr::While(While::new(Eval::Load(Load::new(condition)), body))
}

pub IfStatement: Expr = {
    "if" <condition:Value> "{" <then_body:Body> "}" <else_clause:("else" "{" <Body> "}")?> => {
        match else_clause {
            Some(clause) => {
                Expr::If(If::new(condition, then_body, clause))
            }
            None => {
                Expr::If(If::new(condition, then_body, vec![]))
            }
        }
    }
}

FunctionDef: UserFn = "fn" <name: Ident> <args: List<"(", Ident, ",", ")">> "{" <body: Body> "}" => UserFn::new(name, args, body);


Literal: Literal = {
    <Str> => Literal::string(<>),
    <Char> => Literal::character(<>),
    <Num> => <>
}

Infix<First, Operator, Second>: (First, Operator, Second) = {
    <first:First> <op: Operator> <second:Second> => {
        (<>)
    }
}

List<Begin, T, Sep, End>: Vec<T> = {
    <first:Begin> <list: (<T> <Sep>)*> <end:T?> <last:End> => {
        match end {
            None => list.iter().map(|(v, s)| v.clone()).collect(),
            Some(val) => {
                let mut list: Vec<_> = list.iter().map(|(v, s)| v.clone()).collect();
                list.push(val);
                list
            }
        }
    }
}