405 lines
12 KiB
Rust
405 lines
12 KiB
Rust
//! Built-in functions that implement extended functionality.
|
|
//!
|
|
//! Native functions are used either to implement features that are not possible to implement in
|
|
//! Dust itself or that are more efficient to implement in Rust.
|
|
use std::{
|
|
fmt::{self, Display, Formatter},
|
|
io::{self, stdin, stdout, Write},
|
|
string::{self},
|
|
};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::{AnnotatedError, FunctionType, Instruction, Primitive, Span, Type, Value, Vm, VmError};
|
|
|
|
macro_rules! impl_from_str_for_native_function {
|
|
($(($name:ident, $byte:literal, $str:expr, $type:expr)),*) => {
|
|
/// A dust-native function.
|
|
///
|
|
/// See the [module-level documentation](index.html) for more information.
|
|
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
|
|
pub enum NativeFunction {
|
|
$(
|
|
$name = $byte as isize,
|
|
)*
|
|
}
|
|
|
|
impl NativeFunction {
|
|
pub fn as_str(&self) -> &'static str {
|
|
match self {
|
|
$(
|
|
NativeFunction::$name => $str,
|
|
)*
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::should_implement_trait)]
|
|
pub fn from_str(string: &str) -> Option<Self> {
|
|
match string {
|
|
$(
|
|
$str => Some(NativeFunction::$name),
|
|
)*
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn r#type(&self) -> FunctionType {
|
|
match self {
|
|
$(
|
|
NativeFunction::$name => $type,
|
|
)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<u8> for NativeFunction {
|
|
fn from(byte: u8) -> Self {
|
|
match byte {
|
|
$(
|
|
$byte => NativeFunction::$name,
|
|
)*
|
|
_ => {
|
|
if cfg!(test) {
|
|
panic!("Invalid native function byte: {}", byte)
|
|
} else {
|
|
NativeFunction::Panic
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<NativeFunction> for u8 {
|
|
fn from(native_function: NativeFunction) -> Self {
|
|
match native_function {
|
|
$(
|
|
NativeFunction::$name => $byte,
|
|
)*
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl_from_str_for_native_function! {
|
|
// Assertion
|
|
(
|
|
Assert,
|
|
0_u8,
|
|
"assert",
|
|
FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: None,
|
|
return_type: None
|
|
}
|
|
),
|
|
// (AssertEqual, 1_u8, "assert_equal", false),
|
|
// (AssertNotEqual, 2_u8, "assert_not_equal", false),
|
|
(
|
|
Panic,
|
|
3_u8,
|
|
"panic",
|
|
FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: None,
|
|
return_type: Some(Box::new(Type::Any))
|
|
}
|
|
),
|
|
|
|
// // Type conversion
|
|
// (Parse, 4_u8, "parse", true),
|
|
// (ToByte, 5_u8, "to_byte", true),
|
|
// (ToFloat, 6_u8, "to_float", true),
|
|
// (ToInteger, 7_u8, "to_integer", true),
|
|
(
|
|
ToString,
|
|
8_u8,
|
|
"to_string",
|
|
FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: Some(vec![(0, Type::Any)]),
|
|
return_type: Some(Box::new(Type::String { length: None }))
|
|
}
|
|
),
|
|
|
|
// // List and string
|
|
// (All, 9_u8, "all", true),
|
|
// (Any, 10_u8, "any", true),
|
|
// (Append, 11_u8, "append", false),
|
|
// (Contains, 12_u8, "contains", true),
|
|
// (Dedup, 13_u8, "dedup", false),
|
|
// (EndsWith, 14_u8, "ends_with", true),
|
|
// (Find, 15_u8, "find", true),
|
|
// (Get, 16_u8, "get", true),
|
|
// (IndexOf, 17_u8, "index_of", true),
|
|
// (Length, 18_u8, "length", true),
|
|
// (Prepend, 19_u8, "prepend", false),
|
|
// (Replace, 20_u8, "replace", false),
|
|
// (Set, 21_u8, "set", false),
|
|
// (StartsWith, 22_u8, "starts_with", true),
|
|
// (Slice, 23_u8, "slice", true),
|
|
// (Sort, 24_u8, "sort", false),
|
|
// (Split, 25_u8, "split", true),
|
|
|
|
// // List
|
|
// (Flatten, 26_u8, "flatten", false),
|
|
// (Join, 27_u8, "join", true),
|
|
// (Map, 28_u8, "map", true),
|
|
// (Reduce, 29_u8, "reduce", true),
|
|
// (Remove, 30_u8, "remove", false),
|
|
// (Reverse, 31_u8, "reverse", false),
|
|
// (Unzip, 32_u8, "unzip", true),
|
|
// (Zip, 33_u8, "zip", true),
|
|
|
|
// // String
|
|
// (Bytes, 34_u8, "bytes", true),
|
|
// (CharAt, 35_u8, "char_at", true),
|
|
// (CharCodeAt, 36_u8, "char_code_at", true),
|
|
// (Chars, 37_u8, "chars", true),
|
|
// (Format, 38_u8, "format", true),
|
|
// (Repeat, 39_u8, "repeat", true),
|
|
// (SplitAt, 40_u8, "split_at", true),
|
|
// (SplitLines, 41_u8, "split_lines", true),
|
|
// (SplitWhitespace, 42_u8, "split_whitespace", true),
|
|
// (ToLowerCase, 43_u8, "to_lower_case", true),
|
|
// (ToUpperCase, 44_u8, "to_upper_case", true),
|
|
// (Trim, 45_u8, "trim", true),
|
|
// (TrimEnd, 46_u8, "trim_end", true),
|
|
// (TrimStart, 47_u8, "trim_start", true),
|
|
|
|
// // I/O
|
|
// // Read
|
|
// (Read, 48_u8, "read", true),
|
|
// (ReadFile, 49_u8, "read_file", true),
|
|
(
|
|
ReadLine,
|
|
50_u8,
|
|
"read_line",
|
|
FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: None,
|
|
return_type: Some(Box::new(Type::String { length: None }))
|
|
}
|
|
),
|
|
// (ReadTo, 51_u8, "read_to", false),
|
|
// (ReadUntil, 52_u8, "read_until", true),
|
|
// // Write
|
|
// (AppendFile, 53_u8, "append_file", false),
|
|
// (PrependFile, 54_u8, "prepend_file", false),
|
|
(
|
|
Write,
|
|
55_u8,
|
|
"write",
|
|
FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: Some(vec![(0, Type::String { length: None })]),
|
|
return_type: None
|
|
}
|
|
),
|
|
// (WriteFile, 56_u8, "write_file", false),
|
|
(
|
|
WriteLine,
|
|
57_u8,
|
|
"write_line",
|
|
FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: Some(vec![(0, Type::String { length: None })]),
|
|
return_type: None
|
|
}
|
|
)
|
|
|
|
// // Random
|
|
// (Random, 58_u8, "random", true),
|
|
// (RandomInRange, 59_u8, "random_in_range", true)
|
|
}
|
|
|
|
impl NativeFunction {
|
|
pub fn call(
|
|
&self,
|
|
instruction: Instruction,
|
|
vm: &Vm,
|
|
position: Span,
|
|
) -> Result<Option<Value>, VmError> {
|
|
let to_register = instruction.a();
|
|
let argument_count = instruction.c();
|
|
|
|
let return_value = match self {
|
|
NativeFunction::Panic => {
|
|
let message = if argument_count == 0 {
|
|
None
|
|
} else {
|
|
let mut message = String::new();
|
|
|
|
for argument_index in 0..argument_count {
|
|
if argument_index != 0 {
|
|
message.push(' ');
|
|
}
|
|
|
|
let argument = vm.get_register(argument_index, position)?;
|
|
|
|
message.push_str(&argument.to_string());
|
|
}
|
|
|
|
Some(message)
|
|
};
|
|
|
|
return Err(VmError::NativeFunction(NativeFunctionError::Panic {
|
|
message,
|
|
position,
|
|
}));
|
|
}
|
|
|
|
// Type conversion
|
|
NativeFunction::ToString => {
|
|
let mut string = String::new();
|
|
|
|
for argument_index in 0..argument_count {
|
|
let argument = vm.get_register(argument_index, position)?;
|
|
|
|
string.push_str(&argument.to_string());
|
|
}
|
|
|
|
Some(Value::Primitive(Primitive::String(string)))
|
|
}
|
|
|
|
// I/O
|
|
NativeFunction::ReadLine => {
|
|
let mut buffer = String::new();
|
|
|
|
stdin().read_line(&mut buffer).map_err(|io_error| {
|
|
VmError::NativeFunction(NativeFunctionError::Io {
|
|
error: io_error.kind(),
|
|
position,
|
|
})
|
|
})?;
|
|
|
|
buffer = buffer.trim_end_matches('\n').to_string();
|
|
|
|
Some(Value::Primitive(Primitive::String(buffer)))
|
|
}
|
|
NativeFunction::Write => {
|
|
let to_register = instruction.a();
|
|
let mut stdout = stdout();
|
|
let map_err = |io_error: io::Error| {
|
|
VmError::NativeFunction(NativeFunctionError::Io {
|
|
error: io_error.kind(),
|
|
position,
|
|
})
|
|
};
|
|
|
|
let first_argument = to_register.saturating_sub(argument_count);
|
|
let last_argument = to_register.saturating_sub(1);
|
|
|
|
for argument_index in first_argument..=last_argument {
|
|
if argument_index != first_argument {
|
|
stdout.write(b" ").map_err(map_err)?;
|
|
}
|
|
|
|
let argument_string = vm.get_register(argument_index, position)?.to_string();
|
|
|
|
stdout
|
|
.write_all(argument_string.as_bytes())
|
|
.map_err(map_err)?;
|
|
}
|
|
|
|
None
|
|
}
|
|
NativeFunction::WriteLine => {
|
|
let mut stdout = stdout();
|
|
let map_err = |io_error: io::Error| {
|
|
VmError::NativeFunction(NativeFunctionError::Io {
|
|
error: io_error.kind(),
|
|
position,
|
|
})
|
|
};
|
|
|
|
let first_argument = to_register.saturating_sub(argument_count);
|
|
let last_argument = to_register.saturating_sub(1);
|
|
|
|
for argument_index in first_argument..=last_argument {
|
|
if argument_index != 0 {
|
|
stdout.write(b" ").map_err(map_err)?;
|
|
}
|
|
|
|
let argument_string = vm.get_register(argument_index, position)?.to_string();
|
|
|
|
stdout
|
|
.write_all(argument_string.as_bytes())
|
|
.map_err(map_err)?;
|
|
}
|
|
|
|
stdout.write(b"\n").map_err(map_err)?;
|
|
|
|
None
|
|
}
|
|
_ => todo!(),
|
|
};
|
|
|
|
Ok(return_value)
|
|
}
|
|
}
|
|
|
|
impl Display for NativeFunction {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
write!(f, "{}", self.as_str())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub enum NativeFunctionError {
|
|
ExpectedArgumentCount {
|
|
expected: usize,
|
|
found: usize,
|
|
position: Span,
|
|
},
|
|
Panic {
|
|
message: Option<String>,
|
|
position: Span,
|
|
},
|
|
Parse {
|
|
error: string::ParseError,
|
|
position: Span,
|
|
},
|
|
Io {
|
|
error: io::ErrorKind,
|
|
position: Span,
|
|
},
|
|
}
|
|
|
|
impl AnnotatedError for NativeFunctionError {
|
|
fn title() -> &'static str {
|
|
"Native Function Error"
|
|
}
|
|
|
|
fn description(&self) -> &'static str {
|
|
match self {
|
|
NativeFunctionError::ExpectedArgumentCount { .. } => {
|
|
"Expected a different number of arguments"
|
|
}
|
|
NativeFunctionError::Panic { .. } => "Explicit panic",
|
|
NativeFunctionError::Parse { .. } => "Failed to parse value",
|
|
NativeFunctionError::Io { .. } => "I/O error",
|
|
}
|
|
}
|
|
|
|
fn details(&self) -> Option<String> {
|
|
match self {
|
|
NativeFunctionError::ExpectedArgumentCount {
|
|
expected, found, ..
|
|
} => Some(format!("Expected {} arguments, found {}", expected, found)),
|
|
NativeFunctionError::Panic { message, .. } => message.clone(),
|
|
NativeFunctionError::Parse { error, .. } => Some(format!("{}", error)),
|
|
NativeFunctionError::Io { error, .. } => Some(format!("{}", error)),
|
|
}
|
|
}
|
|
|
|
fn position(&self) -> Span {
|
|
match self {
|
|
NativeFunctionError::ExpectedArgumentCount { position, .. } => *position,
|
|
NativeFunctionError::Panic { position, .. } => *position,
|
|
NativeFunctionError::Parse { position, .. } => *position,
|
|
NativeFunctionError::Io { position, .. } => *position,
|
|
}
|
|
}
|
|
}
|