use mlua::{Lua, Result as LuaResult, Table, Value};
use regex::RegexBuilder;
pub fn register_lpeg_library(lua: &Lua) -> LuaResult<()> {
let globals = lua.globals();
let lpeg = lua.create_table()?;
let p_fn = lua.create_function(|lua, pattern: String| {
let pattern_table = lua.create_table()?;
pattern_table.set("pattern", pattern.clone())?;
pattern_table.set("type", "P")?;
Ok(pattern_table)
})?;
lpeg.set("P", p_fn)?;
let r_fn = lua.create_function(|lua, range: String| {
let pattern_table = lua.create_table()?;
pattern_table.set("range", range.clone())?;
pattern_table.set("type", "R")?;
Ok(pattern_table)
})?;
lpeg.set("R", r_fn)?;
let s_fn = lua.create_function(|lua, set: String| {
let pattern_table = lua.create_table()?;
pattern_table.set("set", set.clone())?;
pattern_table.set("type", "S")?;
Ok(pattern_table)
})?;
lpeg.set("S", s_fn)?;
let v_fn = lua.create_function(|lua, varname: String| {
let pattern_table = lua.create_table()?;
pattern_table.set("varname", varname.clone())?;
pattern_table.set("type", "V")?;
Ok(pattern_table)
})?;
lpeg.set("V", v_fn)?;
let c_fn = lua.create_function(|lua, pattern: Table| {
let capture_table = lua.create_table()?;
capture_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
capture_table.set("type", "C")?;
Ok(capture_table)
})?;
lpeg.set("C", c_fn)?;
let cf_fn = lua.create_function(|lua, (pattern, _func): (Table, Table)| {
let capture_table = lua.create_table()?;
capture_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
capture_table.set("type", "Cf")?;
Ok(capture_table)
})?;
lpeg.set("Cf", cf_fn)?;
let cg_fn = lua.create_function(|lua, (pattern, name): (Table, String)| {
let capture_table = lua.create_table()?;
capture_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
capture_table.set("name", name)?;
capture_table.set("type", "Cg")?;
Ok(capture_table)
})?;
lpeg.set("Cg", cg_fn)?;
let cmt_fn = lua.create_function(|lua, (pattern, _func): (Table, Table)| {
let capture_table = lua.create_table()?;
capture_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
capture_table.set("type", "Cmt")?;
Ok(capture_table)
})?;
lpeg.set("Cmt", cmt_fn)?;
let cs_fn = lua.create_function(|lua, pattern: Table| {
let capture_table = lua.create_table()?;
capture_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
capture_table.set("type", "Cs")?;
Ok(capture_table)
})?;
lpeg.set("Cs", cs_fn)?;
let ct_fn = lua.create_function(|lua, pattern: Table| {
let capture_table = lua.create_table()?;
capture_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
capture_table.set("type", "Ct")?;
Ok(capture_table)
})?;
lpeg.set("Ct", ct_fn)?;
let cc_fn = lua.create_function(|lua, value: String| {
let capture_table = lua.create_table()?;
capture_table.set("value", value)?;
capture_table.set("type", "Cc")?;
Ok(capture_table)
})?;
lpeg.set("Cc", cc_fn)?;
let match_fn = lua.create_function(|lua, (pattern, text): (Table, String)| {
let pat = pattern.get::<String>("pattern").unwrap_or_default();
match RegexBuilder::new(&pat).size_limit(50_000).build() {
Ok(re) => {
if let Some(m) = re.find(&text) {
let result = lua.create_table()?;
result.set(1, m.start() + 1)?; result.set(2, m.end())?;
result.set("match", m.as_str())?;
Ok(Value::Table(result))
} else {
Ok(Value::Nil)
}
}
Err(_) => Ok(Value::Nil),
}
})?;
lpeg.set("match", match_fn)?;
let find_fn = lua.create_function(
|lua, (pattern, text, init): (Table, String, Option<usize>)| {
let pat = pattern.get::<String>("pattern").unwrap_or_default();
let start = init.unwrap_or(1).saturating_sub(1);
if start < text.len() {
match RegexBuilder::new(&pat).size_limit(50_000).build() {
Ok(re) => {
let search_text = &text[start..];
if let Some(m) = re.find(search_text) {
let result = lua.create_table()?;
result.set(1, start + m.start() + 1)?; result.set(2, start + m.end())?;
Ok(result)
} else {
Ok(lua.create_table()?)
}
}
Err(_) => Ok(lua.create_table()?),
}
} else {
Ok(lua.create_table()?)
}
},
)?;
lpeg.set("find", find_fn)?;
let gsub_fn = lua.create_function(
|_lua, (pattern, text, replacement): (String, String, String)| match RegexBuilder::new(
&pattern,
)
.size_limit(50_000)
.build()
{
Ok(re) => {
let new_str = re.replace_all(&text, replacement.as_str());
let count = re.find_iter(&text).count();
let result = _lua.create_table()?;
result.set(1, new_str)?;
result.set(2, count)?;
Ok(result)
}
Err(e) => Err(mlua::Error::RuntimeError(e.to_string())),
},
)?;
lpeg.set("gsub", gsub_fn)?;
let b_fn = lua.create_function(|lua, pattern: Table| {
let pattern_table = lua.create_table()?;
pattern_table.set(
"pattern",
pattern.get::<String>("pattern").unwrap_or_default(),
)?;
pattern_table.set("type", "B")?;
Ok(pattern_table)
})?;
lpeg.set("B", b_fn)?;
let type_fn = lua.create_function(|_lua, value: Value| match value {
Value::Table(t) => match t.get::<String>("type") {
Ok(t) => Ok(t),
_ => match t.get::<String>("pattern") {
Ok(_) => Ok("pattern".to_string()),
_ => Ok("table".to_string()),
},
},
_ => Ok("unknown".to_string()),
})?;
lpeg.set("type", type_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("1.0.0"))?;
lpeg.set("version", version_fn)?;
let setmaxstack_fn = lua.create_function(|_lua, size: usize| Ok(size))?;
lpeg.set("setmaxstack", setmaxstack_fn)?;
globals.set("lpeg", lpeg)?;
Ok(())
}