use alloc::collections::BTreeMap;
use alloc::rc::Rc;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use core::cell::RefCell;
use crate::classes::enumerator;
use crate::classes::object_with;
use crate::dll::NativeType;
use crate::runtime::{
Detail, Object, Runtime, RuntimeError, RuntimeFailure, TypeName, Value, expected_type, put,
};
const STATE: &str = "buffer state";
const STATE_CLASS: &str = "buffer-state";
const PROPERTIES: [&str; 2] = ["size", "ptr"];
const METHODS: [&str; 10] = [
"__new",
"ownprops",
"hasownprop",
"defineprop",
"deleteprop",
"getownpropdesc",
"hasprop",
"hasmethod",
"getmethod",
"hasbase",
];
struct Buffer {
bytes: Vec<u8>,
}
pub(crate) fn names() -> Vec<&'static str> {
PROPERTIES.iter().chain(METHODS.iter()).copied().collect()
}
pub(crate) fn construct(
arguments: &[Value],
_rt: &mut Runtime,
line: u32,
) -> Result<Value, RuntimeFailure> {
let buffer = new(arguments, line)?;
Ok(object_with("buffer", vec![(STATE, stored(&buffer))]))
}
pub(crate) fn of_bytes(bytes: Vec<u8>) -> Value {
object_with("buffer", vec![(STATE, stored(&Buffer { bytes }))])
}
pub(crate) fn call(
method: &str,
this: &Value,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
let method = method.to_lowercase();
match method.as_str() {
"__new" => Some(new(arguments, line).map(|buffer| {
restore(this, &buffer);
Value::Int(buffer.bytes.len() as i64)
})),
_ => base_method(&method, this, arguments, rt, line),
}
}
pub(crate) fn property(
name: &str,
this: &Value,
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
match name.to_lowercase().as_str() {
"size" => Some(state(this, line).map(|buffer| Value::Int(buffer.bytes.len() as i64))),
"ptr" => Some(match ptr_of(this, line) {
Ok(address) => {
rt.remember_a_buffer_at(address, this.clone());
Ok(Value::Int(address))
}
Err(failure) => Err(failure),
}),
_ => None,
}
}
pub(crate) fn set_property(
name: &str,
this: &Value,
value: Value,
_rt: &mut Runtime,
line: u32,
) -> Option<Result<(), RuntimeFailure>> {
match name.to_lowercase().as_str() {
"size" => Some(resize(this, value, line)),
_ => None,
}
}
pub(crate) fn raw_bytes(value: &Value, line: u32) -> Result<Vec<u8>, RuntimeFailure> {
match value {
Value::Object(_) => Ok(state(value, line)?.bytes),
Value::Text(text) => Ok(text.as_bytes().to_vec()),
other => Err(fail(
expected_type(TypeName::Object, other.type_name()),
line,
)),
}
}
pub(crate) fn fill(value: &Value, bytes: &[u8], line: u32) -> Result<usize, RuntimeFailure> {
write_at(value, 0, bytes, line)?;
Ok(bytes.len())
}
pub(crate) fn size_of(value: &Value, line: u32) -> Result<i64, RuntimeFailure> {
Ok(state(value, line)?.bytes.len() as i64)
}
pub(crate) fn ptr_of(this: &Value, line: u32) -> Result<i64, RuntimeFailure> {
let Value::Object(object) = this else {
return Err(fail("this value is not a buffer.", line));
};
let inner = match object.borrow().value_of(STATE) {
Some(Value::Object(inner)) => inner.clone(),
_ => return Err(fail("this value is not a buffer.", line)),
};
Ok(alloc::rc::Rc::as_ptr(&inner) as usize as i64)
}
pub(crate) fn number_type(text: &str) -> Option<NativeType> {
match text.trim().to_ascii_lowercase().as_str() {
"uint" => Some(NativeType::UInt),
"int" => Some(NativeType::Int),
"int64" => Some(NativeType::Int64),
"short" => Some(NativeType::Short),
"ushort" => Some(NativeType::UShort),
"char" => Some(NativeType::Char),
"uchar" => Some(NativeType::UChar),
"double" => Some(NativeType::Double),
"float" => Some(NativeType::Float),
"ptr" => Some(NativeType::Ptr),
"uptr" => Some(NativeType::UPtr),
_ => None,
}
}
pub(crate) fn read_number(
value: &Value,
offset: i64,
kind: NativeType,
line: u32,
) -> Result<Value, RuntimeFailure> {
let buffer = state(value, line)?;
let start = start_of(offset, line)?;
let end = start.saturating_add(kind.width());
if end > buffer.bytes.len() {
return Err(fail("the bytes do not fit in the buffer.", line));
}
Ok(number_from_bytes(&buffer.bytes[start..end], kind))
}
pub(crate) fn write_numbers(
value: &Value,
offset: i64,
numbers: &[(NativeType, Value)],
line: u32,
) -> Result<i64, RuntimeFailure> {
let mut bytes = Vec::new();
for (kind, number) in numbers {
bytes.extend_from_slice(&number_bytes(number, *kind));
}
write_at(value, offset, &bytes, line)?;
Ok(ptr_of(value, line)? + offset + bytes.len() as i64)
}
fn fail(message: impl Into<String>, line: u32) -> RuntimeFailure {
RuntimeFailure::Error(RuntimeError {
message: message.into(),
line,
})
}
fn whole(value: &Value, line: u32) -> Result<i64, RuntimeFailure> {
match value {
Value::Int(number) => Ok(*number),
Value::Float(number) => Ok(*number as i64),
other => Err(RuntimeFailure::Detailed(
RuntimeError {
message: expected_type(TypeName::Number, other.type_name()),
line,
},
Detail {
what: String::new(),
extra: other.to_text(),
},
)),
}
}
fn whole_argument(value: &Value, index: usize, line: u32) -> Result<i64, RuntimeFailure> {
match value {
Value::Int(number) => Ok(*number),
Value::Float(number) => Ok(*number as i64),
other => Err(RuntimeFailure::Detailed(
RuntimeError {
message: crate::runtime::requires(
index + 1,
"Buffer.Prototype.__New",
TypeName::Number,
other,
),
line,
},
Detail {
what: "Buffer.Prototype.__New".to_string(),
extra: other.to_text(),
},
)),
}
}
fn state(this: &Value, line: u32) -> Result<Buffer, RuntimeFailure> {
let Value::Object(object) = this else {
return Err(fail("this value is not a buffer.", line));
};
let inner = match object.borrow().value_of(STATE) {
Some(Value::Object(inner)) => inner.clone(),
_ => return Err(fail("this value is not a buffer.", line)),
};
let inner = inner.borrow();
let bytes = match inner.value_of("bytes") {
Some(Value::List(items)) => items
.iter()
.map(|item| item.to_number().unwrap_or(0.0) as u8)
.collect(),
_ => Vec::new(),
};
Ok(Buffer { bytes })
}
fn stored(buffer: &Buffer) -> Value {
let bytes = Value::List(
buffer
.bytes
.iter()
.map(|byte| Value::Int(*byte as i64))
.collect(),
);
object_with(STATE_CLASS, vec![("bytes", bytes)])
}
fn restore(this: &Value, buffer: &Buffer) {
let Value::Object(object) = this else { return };
put(&mut object.borrow_mut().properties, STATE, stored(buffer));
}
fn new(arguments: &[Value], line: u32) -> Result<Buffer, RuntimeFailure> {
let size = match arguments.first() {
Some(value) => whole_argument(value, 0, line)?,
None => 0,
};
if size < 0 {
return Err(fail("Invalid value.", line));
}
let fill = match arguments.get(1) {
Some(value) => whole_argument(value, 1, line)? as u8,
None => 0,
};
Ok(Buffer {
bytes: vec![fill; size as usize],
})
}
fn resize(this: &Value, value: Value, line: u32) -> Result<(), RuntimeFailure> {
let size = whole(&value, line)?;
if size < 0 {
return Err(fail("the size of a buffer cannot be negative.", line));
}
let mut buffer = state(this, line)?;
buffer.bytes.resize(size as usize, 0);
restore(this, &buffer);
Ok(())
}
fn write_at(value: &Value, offset: i64, bytes: &[u8], line: u32) -> Result<(), RuntimeFailure> {
let mut buffer = state(value, line)?;
let start = start_of(offset, line)?;
let end = start.saturating_add(bytes.len());
if end > buffer.bytes.len() {
return Err(fail("the bytes do not fit in the buffer.", line));
}
buffer.bytes[start..end].copy_from_slice(bytes);
restore(value, &buffer);
Ok(())
}
fn start_of(offset: i64, line: u32) -> Result<usize, RuntimeFailure> {
if offset < 0 {
return Err(fail("the offset of a number cannot be negative.", line));
}
match usize::try_from(offset) {
Ok(start) => Ok(start),
Err(_) => Err(fail("the bytes do not fit in the buffer.", line)),
}
}
fn number_bytes(number: &Value, kind: NativeType) -> Vec<u8> {
let mut bytes = Vec::with_capacity(kind.width());
match kind {
NativeType::Float => {
bytes.extend_from_slice(&(number.to_number().unwrap_or(0.0) as f32).to_le_bytes())
}
NativeType::Double => {
bytes.extend_from_slice(&number.to_number().unwrap_or(0.0).to_le_bytes())
}
_ => {
let whole = match number {
Value::Int(number) => *number,
other => other.to_number().unwrap_or(0.0) as i64,
};
match kind.width() {
1 => bytes.push(whole as u8),
2 => bytes.extend_from_slice(&(whole as u16).to_le_bytes()),
4 => bytes.extend_from_slice(&(whole as u32).to_le_bytes()),
_ => bytes.extend_from_slice(&whole.to_le_bytes()),
}
}
}
bytes
}
fn number_from_bytes(bytes: &[u8], kind: NativeType) -> Value {
match kind {
NativeType::Float => {
Value::Float(f32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as f64)
}
NativeType::Double => {
let mut whole = [0u8; 8];
whole.copy_from_slice(&bytes[..8]);
Value::Float(f64::from_le_bytes(whole))
}
_ => {
let mut whole = 0i64;
for byte in bytes.iter().take(kind.width()).rev() {
whole = (whole << 8) | *byte as i64;
}
let bits = kind.width() * 8;
if bits < 64 && !kind.is_unsigned() {
let sign = 1i64 << (bits - 1);
if whole & sign != 0 {
whole -= sign << 1;
}
}
Value::Int(whole)
}
}
}
fn base_method(
method: &str,
this: &Value,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
let Value::Object(object) = this else {
return None;
};
let failure = |message: &str| {
Some(Err(RuntimeFailure::Error(RuntimeError {
message: message.to_string(),
line,
})))
};
let name = arguments
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let key = name.to_lowercase();
match method {
"ownprops" => {
let pairs: Vec<(Value, Value)> = object
.borrow()
.properties
.iter()
.filter(|(name, _)| name.as_str() != STATE)
.map(|(_, property)| (Value::Text(property.name.clone()), property.value.clone()))
.collect();
Some(Ok(enumerator::make(pairs, enumerator::Alone::TheKey)))
}
"hasownprop" => Some(Ok(Value::Int(own_property(object, &key) as i64))),
"hasprop" => Some(Ok(Value::Int(
(PROPERTIES.contains(&key.as_str())
|| METHODS.contains(&key.as_str())
|| own_property(object, &key)
|| key == "__class"
|| key == "__init"
|| key == "base") as i64,
))),
"hasmethod" => Some(Ok(Value::Int(
(METHODS.contains(&key.as_str())
|| key == "__init") as i64,
))),
"getownpropdesc" => {
let name = arguments
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let value = object.borrow().value_of(&key);
match value {
Some(value) => {
let table = match rt.the_members_of_a_descriptor(&value) {
Some(members) => members,
None => {
let mut table = BTreeMap::new();
put(&mut table, "value", value);
table
}
};
Some(Ok(Value::Object(Rc::new(RefCell::new(Object {
class: "object".to_string(),
properties: table,
})))))
}
None => Some(Err(rt.no_property(this, &name, line))),
}
}
"defineprop" => {
if key == STATE {
return failure("the state of a buffer is not a property of it.");
}
let descriptor = match rt.the_descriptor(arguments.get(1), line) {
Ok(descriptor) => descriptor,
Err(failure) => return Some(Err(failure)),
};
put(&mut object.borrow_mut().properties, &name, descriptor);
Some(Ok(this.clone()))
}
"deleteprop" => {
if key == STATE {
return Some(Ok(Value::Text(String::new())));
}
let gone = object
.borrow_mut()
.properties
.remove(&key)
.map(|property| property.value);
Some(Ok(match gone {
None => Value::Text(String::new()),
Some(value) => match rt.the_value_of_the_descriptor(&value, this, &name, line) {
Ok(Some(value)) => value,
_ => value,
},
}))
}
_ => None,
}
}
fn own_property(object: &Rc<RefCell<Object>>, key: &str) -> bool {
key != STATE && object.borrow().properties.contains_key(key)
}