orion_lib 7.4.0

A library for parsing and executing the Orion Programming Language
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

//! The JIT engine for Orion.

use lalrpop_util::ParseError;
use crate::prelude::*;
use crate::{lrparser, lrbraces, utils};

use serde_yaml::{to_string as yamlt, from_str as yamlf};
use ron::{to_string, from_str};
use crate::utils::ast::Expr;

/// Encode a JIT string.
pub fn encode<S: ToString>(contents: S, use_braces: bool, yaml: bool) -> Result<String> {
    let contents = contents.to_string();

    if contents.is_empty() {
        return Ok(String::new());
    }

    let result = if use_braces {
        lrbraces::StatementsParser::new().parse(contents.clone().leak())
    } else {
        lrparser::StatementsParser::new().parse(contents.clone().leak())
    };

    let result = if result.is_err() {
        Err(match result.err().unwrap() {
            ParseError::InvalidToken { location } => {
                let loc = utils::location::location(location, contents);
                ParseError::InvalidToken { location: loc }
            }

            ParseError::UnrecognizedEof { location, expected } => {
                let loc = utils::location::location(location, contents);
                ParseError::UnrecognizedEof {
                    location: loc,
                    expected,
                }
            }

            ParseError::UnrecognizedToken { token, expected } => {
                let (loc1, token, loc2) = token;
                let loc1 = utils::location::location(loc1, &contents);
                let loc2 = utils::location::location(loc2, contents);

                ParseError::UnrecognizedToken {
                    token: (loc1, token, loc2),
                    expected,
                }
            }

            ParseError::ExtraToken { token } => {
                let (loc1, token, loc2) = token;
                let loc1 = utils::location::location(loc1, &contents);
                let loc2 = utils::location::location(loc2, contents);

                ParseError::ExtraToken {
                    token: (loc1, token, loc2),
                }
            }

            ParseError::User { error } => ParseError::User { error }, // ParseError::User
        })
    }
    else {
        result.map_err(|_| ParseError::User {
            error: "impossible",
        })
    };

    let ast: Vec<Option<Expr>> = result.unwrap_or_else(|e| {
        #[cfg(debug_assertions)]
        {
            panic!("\x1b[31m{e}\x1b[0m");
        }
        #[cfg(not(debug_assertions))]
        {
            eprintln!("\x1b[31m{e}\x1b[0m");
            std::process::exit(1)
        }
    });

    if yaml {
        Ok(yamlt(&ast)?)
    } else {
        Ok(to_string(&ast)?)
    }
}

/// Decode a JIT string.
pub fn decode<S: ToString>(contents: S, yaml: bool) -> Result<Vec<Option<Expr>>> {
    let contents = contents.to_string();

    if yaml {
        Ok(yamlf(&contents)?)
    } else {
        Ok(from_str(&contents)?)
    }
}