use std::path::Path;
use mlua::{Function, Value};
use crate::{Error, Result};
use super::Runtime;
impl Runtime {
pub(super) fn load_chunk(&self, data: Vec<u8>, path: &Path) -> mlua::Result<Function> {
load_chunk_in(&self.lua, data, path)
}
pub fn eval_script(&self, path: &Path) -> Result<Value> {
self.budgeted(|lua| eval_script(lua, path))
}
}
pub fn eval_script(lua: &mlua::Lua, path: &Path) -> Result<Value> {
let data = std::fs::read(path).map_err(|err| {
Error::Script(format!(
"failed to read the Lua script {}: {err}",
path.display()
))
})?;
load_chunk_in(lua, data, path)
.and_then(|chunk| chunk.call(()))
.map_err(|err| load_error(path, err))
}
pub(super) fn load_error(path: &Path, err: mlua::Error) -> Error {
let info = crate::error::ErrorInfo::from_error(&Error::Lua(err));
let mut out = info.message.clone();
match info.line {
Some(line) => {
let token = crate::error::message_token(&info.message);
match crate::error::source_snippet(path, line, 2, token) {
Some(snippet) => {
out.push('\n');
out.push_str(&snippet);
}
None => out.push_str(&format!("\n --> {}:{line}", path.display())),
};
}
None => out.push_str(&format!("\n --> {}", path.display())),
}
if let Some(traceback) = &info.traceback {
out.push_str("\nstack traceback:\n");
out.push_str(traceback);
}
Error::Script(out)
}
fn starts_as_statement(src: &[u8]) -> bool {
let rest = skip_trivia(src);
let is_word = |b: &u8| b.is_ascii_alphanumeric() || *b == b'_';
let word_end = rest.iter().position(|b| !is_word(b)).unwrap_or(rest.len());
match &rest[..word_end] {
b"local" | b"return" | b"if" | b"for" | b"while" | b"do" | b"repeat" | b"goto"
| b"break" => true,
b"function" => skip_trivia(&rest[word_end..])
.first()
.is_some_and(|b| b.is_ascii_alphabetic() || *b == b'_'),
_ => rest.starts_with(b"::"),
}
}
fn skip_trivia(mut src: &[u8]) -> &[u8] {
loop {
let ws = src
.iter()
.position(|b| !b.is_ascii_whitespace())
.unwrap_or(src.len());
src = &src[ws..];
let Some(body) = src.strip_prefix(b"--") else {
return src;
};
src = match long_bracket_level(body) {
Some(level) => {
let open = level + 2;
let mut close = Vec::with_capacity(level + 2);
close.push(b']');
close.extend(std::iter::repeat_n(b'=', level));
close.push(b']');
match body[open..]
.windows(close.len())
.position(|window| window == close.as_slice())
{
Some(at) => &body[open + at + close.len()..],
None => return &[],
}
}
None => match body.iter().position(|b| *b == b'\n') {
Some(at) => &body[at + 1..],
None => return &[],
},
};
}
}
fn long_bracket_level(s: &[u8]) -> Option<usize> {
let after_open = s.strip_prefix(b"[")?;
let level = after_open.iter().take_while(|b| **b == b'=').count();
(after_open.get(level) == Some(&b'[')).then_some(level)
}
fn load_chunk_in(lua: &mlua::Lua, data: Vec<u8>, path: &Path) -> mlua::Result<Function> {
let name = format!("@{}", path.display());
let expr_err = if starts_as_statement(&data) {
None
} else {
let mut wrapped = Vec::with_capacity(data.len() + 7);
wrapped.extend_from_slice(b"return ");
wrapped.extend_from_slice(&data);
match lua
.load(wrapped)
.set_name(&name)
.set_mode(mlua::chunk::ChunkMode::Text)
.into_function()
{
Ok(f) => return Ok(f),
Err(err) => Some(err),
}
};
match lua
.load(data)
.set_name(&name)
.set_mode(mlua::chunk::ChunkMode::Text)
.into_function()
{
Ok(f) => Ok(f),
Err(block_err) => {
let Some(expr_err) = expr_err else {
return Err(block_err);
};
let line = |err: &mlua::Error| {
crate::error::ErrorInfo::from_error(&Error::Lua(err.clone()))
.line
.unwrap_or(0)
};
if line(&expr_err) > line(&block_err) {
Err(expr_err)
} else {
Err(block_err)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn statement_only_prefixes_skip_the_expression_parse() {
for src in [
"local app = nitr.app()",
" \n\t-- a comment\n\nlocal x = 1",
"--[[ multi\nline ]] return {}",
"--[==[ a ]] inside ]==]\nfunction handler(req) end",
"-- one\n-- two\nif x then end",
"for i = 1, 2 do end",
"while true do end",
"do end",
"repeat until true",
"goto top",
"break",
"::top::",
"return",
] {
assert!(starts_as_statement(src.as_bytes()), "{src:?}");
}
}
#[test]
fn expression_capable_prefixes_keep_the_expression_parse() {
for src in [
"function(req) return req end",
"function (req) return req end",
"-- comment\nfunction(db)\n return {}\nend",
"{ a = 1 }",
"nitr.app()",
"string.rep('a', 2)",
"localx = 1",
"returned = 1",
"'a string'",
"42",
"",
" ",
"-- only a comment",
"--[[ unterminated",
"#!/usr/bin/lua\nlocal x = 1",
"\x0blocal x = 1",
] {
assert!(!starts_as_statement(src.as_bytes()), "{src:?}");
}
}
#[test]
fn long_brackets_parse_by_level() {
assert_eq!(long_bracket_level(b"[[x"), Some(0));
assert_eq!(long_bracket_level(b"[==[x"), Some(2));
assert_eq!(long_bracket_level(b"[=x"), None);
assert_eq!(long_bracket_level(b"x"), None);
assert_eq!(long_bracket_level(b""), None);
assert_eq!(skip_trivia(b"--[==[ ]=] ]==]rest"), b"rest");
}
}