#[cfg(all(feature = "no_std", not(feature = "std")))]
use alloc::{
format,
string::{String, ToString},
vec::Vec,
};
use crate::error::NyblError;
use crate::memory::MemoryContext;
use crate::parser::{VariantDecl, VariantKind};
use crate::value::Value;
pub const RANGE_MAX_ITEMS: usize = 10_000;
pub const RANGE_LIMIT_ERROR_MESSAGE: &str = "range() would produce more than 10,000 values";
pub const RANGE_LIMIT_HINT: &str =
"Use a smaller range, a larger step, or process values in smaller chunks.";
pub fn builtin_result_variants() -> Vec<VariantDecl> {
alloc_import::vec![
VariantDecl {
name: String::from("Ok"),
kind: VariantKind::Tuple(alloc_import::vec![String::from("value")]),
},
VariantDecl {
name: String::from("Err"),
kind: VariantKind::Tuple(alloc_import::vec![String::from("error")]),
},
]
}
pub fn builtin_runtime_error_fields() -> Vec<String> {
alloc_import::vec![String::from("message"), String::from("line")]
}
pub fn builtin_iter_variants() -> Vec<VariantDecl> {
alloc_import::vec![
VariantDecl {
name: String::from("Next"),
kind: VariantKind::Tuple(alloc_import::vec![String::from("value")]),
},
VariantDecl {
name: String::from("Done"),
kind: VariantKind::Unit,
},
]
}
pub fn make_iter_next(value: Value, line: u32) -> Result<Value, NyblError> {
make_iter_next_in(value, line, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn make_iter_next_in(
value: Value,
line: u32,
memory: &MemoryContext,
) -> Result<Value, NyblError> {
let items: Vec<Value> = alloc_import::vec![value];
Value::__try_new_enum_tuple_in(
String::from(crate::value::BUILTIN_MODULE_PATH),
String::from("Iter"),
String::from("Next"),
items,
line,
memory,
)
}
pub fn make_iter_done() -> Value {
make_iter_done_in(&MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn make_iter_done_in(memory: &MemoryContext) -> Value {
Value::__new_enum_unit_in(
String::from(crate::value::BUILTIN_MODULE_PATH),
String::from("Iter"),
String::from("Done"),
memory,
)
}
#[cfg(all(feature = "no_std", not(feature = "std")))]
use alloc as alloc_import;
#[cfg(any(feature = "std", not(feature = "no_std")))]
use std as alloc_import;
pub fn builtin_range(args: &[Value], line: u32, rand_state: &mut u64) -> Result<Value, NyblError> {
builtin_range_in(args, line, rand_state, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn builtin_range_in(
args: &[Value],
line: u32,
rand_state: &mut u64,
memory: &MemoryContext,
) -> Result<Value, NyblError> {
let _ = rand_state; let (start, end, step) = match args.len() {
1 => {
let n = expect_int("range", &args[0], line)?;
(0i64, n, 1i64)
}
2 => {
let start = expect_int("range", &args[0], line)?;
let end = expect_int("range", &args[1], line)?;
(start, end, if start <= end { 1 } else { -1 })
}
3 => {
let start = expect_int("range", &args[0], line)?;
let end = expect_int("range", &args[1], line)?;
let step = expect_int("range", &args[2], line)?;
if step == 0 {
return Err(error(line, "range step can't be 0"));
}
(start, end, step)
}
_ => return Err(error(line, "range takes 1, 2, or 3 arguments")),
};
let count = range_cardinality(start, end, step);
if count > RANGE_MAX_ITEMS as u128 {
return Err(range_limit_error(line));
}
let len = usize::try_from(count).map_err(|_| range_memory_error(line))?;
let bytes = len
.checked_mul(core::mem::size_of::<Value>())
.ok_or_else(|| range_memory_error(line))?;
if memory.__would_exceed(bytes) {
return Err(range_memory_error(line));
}
let mut result = Vec::new();
result
.try_reserve_exact(len)
.map_err(|_| range_memory_error(line))?;
let mut i = start;
for index in 0..len {
result.push(Value::Int(i));
if index + 1 < len {
i = i
.checked_add(step)
.ok_or_else(|| error(line, "range arithmetic overflow"))?;
}
}
Value::__try_new_array_in(result, line, memory)
}
fn range_cardinality(start: i64, end: i64, step: i64) -> u128 {
let (distance, stride) = if step > 0 && start < end {
((end as i128 - start as i128) as u128, step as u128)
} else if step < 0 && start > end {
(
(start as i128 - end as i128) as u128,
-(step as i128) as u128,
)
} else {
return 0;
};
1 + (distance - 1) / stride
}
fn range_memory_error(line: u32) -> NyblError {
error_fatal_with_hint(
line,
"Memory limit exceeded",
"This range would create too many values.",
)
}
fn range_limit_error(line: u32) -> NyblError {
error_fatal_with_hint(line, RANGE_LIMIT_ERROR_MESSAGE, RANGE_LIMIT_HINT)
}
pub fn finite_to_int_or_number(n: f64) -> Value {
if n.is_finite() && n >= i64::MIN as f64 && n < i64::MAX as f64 {
Value::Int(n as i64)
} else {
Value::Number(n)
}
}
pub fn builtin_panic(args: &[Value], line: u32) -> Result<Value, NyblError> {
expect_args("panic", args, 1, line)?;
let message = match &args[0] {
Value::Str(s) => s.as_str().to_string(),
other => format!("{other}"),
};
Err(error(line, message))
}
pub fn builtin_rand(args: &[Value], line: u32, rand_state: &mut u64) -> Result<Value, NyblError> {
expect_args("rand", args, 1, line)?;
let n = expect_int("rand", &args[0], line)?;
if n <= 0 {
return Err(error(line, "rand needs a positive number"));
}
*rand_state = rand_state
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
let value = (*rand_state >> 33) % (n as u64);
Ok(Value::Int(value as i64))
}
pub fn expect_args(
name: &str,
args: &[Value],
expected: usize,
line: u32,
) -> Result<(), NyblError> {
if args.len() != expected {
Err(error(
line,
format!(
"`{}` expects {} argument{}, but got {}",
name,
expected,
if expected == 1 { "" } else { "s" },
args.len()
),
))
} else {
Ok(())
}
}
pub fn expect_number(func_name: &str, val: &Value, line: u32) -> Result<f64, NyblError> {
match val {
Value::Int(n) => Ok(*n as f64),
Value::Number(n) => Ok(*n),
_ => Err(error(
line,
format!(
"`{}` expects a number, but got {}",
func_name,
val.type_name()
),
)),
}
}
pub fn expect_int(func_name: &str, val: &Value, line: u32) -> Result<i64, NyblError> {
match val {
Value::Int(n) => Ok(*n),
_ => Err(error(
line,
format!(
"`{}` expects an int, but got {}",
func_name,
val.type_name()
),
)),
}
}
pub fn error(line: u32, message: impl Into<String>) -> NyblError {
NyblError {
line: Some(line),
column: None,
message: message.into(),
friendly_hint: None,
source_context: None,
is_fatal: false,
is_try_return: false,
}
}
pub fn error_at(
line: u32,
column: Option<core::num::NonZeroU32>,
message: impl Into<String>,
) -> NyblError {
NyblError {
line: Some(line),
column: column.map(|c| c.get()),
message: message.into(),
friendly_hint: None,
source_context: None,
is_fatal: false,
is_try_return: false,
}
}
pub fn error_with_hint(
line: u32,
message: impl Into<String>,
hint: impl Into<String>,
) -> NyblError {
NyblError {
line: Some(line),
column: None,
message: message.into(),
friendly_hint: Some(hint.into()),
source_context: None,
is_fatal: false,
is_try_return: false,
}
}
pub fn error_with_hint_at(
line: u32,
column: Option<core::num::NonZeroU32>,
message: impl Into<String>,
hint: impl Into<String>,
) -> NyblError {
NyblError {
line: Some(line),
column: column.map(|c| c.get()),
message: message.into(),
friendly_hint: Some(hint.into()),
source_context: None,
is_fatal: false,
is_try_return: false,
}
}
pub fn error_fatal_with_hint(
line: u32,
message: impl Into<String>,
hint: impl Into<String>,
) -> NyblError {
NyblError {
line: Some(line),
column: None,
message: message.into(),
friendly_hint: Some(hint.into()),
source_context: None,
is_fatal: true,
is_try_return: false,
}
}
pub fn error_fatal(line: u32, message: impl Into<String>) -> NyblError {
NyblError {
line: Some(line),
column: None,
message: message.into(),
friendly_hint: None,
source_context: None,
is_fatal: true,
is_try_return: false,
}
}
pub fn make_try_call_ok(value: Value, line: u32) -> Result<Value, NyblError> {
make_try_call_ok_in(value, line, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn make_try_call_ok_in(
value: Value,
line: u32,
memory: &MemoryContext,
) -> Result<Value, NyblError> {
let items: Vec<Value> = alloc_import::vec![value];
Value::__try_new_enum_tuple_in(
String::from(crate::value::BUILTIN_MODULE_PATH),
String::from("Result"),
String::from("Ok"),
items,
line,
memory,
)
}
pub fn make_try_call_err(err: &NyblError) -> Value {
make_try_call_err_in(err, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn make_try_call_err_in(err: &NyblError, memory: &MemoryContext) -> Value {
let message = Value::__new_str_in(err.message.clone(), memory);
let line = Value::Int(err.line.unwrap_or(0) as i64);
let fields: Vec<(String, Value)> = alloc_import::vec![
(String::from("message"), message),
(String::from("line"), line),
];
let rt_err = Value::__try_new_struct_in(
String::from(crate::value::BUILTIN_MODULE_PATH),
String::from("RuntimeError"),
fields,
0,
memory,
)
.expect("builtin RuntimeError has bounded ownership depth");
let items: Vec<Value> = alloc_import::vec![rt_err];
Value::__try_new_enum_tuple_in(
String::from(crate::value::BUILTIN_MODULE_PATH),
String::from("Result"),
String::from("Err"),
items,
0,
memory,
)
.expect("builtin Result::Err has bounded ownership depth")
}
pub fn check_string_repeat_memory(len: usize, count: usize, line: u32) -> Result<(), NyblError> {
check_string_repeat_memory_in(len, count, line, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn check_string_repeat_memory_in(
len: usize,
count: usize,
line: u32,
memory: &MemoryContext,
) -> Result<(), NyblError> {
let result_len = len.saturating_mul(count);
if memory.__would_exceed(result_len) {
Err(error_fatal_with_hint(
line,
"Memory limit exceeded",
"This string repeat would use too much memory.",
))
} else {
Ok(())
}
}
pub fn check_string_concat_memory(a_len: usize, b_len: usize, line: u32) -> Result<(), NyblError> {
check_string_concat_memory_in(a_len, b_len, line, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn check_string_concat_memory_in(
a_len: usize,
b_len: usize,
line: u32,
memory: &MemoryContext,
) -> Result<(), NyblError> {
let result_len = a_len + b_len;
if memory.__would_exceed(result_len) {
Err(error_fatal_with_hint(
line,
"Memory limit exceeded",
"This string concatenation would use too much memory.",
))
} else {
Ok(())
}
}
pub fn check_array_concat_memory(a_len: usize, b_len: usize, line: u32) -> Result<(), NyblError> {
check_array_concat_memory_in(a_len, b_len, line, &MemoryContext::__legacy_current())
}
#[doc(hidden)]
pub fn check_array_concat_memory_in(
a_len: usize,
b_len: usize,
line: u32,
memory: &MemoryContext,
) -> Result<(), NyblError> {
let result_bytes = (a_len + b_len) * core::mem::size_of::<Value>();
if memory.__would_exceed(result_bytes) {
Err(error_fatal_with_hint(
line,
"Memory limit exceeded",
"This array concatenation would use too much memory.",
))
} else {
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
const TWO_TO_63: f64 = 9_223_372_036_854_775_808.0;
const LARGEST_IN_RANGE_F64: f64 = 9_223_372_036_854_774_784.0;
fn run_range(args: &[Value]) -> Result<Value, NyblError> {
let mut rand_state = 0;
builtin_range_in(args, 7, &mut rand_state, &MemoryContext::__new(usize::MAX))
}
fn array_ints(value: &Value) -> Vec<i64> {
let Value::Array(items) = value else {
panic!("range did not return an array");
};
items
.iter()
.map(|item| match item {
Value::Int(value) => *value,
_ => panic!("range returned a non-integer item"),
})
.collect()
}
#[test]
fn finite_integer_conversion_respects_the_exact_i64_boundary() {
assert!(matches!(
finite_to_int_or_number(TWO_TO_63),
Value::Number(value) if value == TWO_TO_63
));
assert!(matches!(
finite_to_int_or_number(i64::MIN as f64),
Value::Int(i64::MIN)
));
assert!(matches!(
finite_to_int_or_number(LARGEST_IN_RANGE_F64),
Value::Int(value) if value == LARGEST_IN_RANGE_F64 as i64
));
}
#[test]
fn range_cardinality_handles_directions_and_i64_extremes() {
assert_eq!(range_cardinality(0, 10, 3), 4);
assert_eq!(range_cardinality(10, 0, -3), 4);
assert_eq!(range_cardinality(0, 10, -1), 0);
assert_eq!(range_cardinality(10, 0, 1), 0);
assert_eq!(range_cardinality(5, 5, 1), 0);
assert_eq!(range_cardinality(i64::MIN, i64::MAX, 1), u64::MAX as u128);
assert_eq!(range_cardinality(i64::MAX, i64::MIN, i64::MIN), 2);
}
#[test]
fn range_accepts_exactly_ten_thousand_values() {
let value = run_range(&[Value::Int(10_000)]).expect("range should fit");
let items = array_ints(&value);
assert_eq!(items.len(), RANGE_MAX_ITEMS);
assert_eq!(items.last(), Some(&9_999));
}
#[test]
fn range_emits_extreme_bounds_without_overflow_or_truncation() {
let value = run_range(&[
Value::Int(i64::MIN),
Value::Int(i64::MAX),
Value::Int(i64::MAX),
])
.expect("small extreme range should fit");
assert_eq!(array_ints(&value), [i64::MIN, -1, i64::MAX - 1]);
let value = run_range(&[
Value::Int(i64::MAX),
Value::Int(i64::MIN),
Value::Int(i64::MIN),
])
.expect("small reverse extreme range should fit");
assert_eq!(array_ints(&value), [i64::MAX, -1]);
}
#[test]
fn oversized_range_is_a_dedicated_fatal_limit_error() {
let err = run_range(&[Value::Int(10_001)]).expect_err("range should exceed limit");
assert!(err.is_fatal);
assert_eq!(err.line, Some(7));
assert_eq!(err.message, RANGE_LIMIT_ERROR_MESSAGE);
assert_eq!(err.friendly_hint.as_deref(), Some(RANGE_LIMIT_HINT));
}
#[test]
fn range_limit_uses_exact_cardinality_for_steps_and_direction() {
let forward = run_range(&[Value::Int(0), Value::Int(20_000), Value::Int(2)])
.expect("10,000 stepped values should fit");
assert_eq!(array_ints(&forward).len(), RANGE_MAX_ITEMS);
let reverse = run_range(&[Value::Int(20_000), Value::Int(0), Value::Int(-2)])
.expect("10,000 reverse values should fit");
assert_eq!(array_ints(&reverse).len(), RANGE_MAX_ITEMS);
for args in [
[Value::Int(0), Value::Int(20_001), Value::Int(2)],
[Value::Int(20_002), Value::Int(0), Value::Int(-2)],
] {
let err = run_range(&args).expect_err("10,001 values should exceed the limit");
assert!(err.is_fatal);
assert_eq!(err.message, RANGE_LIMIT_ERROR_MESSAGE);
}
}
#[test]
fn configured_memory_limit_still_applies_below_range_cap() {
let mut rand_state = 0;
let err = builtin_range_in(
&[Value::Int(10)],
7,
&mut rand_state,
&MemoryContext::__new(64),
)
.expect_err("range should exceed memory limit");
assert!(err.is_fatal);
assert_eq!(err.message, "Memory limit exceeded");
assert_eq!(
err.friendly_hint.as_deref(),
Some("This range would create too many values.")
);
}
}