woojin 0.1.3

Woojinlang interpreter written as Rust
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

use nom::{
  branch::alt,
  bytes::complete::{
    tag, escaped, is_not
  },
  character::complete::{char, digit1},
  combinator::{map, map_res, opt, recognize},
  sequence::{delimited, pair},
  IResult,
};

use crate::{parser::{parse_variable_name}};

use super::WoojinValue;

// Integer(signed)
pub(crate) fn parse_int(input: &str) -> IResult<&str, i32> {
  map_res(
    recognize(pair(opt(alt((char('+'), char('-')))), digit1)),
    |s: &str| s.parse::<i32>(),
  )(input)
}

pub(crate) fn parse_string(input: &str) -> IResult<&str, String> {
  let re: regex::Regex = regex::Regex::new(r"\\").unwrap();
  let result: (&str, &str) = delimited(
    char('"'),
    escaped(
      is_not("\\\""),
      '\\',
      alt((
        tag("\\"),
        tag("\""),
        tag("t"),
        tag("n"),
        tag("r"),
        tag("0"),
      )),
    ),
    char('"'),
  )(input)?;
  let unescaped = result.1.replace("\\t", "\t").replace("\\r", "\r").replace("\\n", "\n");
  Ok((result.0, re.replace_all(&unescaped, "").to_string()))
}

// Boolean
pub(crate) fn parse_bool(input: &str) -> IResult<&str, bool> {
  alt((
    map(tag("uglyguri"), |_| true),
    map(tag("beautifulguri"), |_| false),
  ))(input)
}

// parse value
pub(crate) fn parse_value(input: &str) -> IResult<&str, WoojinValue> {
  alt((
    map(parse_string, WoojinValue::String),
    map(parse_int, WoojinValue::Int),
    map(parse_bool, WoojinValue::Bool),
    map(parse_variable_name, WoojinValue::Var),
  ))(input)
}