use crate::host::{
el_truthy, CharTable, CtAscii, CtSlot, ElHashTable, ElispHost, Obj, SubCharTable, CT_CHARS,
CT_SIZE, MAX_CHAR,
};
use fusevm::Value;
use num_bigint::BigInt;
use std::collections::{HashMap, HashSet};
pub fn read_all(h: &mut ElispHost, src: &str) -> Result<Vec<Value>, String> {
let chars: Vec<char> = src.chars().collect();
let mut r = Reader::new(chars, 0);
let mut out = Vec::new();
loop {
r.skip_ws();
if r.pos >= r.chars.len() {
break;
}
r.labels.clear();
r.completed.clear();
r.sub_labels.clear();
out.push(r.read_form(h)?);
}
Ok(out)
}
pub struct FormStream {
r: Reader,
}
impl FormStream {
pub fn new(src: &str) -> FormStream {
FormStream {
r: Reader::new(src.chars().collect(), 0),
}
}
pub fn next_form(&mut self, h: &mut ElispHost) -> Result<Option<Value>, String> {
self.r.skip_ws();
if self.r.pos >= self.r.chars.len() {
return Ok(None);
}
self.r.labels.clear();
self.r.completed.clear();
self.r.sub_labels.clear();
self.r.read_form(h).map(Some)
}
}
pub fn read_one(h: &mut ElispHost, src: &str, start: usize) -> Result<(Value, usize), String> {
let chars: Vec<char> = src.chars().collect();
let pos = start.min(chars.len());
let mut r = Reader::new(chars, pos);
r.skip_ws();
if r.pos >= r.chars.len() {
return Err("end-of-file".into());
}
let form = r.read_form(h)?;
Ok((form, r.pos))
}
enum LazySkip {
Skip(usize),
ToEndNil,
Overflow,
}
struct Reader {
chars: Vec<char>,
pos: usize,
newlines: Vec<usize>,
labels: HashMap<i64, Value>,
completed: HashSet<u32>,
sub_labels: HashMap<i64, SubCharTable>,
}
impl Reader {
fn new(chars: Vec<char>, pos: usize) -> Reader {
Reader {
newlines: newline_positions(&chars),
chars,
pos,
labels: HashMap::new(),
completed: HashSet::new(),
sub_labels: HashMap::new(),
}
}
}
fn newline_positions(chars: &[char]) -> Vec<usize> {
chars
.iter()
.enumerate()
.filter_map(|(i, &c)| (c == '\n').then_some(i))
.collect()
}
#[allow(clippy::unnecessary_wraps)]
fn digit_to_number(c: char, radix: u32) -> Option<Option<u32>> {
let digit = match c {
'0'..='9' => c as u32 - '0' as u32,
'a'..='z' => c as u32 - 'a' as u32 + 10,
'A'..='Z' => c as u32 - 'A' as u32 + 10,
_ => return None,
};
Some((digit < radix).then_some(digit))
}
fn is_delim(c: char) -> bool {
c.is_whitespace() || matches!(c, '(' | ')' | '[' | ']' | '"' | '\'' | '`' | ',' | ';')
}
impl Reader {
fn peek(&self) -> Option<char> {
self.chars.get(self.pos).copied()
}
fn line_at(&self, pos: usize) -> u32 {
self.newlines.partition_point(|&p| p < pos) as u32 + 1
}
fn peek_at(&self, n: usize) -> Option<char> {
self.chars.get(self.pos + n).copied()
}
fn dot_is_separator(&self) -> bool {
match self.peek_at(1) {
None => true,
Some(c) => {
c.is_whitespace()
|| matches!(c, '"' | '\'' | ';' | '(' | '[' | '#' | '?' | '`' | ',')
}
}
}
fn skip_ws(&mut self) {
loop {
match self.peek() {
Some(c) if c.is_whitespace() => self.pos += 1,
Some(';') => self.skip_line(),
Some('#') if self.peek_at(1) == Some('!') => self.skip_line(),
Some('#') if self.peek_at(1) == Some('@') => match self.lazy_string_skip() {
LazySkip::Skip(end) => self.pos = end,
LazySkip::ToEndNil | LazySkip::Overflow => break,
},
_ => break,
}
}
}
fn lazy_string_skip(&self) -> LazySkip {
let mut pos = self.pos + 2;
let mut nskip: i64 = 0;
let mut digits = 0;
loop {
match self.chars.get(pos).and_then(|c| c.to_digit(10)) {
Some(d) => {
pos += 1;
match nskip.checked_mul(10).and_then(|n| n.checked_add(d as i64)) {
Some(n) => nskip = n,
None => return LazySkip::Overflow,
}
digits += 1;
if digits == 2 && nskip == 0 {
return LazySkip::ToEndNil;
}
}
None => {
if nskip > 0 && pos < self.chars.len() {
pos += 1;
}
break;
}
}
}
while let Some(&c) = self.chars.get(pos) {
pos += 1;
if c == '\x1f' {
break;
}
}
LazySkip::Skip(pos)
}
fn skip_line(&mut self) {
while let Some(c) = self.peek() {
self.pos += 1;
if c == '\n' {
break;
}
}
}
fn read_form(&mut self, h: &mut ElispHost) -> Result<Value, String> {
stacker::maybe_grow(128 * 1024, 16 * 1024 * 1024, || self.read_form_inner(h))
}
fn read_form_inner(&mut self, h: &mut ElispHost) -> Result<Value, String> {
self.skip_ws();
let c = self.peek().ok_or("end-of-file")?;
match c {
'(' => self.read_list(h),
')' => Err("invalid-read-syntax: )".to_string()),
'.' if self.dot_is_separator() => Err("invalid-read-syntax: .".to_string()),
'[' => self.read_vector(h),
']' => Err("invalid-read-syntax: ]".to_string()),
'`' => {
self.pos += 1;
let f = self.read_form(h)?;
Ok(marker(h, "`", f))
}
',' => {
self.pos += 1;
if self.peek() == Some('@') {
self.pos += 1;
let f = self.read_form(h)?;
Ok(marker(h, ",@", f))
} else {
let f = self.read_form(h)?;
Ok(marker(h, ",", f))
}
}
'"' => {
let s = self.read_string()?;
Ok(h.promote_string(s))
}
'?' => self.read_char_literal(),
'\'' => {
self.pos += 1;
let f = self.read_form(h)?;
Ok(quoted(h, "quote", f))
}
'#' if self.peek_at(1) == Some('\'') => {
self.pos += 2;
let f = self.read_form(h)?;
Ok(quoted(h, "function", f))
}
'#' if self.peek_at(1) == Some('s') && self.peek_at(2) == Some('(') => {
self.pos += 2;
self.read_record(h)
}
'#' if self.peek_at(1) == Some('s') => Err(match self.peek_at(2) {
Some(c) => format!("invalid-read-syntax: #s{c}"),
None => "invalid-read-syntax: #s".to_string(),
}),
'#' if self.peek_at(1) == Some('^') => self.read_char_table_literal(h),
'#' if self.peek_at(1) == Some('$') => {
self.pos += 2;
let sym = h.intern("load-file-name");
Ok(h.get_value(&sym).unwrap_or(Value::Undef))
}
'#' if self.peek_at(1) == Some('@') => match self.lazy_string_skip() {
LazySkip::ToEndNil => {
self.pos = self.chars.len();
Ok(Value::Undef)
}
_ => Err("invalid-read-syntax: #@".to_string()),
},
'#' if self.peek_at(1) == Some('&') => self.read_bool_vector(h),
'#' if self.peek_at(1) == Some('(') => {
self.pos += 1;
self.read_propertized_string(h)
}
'#' if matches!(
self.peek_at(1),
Some('x' | 'X' | 'o' | 'O' | 'b' | 'B' | '0'..='9')
) =>
{
self.read_radix(h)
}
'#' if self.peek_at(1) == Some('#') => {
self.pos += 2;
Ok(h.intern(""))
}
'#' if self.peek_at(1) == Some('_') => {
self.pos += 2;
let mut name = String::new();
while let Some(c) = self.peek() {
if c == '\\' {
self.pos += 1;
name.push(self.peek().ok_or("end-of-file")?);
} else if is_delim(c) {
break;
} else {
name.push(c);
}
self.pos += 1;
}
Ok(h.intern(&name))
}
'#' if self.peek_at(1) == Some(':') => {
self.pos += 2;
let mut name = String::new();
while let Some(c) = self.peek() {
if is_delim(c) {
break;
}
name.push(c);
self.pos += 1;
}
Ok(h.make_symbol(&name))
}
'#' => Err(match self.peek_at(1) {
Some(c2) => format!("invalid-read-syntax: #{c2}"),
None => "invalid-read-syntax: #".to_string(),
}),
_ => self.read_atom(h),
}
}
fn read_list(&mut self, h: &mut ElispHost) -> Result<Value, String> {
let line = self.line_at(self.pos);
self.pos += 1; let mut items = Vec::new();
loop {
self.skip_ws();
match self.peek() {
None => return Err("end-of-file".to_string()),
Some(')') => {
self.pos += 1;
break;
}
Some('.') if self.dot_is_separator() => {
if items.is_empty() {
return Err("invalid-read-syntax: .".to_string());
}
self.pos += 1; self.skip_ws();
if self.peek() == Some(')') {
return Err("invalid-read-syntax: )".to_string());
}
let tail = self.read_form(h)?;
self.skip_ws();
if self.peek() != Some(')') {
return Err("invalid-read-syntax: expected )".to_string());
}
self.pos += 1;
let mut acc = tail;
for x in items.into_iter().rev() {
acc = h.cons(x, acc);
}
h.record_form_line(&acc, line);
return Ok(acc);
}
_ => items.push(self.read_form(h)?),
}
}
let form = h.list_from(items);
h.record_form_line(&form, line);
Ok(form)
}
fn read_vector(&mut self, h: &mut ElispHost) -> Result<Value, String> {
self.pos += 1; let mut items = Vec::new();
loop {
self.skip_ws();
match self.peek() {
None => return Err("end-of-file".to_string()),
Some(']') => {
self.pos += 1;
break;
}
_ => items.push(self.read_form(h)?),
}
}
Ok(h.alloc(Obj::Vector(items)))
}
fn read_string(&mut self) -> Result<Value, String> {
self.pos += 1;
let mut s = String::new();
loop {
match self.peek() {
None => return Err("end-of-file".to_string()),
Some('"') => {
self.pos += 1;
break;
}
Some('\\') => {
self.pos += 1;
let e = self.peek().ok_or("end-of-file")?;
let dash = self.peek_at(1) == Some('-');
let scalar = match e {
'^' => {
self.pos += 1;
apply_control(self.read_control_target()?)
}
'C' if dash => {
self.pos += 2;
apply_control(self.read_control_target()?)
}
'M' if dash => {
self.pos += 2;
let target = self.read_control_target()?;
if !(0..128).contains(&target) {
return Err(
"invalid-read-syntax: Invalid modifier in string".to_string()
);
}
target | 0x80
}
's' if !dash => {
self.pos += 1;
32
}
'\n' | ' ' => {
self.pos += 1;
continue;
}
_ => match self.read_escape_scalar()? {
r if (BYTE8_OFFSET + 0x80..=BYTE8_OFFSET + 0xff).contains(&r) => {
r - BYTE8_OFFSET
}
r => r,
},
};
match char::from_u32(scalar as u32) {
Some(c) => s.push(c),
None => return Err(format!("invalid character code {scalar} in string")),
}
}
Some(c) => {
self.pos += 1;
s.push(c);
}
}
}
Ok(Value::str(s))
}
fn read_char_literal(&mut self) -> Result<Value, String> {
self.pos += 1; let ch = self.read_char_spec()?;
let ch = match ch & !C_MODMASK {
c if c >= BYTE8_OFFSET + 0x80 => (c - BYTE8_OFFSET) | (ch & C_MODMASK),
_ => ch,
};
match self.peek() {
Some(c)
if !(c as u32 <= 32
|| matches!(
c,
'"' | '\'' | ';' | '(' | ')' | '[' | ']' | '#' | '?' | '`' | ',' | '.'
)) =>
{
Err("invalid-read-syntax: ?".to_string())
}
_ => Ok(Value::Int(ch)),
}
}
fn read_char_spec(&mut self) -> Result<i64, String> {
let c = self.peek().ok_or("end-of-file")?;
self.pos += 1;
if c != '\\' {
return Ok(c as i64);
}
let e = self.peek().ok_or("end-of-file")?;
let dash = self.peek_at(1) == Some('-');
match e {
'C' if dash => {
self.pos += 2;
Ok(apply_control(self.read_char_spec()?))
}
'^' => {
self.pos += 1;
Ok(apply_control(self.read_char_spec()?))
}
'M' if dash => {
self.pos += 2;
Ok(self.read_char_spec()? | C_META)
}
'S' if dash => {
self.pos += 2;
Ok(self.read_char_spec()? | C_SHIFT)
}
'H' if dash => {
self.pos += 2;
Ok(self.read_char_spec()? | C_HYPER)
}
's' if dash => {
self.pos += 2;
Ok(self.read_char_spec()? | C_SUPER)
}
'A' if dash => {
self.pos += 2;
Ok(self.read_char_spec()? | C_ALT)
}
's' => {
self.pos += 1;
Ok(32)
}
_ => self.read_escape_scalar(),
}
}
fn read_escape_scalar(&mut self) -> Result<i64, String> {
let e = self.peek().ok_or("end-of-file")?;
match e {
'x' => {
self.pos += 1;
let mut n: i64 = 0;
let mut count = 0;
while let Some(d) = self.peek().and_then(|c| c.to_digit(16)) {
n = n * 16 + d as i64;
self.pos += 1;
if n > C_META | (C_META - 1) {
return Err(format!("error: Hex character out of range: \\x{n:x}..."));
}
count += usize::from(count < 3);
}
if count == 0 {
return Err(
"error: Invalid escape char syntax: \\x not followed by hex digit"
.to_string(),
);
}
if count < 3 && n >= 0x80 {
n += BYTE8_OFFSET;
}
Ok(n)
}
'u' => {
self.pos += 1;
self.read_fixed_hex(4)
}
'U' => {
self.pos += 1;
self.read_fixed_hex(8)
}
'N' => {
self.pos += 1;
if self.peek() != Some('{') {
return Err("invalid-read-syntax: Expected opening brace after \\N".to_string());
}
self.pos += 1;
let mut name = String::new();
let mut whitespace = false;
loop {
let c = self.peek().ok_or("end-of-file")?;
self.pos += 1;
if c == '}' {
break;
}
if c as u32 >= 0x80 {
return Err(format!(
"invalid-read-syntax: Invalid character U+{:04X} in character name",
c as u32
));
}
let c = if c.is_ascii_whitespace() || c == '\x0b' {
if whitespace {
continue;
}
whitespace = true;
' '
} else {
whitespace = false;
c
};
name.push(c);
if name.len() >= 201 {
return Err("invalid-read-syntax: Character name too long".to_string());
}
}
if name.is_empty() {
return Err("invalid-read-syntax: Empty character name".to_string());
}
match name.strip_prefix("U+") {
Some(hex) => match i64::from_str_radix(hex, 16) {
Ok(n)
if !hex.starts_with(['+', '-'])
&& (0..=0x10FFFF).contains(&n)
&& !(0xD800..=0xDFFF).contains(&n) =>
{
Ok(n)
}
_ => Err(format!("invalid-read-syntax: \\N{{{name}}}")),
},
None => Err(format!("unsupported character name: {name}")),
}
}
'0'..='7' => {
let mut n: i64 = 0;
let mut count = 0;
while count < 3 {
match self.peek().and_then(|c| c.to_digit(8)) {
Some(d) => {
n = n * 8 + d as i64;
self.pos += 1;
count += 1;
}
None => break,
}
}
Ok(n)
}
other => {
self.pos += 1;
Ok(unescape(other) as i64)
}
}
}
fn read_control_target(&mut self) -> Result<i64, String> {
let nc = self.peek().ok_or("unterminated escape")?;
if nc == '\\' {
self.pos += 1;
self.read_escape_scalar()
} else {
self.pos += 1;
Ok(nc as i64)
}
}
fn read_fixed_hex(&mut self, n: usize) -> Result<i64, String> {
let letter = if n == 4 { 'u' } else { 'U' };
let mut val: u32 = 0;
for _ in 0..n {
let Some(c) = self.peek() else {
return Err(format!(
"error: Malformed Unicode escape: \\{letter}{val:x}"
));
};
self.pos += 1;
let Some(d) = c.to_digit(16) else {
return Err(format!(
"error: Non-hex character used for Unicode escape: {c} ({})",
c as u32
));
};
val = (val << 4) + d;
}
if val > 0x10FFFF {
return Err(format!("error: Non-Unicode character: 0x{val:x}"));
}
Ok(i64::from(val))
}
fn read_radix(&mut self, h: &mut ElispHost) -> Result<Value, String> {
self.pos += 1; let c = self.peek().ok_or("unterminated radix literal")?;
let base: u32 = match c {
'x' | 'X' => {
self.pos += 1;
16
}
'o' | 'O' => {
self.pos += 1;
8
}
'b' | 'B' => {
self.pos += 1;
2
}
'0'..='9' => {
let dstart = self.pos;
let mut n: i64 = c.to_digit(10).unwrap_or(0) as i64;
self.pos += 1;
let ended: char;
loop {
let Some(ch) = self.peek() else {
return Err(self.hash_syntax_err(dstart));
};
self.pos += 1;
let Some(d) = ch.to_digit(10) else {
ended = ch;
break;
};
match n.checked_mul(10).and_then(|v| v.checked_add(d as i64)) {
Some(v) => n = v,
None => return Err(self.hash_syntax_err(dstart)),
}
}
let read_circle = {
let sym = h.intern("read-circle");
h.get_value(&sym).map(|v| el_truthy(&v)).unwrap_or(true)
};
match ended {
'r' | 'R' => {
if n > 36 {
return Err(format!("invalid-read-syntax: integer, radix {n}"));
}
return self.read_integer(h, n as u32);
}
'=' if n <= crate::host::MOST_POSITIVE_FIXNUM && read_circle => {
return self.read_labelled(h, n);
}
'#' if n <= crate::host::MOST_POSITIVE_FIXNUM && read_circle => {
return self
.labels
.get(&n)
.cloned()
.ok_or_else(|| self.hash_syntax_err(dstart));
}
_ => return Err(self.hash_syntax_err(dstart)),
}
}
_ => return Err(format!("unsupported reader macro #{c}")),
};
self.read_integer(h, base)
}
fn hash_syntax_err(&self, dstart: usize) -> String {
let seen: String = self.chars[dstart..self.pos].iter().collect();
format!("invalid-read-syntax: #{seen}")
}
fn read_integer(&mut self, h: &mut ElispHost, radix: u32) -> Result<Value, String> {
let bad = || format!("invalid-read-syntax: integer, radix {radix}");
let mut digits = String::new();
let mut valid: i8 = -1;
let mut sign = 1i64;
let mut c = self.peek();
if c == Some('-') || c == Some('+') {
if c == Some('-') {
sign = -1;
}
self.pos += 1;
c = self.peek();
}
if c == Some('0') {
digits.push('0');
valid = 1;
loop {
self.pos += 1;
c = self.peek();
if c != Some('0') {
break;
}
}
}
while let Some(ch) = c {
match digit_to_number(ch, radix) {
None => break,
Some(d) => {
if d.is_none() {
valid = 0;
}
if valid < 0 {
valid = 1;
}
digits.push(ch);
}
}
self.pos += 1;
c = self.peek();
}
if valid != 1 {
return Err(bad());
}
if radix < 2 {
return Ok(if radix == 1 {
h.make_integer(BigInt::from(0))
} else {
Value::Undef
});
}
let n = BigInt::parse_bytes(digits.as_bytes(), radix).ok_or_else(bad)?;
Ok(h.make_integer(n * sign))
}
fn read_labelled(&mut self, h: &mut ElispHost, n: i64) -> Result<Value, String> {
let placeholder = h.cons(Value::Undef, Value::Undef);
let Value::Obj(ph_id) = placeholder else {
return Err("invalid-read-syntax: #".to_string());
};
self.labels.insert(n, placeholder.clone());
let obj = self.read_form(h)?;
let obj_cons = matches!(h.obj(&obj), Some(Obj::Cons(_, _)));
if obj_cons {
if obj == placeholder {
return Err("invalid-read-syntax: nonsensical self-reference".to_string());
}
let Some(Obj::Cons(car, cdr)) = h.obj(&obj) else {
return Err("invalid-read-syntax: #".to_string());
};
let (car, cdr) = (car.clone(), cdr.clone());
if let Some(Obj::Cons(a, d)) = h.arena.get_mut(ph_id as usize) {
*a = car;
*d = cdr;
}
self.completed.insert(ph_id);
return Ok(placeholder);
}
if let Value::Obj(id) = &obj {
if Reader::can_contain(h, &obj) {
self.completed.insert(*id);
}
}
let mut seen: HashSet<u32> = HashSet::new();
self.substitute(h, &obj, ph_id, &obj.clone(), &mut seen);
self.labels.insert(n, obj.clone());
Ok(obj)
}
fn can_contain(h: &ElispHost, v: &Value) -> bool {
match h.obj(v) {
Some(Obj::Symbol(_)) => false,
Some(Obj::Str(a)) => h
.string_props_vec(a)
.is_some_and(|p| p.iter().any(el_truthy)),
Some(_) => true,
None => false,
}
}
fn substitute(
&self,
h: &mut ElispHost,
object: &Value,
ph_id: u32,
subtree: &Value,
seen: &mut HashSet<u32>,
) -> Value {
let Value::Obj(id) = *subtree else {
return subtree.clone();
};
if id == ph_id {
return object.clone();
}
if !Reader::can_contain(h, subtree) {
return subtree.clone();
}
if seen.contains(&id) {
return subtree.clone();
}
if self.completed.contains(&id) {
seen.insert(id);
}
match h.arena.get(id as usize) {
Some(Obj::Cons(car, cdr)) => {
let (car, cdr) = (car.clone(), cdr.clone());
let car = self.substitute(h, object, ph_id, &car, seen);
let cdr = self.substitute(h, object, ph_id, &cdr, seen);
if let Some(Obj::Cons(a, d)) = h.arena.get_mut(id as usize) {
*a = car;
*d = cdr;
}
}
Some(Obj::Vector(items)) | Some(Obj::Record(items)) => {
let items = items.clone();
let next: Vec<Value> = items
.iter()
.map(|x| self.substitute(h, object, ph_id, x, seen))
.collect();
match h.arena.get_mut(id as usize) {
Some(Obj::Vector(slots)) | Some(Obj::Record(slots)) => *slots = next,
_ => {}
}
}
Some(Obj::Str(a)) => {
let a = a.clone();
if let Some(props) = h.string_props_vec(&a) {
let next: Vec<Value> = props
.iter()
.map(|x| self.substitute(h, object, ph_id, x, seen))
.collect();
h.string_set_props_vec(&a, next);
}
}
_ => {}
}
subtree.clone()
}
fn read_record(&mut self, h: &mut ElispHost) -> Result<Value, String> {
let lst = self.read_list(h)?;
let items = h.list_vec(&lst).ok_or("malformed #s(...) literal")?;
if items.is_empty() {
return Err("invalid-read-syntax: #s".to_string());
}
if h.sym_name(&items[0]).as_deref() == Some("hash-table") {
let mut test = 1u8; let mut weakness = Value::Undef;
let mut data: Vec<Value> = Vec::new();
let mut i = 1;
while i + 1 < items.len() {
match h.sym_name(&items[i]).as_deref() {
Some("weakness") => {
weakness = crate::builtins::hash_table_weakness_arg(h, &items[i + 1])?;
}
Some("test") => {
test = match h.sym_name(&items[i + 1]).as_deref() {
Some("eq") => 0,
Some("equal") => 2,
_ => 1,
};
}
Some("data") => data = h.list_vec(&items[i + 1]).unwrap_or_default(),
_ => {}
}
i += 2;
}
let mut slots = Vec::new();
let mut j = 0;
while j + 1 < data.len() {
slots.push(Some((data[j].clone(), data[j + 1].clone())));
j += 2;
}
let size = slots.len();
Ok(h.alloc(Obj::HashTable(ElHashTable::from_slots(
test,
slots,
Vec::new(),
size,
weakness,
))))
} else {
Ok(h.alloc(Obj::Record(items)))
}
}
fn read_propertized_string(&mut self, h: &mut ElispHost) -> Result<Value, String> {
let lst = self.read_list(h)?;
let items = h
.list_vec(&lst)
.ok_or_else(|| "invalid-read-syntax: #".to_string())?;
let Some(head) = items.first().cloned() else {
return Err("invalid-read-syntax: #".to_string());
};
let Some(s) = h.str_arc(&head) else {
return Err("invalid-read-syntax: #".to_string());
};
let len = s.chars().count() as i64;
let mut rest = &items[1..];
while !rest.is_empty() {
if rest.len() < 3 {
return Err("invalid-read-syntax: Invalid string property list".to_string());
}
let (beg, end) = (int_or_marker(h, &rest[0])?, int_or_marker(h, &rest[1])?);
let plist = validate_plist(h, &rest[2])?;
rest = &rest[3..];
let (lo, hi) = if beg > end { (end, beg) } else { (beg, end) };
if !(0 <= lo && lo <= hi && hi <= len) {
return Err(format!("args-out-of-range: {lo} {hi}"));
}
if lo != hi {
h.string_set_props(&s, lo as usize, hi as usize, &plist);
}
}
Ok(head)
}
fn read_bool_vector(&mut self, h: &mut ElispHost) -> Result<Value, String> {
self.pos += 2; let mut num = String::new();
while let Some(c) = self.peek() {
if c.is_ascii_digit() {
num.push(c);
self.pos += 1;
} else {
break;
}
}
let len: usize = num
.parse()
.map_err(|_| "invalid-read-syntax: #&".to_string())?;
if self.peek() != Some('"') {
return Err("invalid-read-syntax: #&".to_string());
}
let packed: Vec<u32> = match self.read_string()? {
Value::Str(s) => s.chars().map(|c| c as u32).collect(),
_ => unreachable!("read_string returns a transient string"),
};
let mut bits = Vec::with_capacity(len);
for i in 0..len {
let byte = packed.get(i / 8).copied().unwrap_or(0);
bits.push((byte >> (i % 8)) & 1 == 1);
}
Ok(h.alloc(Obj::BoolVector(bits)))
}
fn read_atom(&mut self, h: &mut ElispHost) -> Result<Value, String> {
let mut tok = String::new();
let mut had_escape = false;
while let Some(c) = self.peek() {
if c == '\\' {
self.pos += 1;
match self.peek() {
Some(e) => {
tok.push(e);
self.pos += 1;
had_escape = true;
}
None => return Err("end-of-file".to_string()),
}
} else if is_delim(c) {
break;
} else {
tok.push(c);
self.pos += 1;
}
}
if had_escape {
Ok(h.intern(&tok))
} else {
Ok(classify(h, &tok))
}
}
}
fn int_or_marker(h: &ElispHost, v: &Value) -> Result<i64, String> {
match v {
Value::Int(n) => Ok(*n),
_ => match h.marker_position(v) {
Some(p) => Ok(p as i64),
None => Err(format!(
"wrong-type-argument: integer-or-marker-p {}",
h.print(v, true)
)),
},
}
}
fn validate_plist(h: &mut ElispHost, v: &Value) -> Result<Value, String> {
if !el_truthy(v) {
return Ok(Value::Undef);
}
if matches!(h.obj(v), Some(Obj::Cons(..))) {
let mut tail = v.clone();
while let Some(Obj::Cons(_, d)) = h.obj(&tail) {
let d = d.clone();
let Some(Obj::Cons(_, d2)) = h.obj(&d) else {
return Err("error: Odd length text property list".to_string());
};
tail = d2.clone();
}
return Ok(v.clone());
}
let nil = h.cons(Value::Undef, Value::Undef);
Ok(h.cons(v.clone(), nil))
}
fn quoted(h: &mut ElispHost, head: &str, form: Value) -> Value {
let q = h.intern(head);
h.list_from(vec![q, form])
}
fn marker(h: &mut ElispHost, name: &str, form: Value) -> Value {
let s = h.intern(name);
h.list_from(vec![s, form])
}
const C_META: i64 = 1 << 27;
const C_CTL: i64 = 1 << 26;
const C_SHIFT: i64 = 1 << 25;
const C_HYPER: i64 = 1 << 24;
const C_SUPER: i64 = 1 << 23;
const C_ALT: i64 = 1 << 22;
const C_MODMASK: i64 = C_META | C_CTL | C_SHIFT | C_HYPER | C_SUPER | C_ALT;
const BYTE8_OFFSET: i64 = 0x3F_FF00;
fn apply_control(c: i64) -> i64 {
let mods = c & C_MODMASK;
let base = c & !C_MODMASK;
let ctrl = if base == '?' as i64 {
127
} else if (b'a' as i64..=b'z' as i64).contains(&base) {
base - b'a' as i64 + 1
} else if (64..=95).contains(&base) {
base ^ 64
} else {
return c | C_CTL;
};
ctrl | mods
}
fn unescape(e: char) -> char {
match e {
'n' => '\n',
't' => '\t',
'r' => '\r',
'0' => '\0',
'e' => '\u{1b}', 'a' => '\u{7}', 'b' => '\u{8}', 'v' => '\u{b}', 'f' => '\u{c}', 'd' => '\u{7f}', other => other,
}
}
fn classify(h: &mut ElispHost, tok: &str) -> Value {
match tok {
"nil" => return Value::Undef,
"t" => return Value::Bool(true),
_ => {}
}
if !tok.starts_with(':') {
if let Ok(i) = tok.parse::<i64>() {
return h.make_integer(BigInt::from(i));
}
if let Ok(b) = tok.parse::<BigInt>() {
return h.make_integer(b);
}
if let Some(intpart) = tok.strip_suffix('.') {
if let Ok(i) = intpart.parse::<i64>() {
return Value::Int(i);
}
if let Ok(b) = intpart.parse::<BigInt>() {
return h.make_integer(b);
}
}
if looks_numeric(tok) {
if let Ok(f) = tok.parse::<f64>() {
return Value::Float(f);
}
}
if let Some(mant) = split_nonfinite(tok, "INF") {
let inf = if mant.starts_with('-') {
f64::NEG_INFINITY
} else {
f64::INFINITY
};
return Value::Float(inf);
}
if let Some(mant) = split_nonfinite(tok, "NaN") {
return Value::Float(nan_with_payload(
leading_integer(mant),
mant.starts_with('-'),
));
}
}
h.intern(tok)
}
fn split_nonfinite<'a>(tok: &'a str, word: &str) -> Option<&'a str> {
let mant = tok
.strip_suffix(word)?
.strip_suffix('+')?
.strip_suffix(['e', 'E'])?;
mant.parse::<f64>().ok().map(|_| mant)
}
pub(crate) const NAN_PAYLOAD_MASK: u64 = 0x0007_FFFF_FFFF_FFFF;
pub(crate) fn nan_with_payload(payload: u64, negative: bool) -> f64 {
let f = f64::from_bits(0x7ff8_0000_0000_0000 | (payload & NAN_PAYLOAD_MASK));
if negative {
-f
} else {
f
}
}
pub(crate) fn leading_integer(mant: &str) -> u64 {
let digits = mant.strip_prefix(['+', '-']).unwrap_or(mant);
let mut chars = digits.chars();
let Some(first) = chars.next().and_then(|c| c.to_digit(10)) else {
return -2i64 as u64;
};
let mut n = first as u64;
for c in chars {
match c.to_digit(10) {
Some(d) => n = n.wrapping_mul(10).wrapping_add(d as u64),
None => break,
}
}
n
}
pub(crate) fn token_is_number(tok: &str) -> bool {
if tok.parse::<BigInt>().is_ok() {
return true;
}
if let Some(intpart) = tok.strip_suffix('.') {
if intpart.parse::<BigInt>().is_ok() {
return true;
}
}
if looks_numeric(tok) && tok.parse::<f64>().is_ok() {
return true;
}
["INF", "NaN"]
.iter()
.any(|word| split_nonfinite(tok, word).is_some())
}
fn looks_numeric(tok: &str) -> bool {
let mut seen_digit = false;
for c in tok.chars() {
match c {
'0'..='9' => seen_digit = true,
'+' | '-' | '.' | 'e' | 'E' => {}
_ => return false,
}
}
seen_digit
}
#[derive(Debug, Clone, PartialEq)]
pub enum Tok {
LParen,
RParen,
LBracket,
RBracket,
Quote,
Backquote,
Unquote,
UnquoteSplice,
FunctionQuote,
Hash(String),
Dot,
Char(String),
Str(String),
Number(String),
Symbol(String),
}
#[derive(Debug, Clone)]
pub struct Token {
pub tok: Tok,
pub line: u32,
}
fn dot_is_sep(chars: &[char], pos: usize) -> bool {
match chars.get(pos + 1) {
None => true,
Some(c) => {
c.is_whitespace() || matches!(c, '"' | '\'' | ';' | '(' | '[' | '#' | '?' | '`' | ',')
}
}
}
pub fn tokenize(src: &str) -> Result<Vec<Token>, String> {
let chars: Vec<char> = src.chars().collect();
let newlines = newline_positions(&chars);
let line_at = |p: usize| newlines.partition_point(|&x| x < p) as u32 + 1;
let mut pos = 0usize;
let mut out: Vec<Token> = Vec::new();
loop {
loop {
match chars.get(pos) {
Some(c) if c.is_whitespace() => pos += 1,
Some(';') => {
while let Some(&c) = chars.get(pos) {
pos += 1;
if c == '\n' {
break;
}
}
}
_ => break,
}
}
let Some(&c) = chars.get(pos) else { break };
let line = line_at(pos);
let tok = match c {
'(' => {
pos += 1;
Tok::LParen
}
')' => {
pos += 1;
Tok::RParen
}
'[' => {
pos += 1;
Tok::LBracket
}
']' => {
pos += 1;
Tok::RBracket
}
'\'' => {
pos += 1;
Tok::Quote
}
'`' => {
pos += 1;
Tok::Backquote
}
',' => {
pos += 1;
if chars.get(pos) == Some(&'@') {
pos += 1;
Tok::UnquoteSplice
} else {
Tok::Unquote
}
}
'"' => {
pos += 1;
let mut s = String::new();
loop {
match chars.get(pos) {
None => return Err("end-of-file".to_string()),
Some('"') => {
pos += 1;
break;
}
Some('\\') => {
s.push('\\');
pos += 1;
match chars.get(pos) {
Some(&e) => {
s.push(e);
pos += 1;
}
None => return Err("end-of-file".to_string()),
}
}
Some(&ch) => {
s.push(ch);
pos += 1;
}
}
}
Tok::Str(s)
}
'?' => {
pos += 1;
let mut s = String::new();
match chars.get(pos) {
None => return Err("end-of-file".to_string()),
Some('\\') => {
s.push('\\');
pos += 1;
while let Some(&ch) = chars.get(pos) {
if is_delim(ch) {
break;
}
s.push(ch);
pos += 1;
}
}
Some(&ch) => {
s.push(ch);
pos += 1;
}
}
Tok::Char(s)
}
'#' if chars.get(pos + 1) == Some(&'\'') => {
pos += 2;
Tok::FunctionQuote
}
'#' => {
let mut s = String::from("#");
pos += 1;
while let Some(&ch) = chars.get(pos) {
if is_delim(ch) {
break;
}
s.push(ch);
pos += 1;
}
Tok::Hash(s)
}
'.' if dot_is_sep(&chars, pos) => {
pos += 1;
Tok::Dot
}
_ => {
let mut s = String::new();
let mut escaped = false;
while let Some(&ch) = chars.get(pos) {
if ch == '\\' {
pos += 1;
match chars.get(pos) {
Some(&e) => {
s.push(e);
pos += 1;
escaped = true;
}
None => return Err("end-of-file".to_string()),
}
} else if is_delim(ch) {
break;
} else {
s.push(ch);
pos += 1;
}
}
if !escaped && token_is_number(&s) {
Tok::Number(s)
} else {
Tok::Symbol(s)
}
}
};
out.push(Token { tok, line });
}
Ok(out)
}
enum CtItem {
Val(Value),
Sub(SubCharTable),
}
impl Reader {
fn read_char_table_literal(&mut self, h: &mut ElispHost) -> Result<Value, String> {
self.pos += 2;
let mut seen = String::from("#^");
let sub = self.peek() == Some('^');
if sub {
self.pos += 1;
seen.push('^');
}
match self.peek() {
Some('[') => self.pos += 1,
Some(c) => return Err(format!("invalid-read-syntax: {seen}{c}")),
None => return Err(format!("invalid-read-syntax: {seen}")),
}
if sub {
self.read_sub_char_table(h)?;
return Err(
"error: elisprs keeps sub-char-tables inside their char-table; \
a #^^[...] outside one is not readable"
.to_string(),
);
}
let items = self.read_ct_items(h)?;
if items.len() < 4 + CT_SIZE[0] {
return Err("invalid-read-syntax: Invalid size char-table".to_string());
}
let mut items = items.into_iter();
let val = |item: Option<CtItem>| match item {
Some(CtItem::Val(v)) => Ok(v),
_ => Err(CT_NESTING.to_string()),
};
let default = val(items.next())?;
let parent = val(items.next())?;
let subtype = val(items.next())?;
let ascii = match items.next() {
Some(CtItem::Sub(_)) => CtAscii::Tree,
Some(CtItem::Val(v)) => CtAscii::Val(v),
None => CtAscii::Val(Value::Undef),
};
let mut contents = Vec::with_capacity(CT_SIZE[0]);
for i in 0..CT_SIZE[0] {
contents.push(ct_slot(items.next(), 0, i as u32 * CT_CHARS[0])?);
}
let extra = items
.map(|item| val(Some(item)))
.collect::<Result<Vec<_>, _>>()?;
Ok(h.alloc(Obj::CharTable(CharTable {
subtype,
default,
parent,
extra,
contents,
ascii,
})))
}
fn read_ct_items(&mut self, h: &mut ElispHost) -> Result<Vec<CtItem>, String> {
let mut items = Vec::new();
loop {
self.skip_ws();
let Some(c) = self.peek() else {
return Err("end-of-file".to_string());
};
if c == ']' {
self.pos += 1;
return Ok(items);
}
let rest = &self.chars[self.pos..];
let digits = rest
.iter()
.skip(1)
.take_while(|c| c.is_ascii_digit())
.count();
let label = (c == '#' && digits > 0)
.then(|| {
rest[1..=digits]
.iter()
.collect::<String>()
.parse::<i64>()
.ok()
})
.flatten();
let after = rest.get(1 + digits).copied();
let is_sub = |at: usize| rest.get(at..at + 4) == Some(&['#', '^', '^', '['][..]);
if is_sub(0) {
self.pos += 4;
items.push(CtItem::Sub(self.read_sub_char_table(h)?));
} else if let (Some(n), Some('='), true) = (label, after, is_sub(digits + 2)) {
self.pos += digits + 2 + 4;
let sub = self.read_sub_char_table(h)?;
self.sub_labels.insert(n, sub.clone());
items.push(CtItem::Sub(sub));
} else if let Some(sub) = label
.filter(|_| after == Some('#'))
.and_then(|n| self.sub_labels.get(&n))
{
items.push(CtItem::Sub(sub.clone()));
self.pos += digits + 2;
} else {
items.push(CtItem::Val(self.read_form(h)?));
}
}
}
fn read_sub_char_table(&mut self, h: &mut ElispHost) -> Result<SubCharTable, String> {
let items = self.read_ct_items(h)?;
if items.len() < 2 {
return Err("error: Invalid size of sub-char-table".to_string());
}
let mut items = items.into_iter();
let depth = match items.next() {
Some(CtItem::Val(Value::Int(d))) if (1..=3).contains(&d) => d as usize,
_ => return Err("error: Invalid depth in sub-char-table".to_string()),
};
if CT_SIZE[depth] != items.len() - 1 {
return Err("error: Invalid size in sub-char-table".to_string());
}
let min_char = match items.next() {
Some(CtItem::Val(Value::Int(m))) if (0..=i64::from(MAX_CHAR)).contains(&m) => m as u32,
_ => return Err("error: Invalid minimum character in sub-char-table".to_string()),
};
let contents = (0..CT_SIZE[depth])
.map(|i| ct_slot(items.next(), depth, min_char + i as u32 * CT_CHARS[depth]))
.collect::<Result<Vec<_>, _>>()?;
Ok(SubCharTable {
depth: depth as u8,
min_char,
contents,
})
}
}
const CT_NESTING: &str = "error: elisprs needs each sub-char-table at its own slot of the tree";
fn ct_slot(item: Option<CtItem>, depth: usize, first: u32) -> Result<CtSlot, String> {
match item {
Some(CtItem::Val(v)) => Ok(CtSlot::Val(v)),
Some(CtItem::Sub(s)) if usize::from(s.depth) == depth + 1 && s.min_char == first => {
Ok(CtSlot::Sub(Box::new(s)))
}
_ => Err(CT_NESTING.to_string()),
}
}