use super::*;
fn assign(
eng: &mut Engine,
global: bool,
text: &str,
assign: impl FnOnce(&mut Engine, &mut Lexer) -> R<()>,
) -> mlua::Result<()> {
let mut lx = Lexer::new(text);
eng.set_global_prefix(global);
let out = assign(eng, &mut lx);
eng.set_global_prefix(false);
out.map_err(|e| mlua::Error::runtime(e.0))
}
fn global_prefix(args: &Variadic<Value>, needed: usize) -> (bool, Vec<Value>) {
let is_global =
|v: &Value| matches!(v, Value::String(s) if s.to_str().is_ok_and(|s| &*s == "global"));
match args.first() {
Some(v) if args.len() > needed && is_global(v) => {
(true, args.iter().skip(1).cloned().collect())
}
_ => (false, args.iter().cloned().collect()),
}
}
enum Param {
Int(usize),
Dimen(i64),
Glue { slot: i64 },
Toks(i64),
}
fn param(name: &str) -> Option<Param> {
if let Some(i) = crate::intpar::index(name) {
return Some(Param::Int(i));
}
if let Some(slot) = crate::params::register_slot(name) {
if crate::params::DIMEN_NAMES.contains(&name)
|| crate::params::LUATEX_DIMEN_NAMES.contains(&name)
{
return Some(Param::Dimen(slot));
}
return Some(Param::Glue { slot });
}
crate::params::toks_register(name).map(Param::Toks)
}
fn get_param(
lua: &Lua,
bridge: &Rc<RefCell<Bridge>>,
arena: &Rc<RefCell<node::Arena>>,
p: &Param,
all: Option<bool>,
) -> mlua::Result<Variadic<Value>> {
let one = |v: Value| Ok(Variadic::from_iter([v]));
match p {
Param::Int(i) => {
let v = ctx::with("tex.get", |eng, _| Ok(eng.intpars.get(*i)))?;
one(Value::Integer(v))
}
Param::Dimen(slot) => one(Value::Integer(slot_value(&bridge.borrow(), *slot))),
Param::Glue { slot, .. } => {
let g = glue_get(&bridge.borrow(), *slot);
match all {
Some(false) => one(Value::Integer(g.0)),
Some(true) => Ok(Variadic::from_iter(
[g.0, g.1, g.2, g.3, g.4].map(Value::Integer),
)),
None => one(node::spec_node(lua, arena, g)?),
}
}
Param::Toks(reg) => {
let text = bridge.borrow().toks.get(reg).cloned().unwrap_or_default();
one(Value::String(lua.create_string(text)?))
}
}
}
fn set_param(
bridge: &Rc<RefCell<Bridge>>,
arena: &Rc<RefCell<node::Arena>>,
p: &Param,
global: bool,
values: &[Value],
) -> mlua::Result<()> {
let value = values.first().cloned().unwrap_or(Value::Nil);
match p {
Param::Int(i) => {
let Some(n) = value
.as_integer()
.or_else(|| value.as_number().map(|f| f as i64))
else {
return Err(mlua::Error::runtime("unsupported value type"));
};
let i = *i;
ctx::with("tex.set", |eng, _| {
assign(eng, global, &format!("={n} "), |eng, lx| {
eng.compile_time_intpar(lx, i)
})
})
}
Param::Dimen(slot) => {
let v = scaled_value(Kind::Dimen, &value)
.map_err(|_| mlua::Error::runtime("unsupported value type"))?;
let mut b = bridge.borrow_mut();
b.counts.insert(*slot, v);
b.counts_written.insert(*slot, v);
Ok(())
}
Param::Glue { slot, .. } => {
let g = match &value {
Value::Integer(_) | Value::Number(_) => {
let n = |i: usize| {
values
.get(i)
.and_then(|v| {
v.as_integer()
.or_else(|| v.as_number().map(|f| f.round() as i64))
})
.unwrap_or(0)
};
(n(0), n(1), n(2), n(3), n(4))
}
other => node::spec_values(arena, other)?,
};
glue_set(&mut bridge.borrow_mut(), *slot, g)
}
Param::Toks(reg) => {
let Value::String(s) = &value else {
return Err(mlua::Error::runtime("unsupported value type"));
};
let text = s.to_str()?.to_string();
let mut b = bridge.borrow_mut();
b.toks.insert(*reg, text.clone());
b.toks_written.insert(*reg, text);
Ok(())
}
}
}
fn get_item(lua: &Lua, name: &str) -> mlua::Result<Option<Value>> {
Ok(Some(match name {
"inputlineno" => {
Value::Integer(ctx::with("tex.inputlineno", |_, lx| Ok(lx.line() as i64))?)
}
"luatexversion" => Value::Integer(124),
"eTeXversion" => Value::Integer(2),
"eTeXminorversion" => Value::Integer(6),
"luatexrevision" => Value::String(lua.create_string("0")?),
"eTeXrevision" => Value::String(lua.create_string(".6")?),
"jobname" => Value::String(lua.create_string(jobname())?),
"currentgrouplevel" => Value::Integer(ctx::with("tex.currentgrouplevel", |eng, _| {
Ok(eng.group_level() as i64)
})?),
"catcodetable" => {
Value::Integer(ctx::with("tex.catcodetable", |eng, _| Ok(eng.cat_table))?)
}
_ => return Ok(None),
}))
}
pub(super) fn install(
lua: &Lua,
tex: &Table,
bridge: &Rc<RefCell<Bridge>>,
arena: &Rc<RefCell<node::Arena>>,
) -> mlua::Result<()> {
use crate::charcodes::Table as T;
let (b, a) = (Rc::clone(bridge), Rc::clone(arena));
tex.set(
"get",
lua.create_function(move |lua, args: Variadic<Value>| {
let mut args: Vec<Value> = args.into_iter().collect();
let all = match args.last() {
Some(Value::Boolean(v)) if args.len() > 1 => {
let v = *v;
args.pop();
Some(v)
}
_ => None,
};
let Some(Value::String(name)) = args.last() else {
return Ok(Variadic::from_iter([Value::Nil]));
};
let name = name.to_str()?.to_string();
if let Some(p) = param(&name) {
return get_param(lua, &b, &a, &p, all);
}
if let Some(v) = get_item(lua, &name)? {
return Ok(Variadic::from_iter([v]));
}
refused(&name).map(|_| Variadic::from_iter([Value::Nil]))
})?,
)?;
let (b, a) = (Rc::clone(bridge), Rc::clone(arena));
tex.set(
"set",
lua.create_function(move |_, args: Variadic<Value>| {
let n = args.len();
if n < 2 {
return Ok(());
}
let Value::String(name) = &args[n - 2] else {
return Ok(());
};
let global = n == 3
&& matches!(&args[0], Value::String(s) if s.to_str().is_ok_and(|s| &*s == "global"));
let name = name.to_str()?.to_string();
if name == "catcodetable" {
return set_catcodetable(global, &args[n - 1]);
}
match param(&name) {
Some(p) => set_param(&b, &a, &p, global, &args[n - 1..]),
None => refused(&name),
}
})?,
)?;
let mt = lua.create_table()?;
let (b, a) = (Rc::clone(bridge), Rc::clone(arena));
mt.set(
"__index",
lua.create_function(move |lua, (_, key): (Table, Value)| {
let Value::String(s) = &key else {
return Ok(Value::Nil);
};
let name = s.to_str()?.to_string();
if let Some(p) = param(&name) {
return Ok(get_param(lua, &b, &a, &p, None)?
.into_iter()
.next()
.unwrap_or(Value::Nil));
}
if let Some(v) = get_item(lua, &name)? {
return Ok(v);
}
refused(&name).map(|_| Value::Nil)
})?,
)?;
let (b, a) = (Rc::clone(bridge), Rc::clone(arena));
mt.set(
"__newindex",
lua.create_function(move |_, (t, key, value): (Table, Value, Value)| {
if let Value::String(s) = &key {
let name = s.to_str()?.to_string();
if let Some(p) = param(&name) {
return set_param(&b, &a, &p, false, &[value]);
}
if name == "catcodetable" {
return set_catcodetable(false, &value);
}
if parameter_reason(&key)?.is_some() {
return refused(&name);
}
}
t.raw_set(key, value)
})?,
)?;
tex.set_metatable(Some(mt))?;
let getcat = lua.create_function(|_, args: Variadic<Value>| {
let n = args.len();
let Some(c) = args.last().and_then(|v| v.as_integer()) else {
return Err(mlua::Error::runtime(
"bad argument to 'getcatcode' (number expected)",
));
};
check_char_range(c, "getcatcode", 65536 * 17)?;
let table = match n >= 2 {
true => args[n - 2].as_integer(),
false => None,
};
ctx::with("catcode", |eng, _| {
Ok(eng.cat_code_in(table.unwrap_or(eng.cat_table), c as u32))
})
})?;
let setcat = lua.create_function(|_, args: Variadic<Value>| {
let n = args.len();
let mut f = 0;
if n > 1 && matches!(args[0], Value::Table(_)) {
f += 1;
}
let mut global = false;
if n > 2
&& matches!(&args[f], Value::String(s) if s.to_str().is_ok_and(|s| &*s == "global"))
{
global = true;
f += 1;
}
let int = |i: usize, what: &str| {
args.get(i).and_then(|v| v.as_integer()).ok_or_else(|| {
mlua::Error::runtime(format!("bad argument to 'setcatcode' ({what} expected)"))
})
};
let table = match n - f == 3 {
true => Some(int(n - 3, "number")?),
false => None,
};
let c = int(n.wrapping_sub(2), "number")?;
check_char_range(c, "setcatcode", 65536 * 17)?;
let v = int(n - 1, "number")?;
check_char_range(v, "setcatcode", 16)?;
ctx::with("catcode", |eng, _| {
let table = table.unwrap_or(eng.cat_table);
match table == eng.cat_table && c <= 255 {
true => assign(eng, global, &format!("{c}={v} "), |eng, lx| {
eng.compile_time_catcode(lx)
}),
false => {
eng.assign_cat_code_in(table, c as u32, v, global);
Ok(())
}
}
})
})?;
tex.set("getcatcode", getcat.clone())?;
tex.set("setcatcode", setcat.clone())?;
let t = lua.create_table()?;
let mt = lua.create_table()?;
mt.set("__index", getcat)?;
mt.set("__newindex", setcat)?;
t.set_metatable(Some(mt))?;
tex.set("catcode", t)?;
for (name, code) in [
("lccode", T::Lower),
("uccode", T::Upper),
("sfcode", T::Space),
("mathcode", T::Math),
("delcode", T::Delimiter),
] {
let getter = lua.create_function(move |_, args: Variadic<Value>| {
let Some(c) = args.last().and_then(|v| v.as_integer()) else {
return Err(mlua::Error::runtime(format!(
"bad argument to 'get{name}' (number expected)"
)));
};
let ch = char::from_u32(c as u32)
.ok_or_else(|| mlua::Error::runtime("invalid character code"))?;
ctx::with(name, |eng, _| Ok(eng.charcodes.get(code, ch)))
})?;
let setter = lua.create_function(move |_, args: Variadic<Value>| {
let (global, args) = global_prefix(&args, 2);
let n = args.len();
let (Some(c), Some(v)) = (
args.get(n.wrapping_sub(2)).and_then(|v| v.as_integer()),
args.get(n.wrapping_sub(1)).and_then(|v| v.as_integer()),
) else {
return Err(mlua::Error::runtime(format!(
"bad arguments to 'set{name}'"
)));
};
ctx::with(name, |eng, _| {
let text = format!("{c}={v} ");
assign(eng, global, &text, |eng, lx| {
eng.compile_time_charcode(lx, code)
})
})
})?;
tex.set(format!("get{name}"), getter.clone())?;
tex.set(format!("set{name}"), setter.clone())?;
let t = lua.create_table()?;
let mt = lua.create_table()?;
mt.set("__index", getter)?;
mt.set("__newindex", setter)?;
t.set_metatable(Some(mt))?;
tex.set(name, t)?;
}
math_and_delimiter_codes(lua, tex)?;
tex.set(
"hashtokens",
lua.create_function(|lua, ()| {
let names = ctx::with("tex.hashtokens", |eng, _| {
let mut names: Vec<String> =
eng.meanings.keys().map(|n| n.name().to_string()).collect();
names.extend(
crate::luatex_primitives::TABLE
.iter()
.map(|(n, _, _)| n.to_string()),
);
names.sort();
names.dedup();
Ok(names)
})?;
lua.create_sequence_from(names)
})?,
)?;
tex.set(
"primitives",
lua.create_function(|lua, ()| {
lua.create_sequence_from(crate::luatex_primitives::TABLE.iter().map(|(n, _, _)| *n))
})?,
)?;
tex.set(
"badness",
lua.create_function(|_, (t, s): (i64, i64)| Ok(badness(t, s)))?,
)?;
Ok(())
}
fn math_and_delimiter_codes(lua: &Lua, tex: &Table) -> mlua::Result<()> {
use crate::charcodes::Table as T;
fn code_of(args: &Variadic<Value>, what: &str) -> mlua::Result<char> {
let c = args.last().and_then(|v| v.as_integer()).ok_or_else(|| {
mlua::Error::runtime(format!("bad argument to '{what}' (number expected)"))
})?;
char::from_u32(c as u32)
.ok_or_else(|| mlua::Error::runtime(format!("{what}: invalid character code")))
}
let math_parts = |v: i64| [v >> 12, (v >> 8) & 15, v & 255];
let del_parts = |v: i64| match v < 0 {
true => [-1, 0, 0, 0],
false => [(v >> 20) & 15, (v >> 12) & 255, (v >> 8) & 15, v & 255],
};
let get = move |table: T, args: &Variadic<Value>, what: &str| -> mlua::Result<Vec<i64>> {
let c = code_of(args, what)?;
let v = ctx::with(what, |eng, _| Ok(eng.charcodes.get(table, c)))?;
Ok(match table {
T::Math => math_parts(v).to_vec(),
_ => del_parts(v).to_vec(),
})
};
for (name, table) in [("mathcode", T::Math), ("delcode", T::Delimiter)] {
let getter = lua.create_function(move |lua, args: Variadic<Value>| {
lua.create_sequence_from(get(table, &args, &format!("get{name}"))?)
})?;
tex.set(
format!("get{name}s"),
lua.create_function(move |_, args: Variadic<Value>| {
Ok(Variadic::from_iter(
get(table, &args, &format!("get{name}s"))?
.into_iter()
.map(Value::Integer),
))
})?,
)?;
let parts = match table {
T::Math => 3,
_ => 4,
};
let setter = lua.create_function(move |_, args: Variadic<Value>| {
let mut rest: Vec<Value> = args.into_iter().collect();
let global = matches!(rest.first(), Some(Value::String(s)) if s.to_str().is_ok_and(|s| &*s == "global"));
if global {
rest.remove(0);
}
if matches!(rest.first(), Some(Value::Table(_))) && rest.len() > 2 {
rest.remove(0);
}
let bad = || mlua::Error::runtime(format!("Bad arguments for tex.set{name}()"));
let c = rest.first().and_then(|v| v.as_integer()).ok_or_else(bad)?;
let vals: Vec<i64> = match rest.get(1) {
Some(Value::Table(t)) => (1..=parts).map(|i| t.raw_get::<i64>(i)).collect::<mlua::Result<_>>()?,
Some(_) => rest[1..].iter().take(parts).map(|v| v.as_integer().ok_or_else(bad)).collect::<mlua::Result<_>>()?,
None => return Err(bad()),
};
if vals.len() != parts {
return Err(bad());
}
let packed = match table {
T::Math if vals[1] < 16 && vals[2] < 256 => vals[0] * 0x1000 + vals[1] * 0x100 + vals[2],
T::Delimiter if vals[0] < 0 => -1,
T::Delimiter if vals[0] < 16 && vals[1] < 256 && vals[2] < 16 && vals[3] < 256 => {
vals[0] * 0x10_0000 + vals[1] * 0x1000 + vals[2] * 0x100 + vals[3]
}
_ => {
return Err(mlua::Error::runtime(format!(
"tex.set{name}: a family past 15 or a character past 255 is a \\U{name}, \
which texrs's TeX82 {name} table cannot hold"
)))
}
};
ctx::with(name, |eng, _| {
assign(eng, global, &format!("{c}={packed} "), |eng, lx| eng.compile_time_charcode(lx, table))
})
})?;
tex.set(format!("get{name}"), getter.clone())?;
tex.set(format!("set{name}"), setter.clone())?;
let t = lua.create_table()?;
let mt = lua.create_table()?;
mt.set("__index", getter)?;
mt.set("__newindex", setter)?;
t.set_metatable(Some(mt))?;
tex.set(name, t)?;
}
Ok(())
}
fn badness(t: i64, s: i64) -> i64 {
const INF_BAD: i64 = 10000;
if t == 0 {
return 0;
}
if s <= 0 {
return INF_BAD;
}
let r = if t <= 7_230_584 {
(t * 297) / s
} else if s >= 1_663_497 {
t / (s / 297)
} else {
t
};
if r > 1290 {
INF_BAD
} else {
(r * r * r + 0x20000) / 0x40000
}
}
fn check_char_range(j: i64, name: &str, lim: i64) -> mlua::Result<()> {
match (0..lim).contains(&j) {
true => Ok(()),
false => Err(mlua::Error::runtime(format!(
"incorrect character value {j} for tex.{name}()"
))),
}
}
fn set_catcodetable(global: bool, value: &Value) -> mlua::Result<()> {
let n = value
.as_integer()
.ok_or_else(|| mlua::Error::runtime("tex.catcodetable wants a number"))?;
ctx::with("tex.catcodetable", |eng, _| {
assign(eng, global, &format!("={n} "), |eng, lx| {
eng.compile_time_catcodetable(lx)
})
})
}
fn refused(name: &str) -> mlua::Result<()> {
let key_ok = name.to_string();
let lua_free = parameter_reason_text(&key_ok);
match lua_free {
Some(why) => Err(mlua::Error::runtime(why)),
None => Ok(()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn badness_is_tex_webs() {
assert_eq!(badness(10, 10), 100);
assert_eq!(badness(5, 10), 12);
assert_eq!(badness(0, 0), 0);
assert_eq!(badness(1, 0), 10000);
assert_eq!(badness(14, 10), 273);
assert_eq!(badness(100, 3), 10000);
}
}