lispi 0.3.3

Lisp I interpreter
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::elementary_functions::cdr;
use crate::parser::parse;
use crate::repl::find_matching_bracket;
use crate::types::{Atom, NullableList, SExpression, Symbol, NIL};
use crate::{interpreter::eval, list_macros::compose_car_cdr};
use std::{io::Write, ops::RangeInclusive};

// use crate::{interpreter::eval, parser::parse, types::NullableList};

/// returns (line, nth_char_in_line)
pub fn offset_to_coordinate(s: &str, offset: usize) -> Option<(usize, usize)> {
    let mut offset = offset;
    for (line_no, line) in s.lines().enumerate() {
        if offset < line.len() {
            return Some((line_no + 1, offset + 1));
        }
        offset -= line.len();
    }
    None // offset out of bounds
}

#[test]
fn test_offset_to_coordinate() {
    let s = "(1 2 3)\n(4 5 6)\n(7 8 9)";
    assert_eq!(offset_to_coordinate(s, 0), Some((1, 1)));
    assert_eq!(offset_to_coordinate(s, 6), Some((1, 7)));
    assert_eq!(offset_to_coordinate(s, 7), Some((2, 1)));
    assert_eq!(offset_to_coordinate(s, 13), Some((2, 7)));
    assert_eq!(offset_to_coordinate(s, 14), Some((3, 1)));
    assert_eq!(offset_to_coordinate(s, 20), Some((3, 7)));
    assert_eq!(offset_to_coordinate(s, 21), None);
}

fn extract_sexp_range(s: &str, offset: usize) -> Option<RangeInclusive<usize>> {
    let begin_of_sexp = s.chars().skip(offset).position(|c| c == '(')? + offset;
    match find_matching_bracket(s, begin_of_sexp) {
        Ok(end_of_sexp) => Some(begin_of_sexp..=end_of_sexp),
        Err(_) => {
            if let Some((line_no, char_no)) = offset_to_coordinate(s, begin_of_sexp) {
                log::error!("Unclosed parenthesis at {line_no}:{char_no}.");
            } else {
                todo!("offset out of bounds???")
            }
            None
        }
    }
}

#[test]
fn test_extract_sexp_range() {
    assert_eq!(extract_sexp_range("123 (456) 789", 0), Some(4..=8));
    assert_eq!(extract_sexp_range("123 (456) 789", 4), Some(4..=8));
    assert_eq!(extract_sexp_range("123 (456) 789", 5), None);
    assert_eq!(extract_sexp_range("123 (456) 789", 14), None);
    assert_eq!(extract_sexp_range("123 456 789", 0), None);
}

pub(crate) fn split_sexps(s: &str) -> Option<Vec<&str>> {
    let mut sexps = Vec::new();
    let mut offset = 0;
    while let Some(skip) = s.chars().skip(offset).position(|c| c == '(') {
        let range = extract_sexp_range(s, offset + skip)?;
        offset = *range.end() + 1;
        sexps.push(&s[range]);
    }
    Some(sexps)
}

#[test]
fn test_split_sexps() {
    assert_eq!(split_sexps("(1) (2) (3)"), Some(vec!["(1)", "(2)", "(3)"]));
    assert_eq!(split_sexps("(1 (2 (3)))"), Some(vec!["(1 (2 (3)))"]));
    assert_eq!(split_sexps("(1 (2)) (3)"), Some(vec!["(1 (2))", "(3)"]));
    assert_eq!(split_sexps(""), Some(vec![]));
    assert_eq!(split_sexps("(123"), None);
}

pub fn eval_file<W>(filename: &str, output: &mut W) -> Option<NullableList>
where
    W: Write,
{
    let s = match std::fs::read_to_string(filename) {
        Ok(content) => content,
        Err(e) => {
            log::error!("Failed to open file {filename}: {e}");
            return None;
        }
    };
    let sexp_slices = split_sexps(&s)?;

    let mut a: NullableList = NIL.into();
    for slice in sexp_slices {
        // TODO: if there is error with parsing it would be nice to show the coordinates of where it occured
        let sexp = parse(slice)?;
        let (res, new_a_list) = eval(sexp, &a)?;
        a = new_a_list.into_owned();

        writeln!(output, "{}", res).unwrap();
    }
    Some(a)
}

pub fn get_bound_symbols(a: &NullableList) -> Option<Vec<String>> {
    match a {
        NullableList::List(l) => match compose_car_cdr("caar", l) {
            Some(SExpression::Atom(Atom::Symbol(Symbol::Other(s)))) => {
                let mut v = vec![s];
                let rest = cdr(l.clone());
                match rest {
                    SExpression::List(rest) => {
                        v.append(&mut get_bound_symbols(&rest.into())?);
                        Some(v)
                    }
                    _ => Some(v),
                }
            }
            _ => todo!("invalid alist: {a:?}"),
        },
        NullableList::NIL => Some(vec![]),
    }
}

#[test]
fn test_get_bound_symbols() {
    use crate::list;
    assert_eq!(
        get_bound_symbols(&list![cons("first", ElementaryFunction::CAR)].into()),
        Some(vec!["first".to_string()])
    );
    assert_eq!(
        get_bound_symbols(
            &list![
                cons("head", ElementaryFunction::CAR),
                cons("tail", ElementaryFunction::CDR)
            ]
            .into()
        ),
        Some(vec!["head".to_string(), "tail".to_string()])
    );
}