use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::dll::NativeType;
use crate::runtime::{Runtime, RuntimeError, RuntimeFailure, Value};
fn the_target_address(
rt: &mut Runtime<'_>,
target: &Value,
line: u32,
) -> Result<i64, RuntimeError> {
match target {
Value::Reference(reference) => {
if crate::v1::is_the_name_of_a_variable(&reference.name) {
Ok(rt.the_variable_address(reference))
} else {
let value = rt
.the_value_of_the_expression_text(&reference.name, line)
.map_err(|failure| match failure {
RuntimeFailure::Error(error) => error,
RuntimeFailure::Detailed(error, _) => error,
_ => RuntimeError {
message: "the target of the memory is not an address.".to_string(),
line,
},
})?;
Ok(value.to_number().unwrap_or(0.0) as i64)
}
}
Value::Int(number) => Ok(*number),
Value::Float(number) => Ok(*number as i64),
Value::Text(text) => Ok(text.trim().parse::<i64>().unwrap_or(0)),
_ => Err(RuntimeError {
message: "the target of a NumPut/NumGet is a variable or an address.".to_string(),
line,
}),
}
}
fn the_offset_and_type(values: &[Value], start: usize) -> (i64, NativeType) {
let mut offset = 0i64;
let mut kind = NativeType::UPtr;
if let Some(value) = values.get(start) {
let text = value.to_text();
if let Some(named) = crate::classes::buffer::number_type(&text) {
kind = named;
} else {
offset = value.to_number().unwrap_or(0.0) as i64;
if let Some(named) = values
.get(start + 1)
.and_then(|value| crate::classes::buffer::number_type(&value.to_text()))
{
kind = named;
}
}
}
(offset, kind)
}
pub(crate) fn num_put(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = values.first().cloned().unwrap_or(Value::Int(0));
let number = match &number {
Value::Text(text) => crate::v1::numbers::the_number_of_a_text(text)
.unwrap_or_else(|| number.clone()),
_ => number,
};
let Some(target) = values.get(1) else {
return Err(RuntimeError {
message: "NumPut requires a target.".to_string(),
line,
});
};
let address = the_target_address(rt, target, line)?;
let (offset, kind) = the_offset_and_type(values, 2);
let bytes = crate::classes::buffer::number_bytes(&number, kind);
let at = address.saturating_add(offset);
if at == 0 {
return Err(RuntimeError {
message: "NumPut: the address is null.".to_string(),
line,
});
}
let in_the_script = rt.the_bytes_are_written_at_an_address(at, &bytes);
if in_the_script.is_none()
&& !rt.the_bytes_are_written_at_a_text(at, &bytes)
&& !rt.desktop().the_memory_is_written(at as u64, &bytes)
{
return Err(RuntimeError {
message: "NumPut: the address cannot be written.".to_string(),
line,
});
}
Ok(Value::Int(at + bytes.len() as i64))
}
pub(crate) fn num_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(target) = values.first() else {
return Err(RuntimeError {
message: "NumGet requires a target.".to_string(),
line,
});
};
let address = the_target_address(rt, target, line)?;
let (offset, kind) = the_offset_and_type(values, 1);
let at = address.saturating_add(offset);
if at == 0 {
return Err(RuntimeError {
message: "NumGet: the address is null.".to_string(),
line,
});
}
let width = kind.width();
let mut bytes = match rt.the_bytes_at_an_address(at) {
Some(bytes) => bytes,
None => match rt.desktop().read_memory(at, width as i64) {
Ok(bytes) => bytes,
Err(_) => return Ok(Value::Text(String::new())),
},
};
if bytes.len() < width {
bytes.resize(width, 0);
}
Ok(crate::classes::buffer::number_from_bytes(&bytes, kind))
}
pub(crate) fn var_set_capacity(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(Value::Reference(reference)) = values.first() else {
return Ok(Value::Int(0));
};
let Some(capacity_value) = values.get(1) else {
return Ok(Value::Int(rt.string_capacity(reference)));
};
let capacity = capacity_value.to_number().unwrap_or(0.0) as i64;
let fill = values
.get(2)
.map(|value| value.to_number().unwrap_or(0.0) as u8)
.unwrap_or(0);
if capacity < 0 {
rt.the_capacity_buffer(reference, -1, 0);
return Ok(Value::Int(0));
}
rt.the_capacity_buffer(reference, capacity, fill);
rt.write_reference(values.first().expect("the reference"), Value::Text(String::new()));
let _ = line;
Ok(Value::Int(capacity))
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum TheEncoding {
Utf8,
Utf16,
Cp0,
}
fn the_encoding_of(name: Option<&Value>) -> Option<TheEncoding> {
match name {
None => Some(TheEncoding::Utf16),
Some(Value::Text(text)) => {
let name = text.trim();
if name.is_empty() {
return Some(TheEncoding::Cp0);
}
match name.to_ascii_lowercase().as_str() {
"utf-8" => Some(TheEncoding::Utf8),
"utf-16" => Some(TheEncoding::Utf16),
other if other.starts_with("cp") => Some(TheEncoding::Cp0),
_ => None,
}
}
Some(_) => None,
}
}
fn the_bytes_of(text: &str, encoding: TheEncoding) -> (Vec<u8>, usize) {
match encoding {
TheEncoding::Utf8 | TheEncoding::Cp0 => {
let bytes = text.as_bytes().to_vec();
let units = bytes.len();
(bytes, units)
}
TheEncoding::Utf16 => {
let mut bytes = Vec::with_capacity(text.len() * 2);
let mut units = 0;
for unit in text.encode_utf16() {
bytes.extend_from_slice(&unit.to_le_bytes());
units += 1;
}
(bytes, units)
}
}
}
fn the_terminator_of(encoding: TheEncoding) -> Vec<u8> {
match encoding {
TheEncoding::Utf8 | TheEncoding::Cp0 => alloc::vec![0],
TheEncoding::Utf16 => alloc::vec![0, 0],
}
}
fn the_text_of(bytes: &[u8], encoding: TheEncoding, length: Option<usize>) -> String {
match encoding {
TheEncoding::Utf8 | TheEncoding::Cp0 => {
let end = bytes.iter().position(|byte| *byte == 0).unwrap_or(bytes.len());
let end = length.map(|length| end.min(length)).unwrap_or(end);
String::from_utf8_lossy(&bytes[..end]).into_owned()
}
TheEncoding::Utf16 => {
if length == Some(0) {
return String::new();
}
let mut units: Vec<u16> = Vec::new();
let mut at = 0;
while at + 1 < bytes.len() {
let unit = u16::from_le_bytes([bytes[at], bytes[at + 1]]);
if unit == 0 {
break;
}
units.push(unit);
at += 2;
if let Some(length) = length {
if units.len() >= length {
break;
}
}
}
String::from_utf16_lossy(&units)
}
}
}
fn the_address_of(rt: &mut Runtime<'_>, value: &Value) -> Option<i64> {
match value {
Value::Int(number) => Some(*number),
Value::Float(number) => Some(*number as i64),
Value::Reference(reference) => Some(rt.the_variable_address(reference)),
_ => None,
}
}
pub(crate) fn str_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(source) = values.first() else {
return Ok(Value::Text(String::new()));
};
let Some(address) = the_address_of(rt, source) else {
return Ok(Value::Text(String::new()));
};
let (length, encoding_name) = match values.get(1) {
Some(value) if value.to_number().is_some() => (
Some(value.to_number().unwrap_or(0.0).max(0.0) as usize),
values.get(2),
),
Some(value) => (None, Some(value)),
None => (None, None),
};
let Some(encoding) = the_encoding_of(encoding_name) else {
return Ok(Value::Text(String::new()));
};
let bytes = match rt.the_bytes_at_an_address(address) {
Some(bytes) => bytes,
None => {
let wanted = match length {
Some(length) => length * the_size_of_the_unit(encoding),
None => THE_LIMIT_OF_A_READ,
};
match rt.desktop().the_bytes_of_the_memory(address as u64, wanted) {
Some(bytes) => bytes,
None => return Ok(Value::Text(String::new())),
}
}
};
let _ = line;
Ok(Value::Text(the_text_of(&bytes, encoding, length)))
}
pub(crate) fn str_put(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let text = match values.first() {
Some(Value::Text(text)) => text.clone(),
Some(value @ (Value::Object(_) | Value::List(_))) => {
let _ = value;
return Ok(Value::Text(String::new()));
}
Some(value) => value.to_text(),
None => return Ok(Value::Text(String::new())),
};
let Some(target) = values.get(1) else {
let (_, units) = the_bytes_of(&text, TheEncoding::Utf16);
return Ok(Value::Int((units + 1) as i64));
};
if let Value::Text(name) = target {
let Some(encoding) = the_encoding_of(Some(&Value::Text(name.clone()))) else {
return Ok(Value::Text(String::new()));
};
let (_, units) = the_bytes_of(&text, encoding);
return Ok(Value::Int((units + 1) as i64));
}
let Some(address) = the_address_of(rt, target) else {
return Ok(Value::Text(String::new()));
};
let (length, encoding) = match values.get(2) {
Some(value) if value.to_number().is_some() => (
Some(value.to_number().unwrap_or(0.0) as i64),
match values.get(3) {
Some(value) if value.to_number().is_some() => Some(TheEncoding::Cp0),
Some(value) => the_encoding_of(Some(value)),
None => Some(TheEncoding::Utf16),
},
),
Some(value) => (None, the_encoding_of(Some(value))),
None => (None, Some(TheEncoding::Utf16)),
};
let Some(encoding) = encoding else {
return Ok(Value::Text(String::new()));
};
let (bytes, units) = the_bytes_of(&text, encoding);
let terminator = the_terminator_of(encoding);
let (bytes, units) = match length {
None => {
let mut all = bytes;
all.extend_from_slice(&terminator);
(all, units + 1)
}
Some(length) => {
if length == 0 {
return Ok(Value::Text(String::new()));
}
if length < units as i64 {
return Ok(Value::Int(0));
}
if length == units as i64 {
(bytes, units)
} else {
let mut all = bytes;
all.extend_from_slice(&terminator);
(all, units + 1)
}
}
};
let variable = rt.the_bytes_are_written_at_an_address(address, &bytes);
if variable.is_none() && !rt.the_bytes_are_written_at_a_text(address, &bytes) {
rt.desktop().the_memory_is_written(address as u64, &bytes);
}
if let Some(reference) = variable {
let text = the_text_of(&bytes, encoding, None);
rt.write_reference(&Value::Reference(reference), Value::Text(text));
}
let _ = line;
Ok(Value::Int(units as i64))
}
fn the_size_of_the_unit(encoding: TheEncoding) -> usize {
match encoding {
TheEncoding::Utf16 => 2,
TheEncoding::Utf8 | TheEncoding::Cp0 => 1,
}
}
const THE_LIMIT_OF_A_READ: usize = 64 * 1024;