Add native calls and the panic native
This commit is contained in:
parent
caf1c22af0
commit
af4e43fc9f
@ -1,7 +0,0 @@
|
|||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
|
|
||||||
pub enum BuiltInFunction {
|
|
||||||
String,
|
|
||||||
WriteLine,
|
|
||||||
}
|
|
@ -1,6 +1,6 @@
|
|||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
use crate::{Chunk, Operation};
|
use crate::{Chunk, NativeFunction, Operation};
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
||||||
pub struct Instruction(u32);
|
pub struct Instruction(u32);
|
||||||
@ -229,6 +229,21 @@ impl Instruction {
|
|||||||
instruction
|
instruction
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn call_native(
|
||||||
|
to_register: u8,
|
||||||
|
native_fn: NativeFunction,
|
||||||
|
argument_count: u8,
|
||||||
|
) -> Instruction {
|
||||||
|
let mut instruction = Instruction(Operation::CallNative as u32);
|
||||||
|
let native_fn_byte = native_fn as u8;
|
||||||
|
|
||||||
|
instruction.set_a(to_register);
|
||||||
|
instruction.set_b(native_fn_byte);
|
||||||
|
instruction.set_c(argument_count);
|
||||||
|
|
||||||
|
instruction
|
||||||
|
}
|
||||||
|
|
||||||
pub fn r#return(should_return_value: bool) -> Instruction {
|
pub fn r#return(should_return_value: bool) -> Instruction {
|
||||||
let mut instruction = Instruction(Operation::Return as u32);
|
let mut instruction = Instruction(Operation::Return as u32);
|
||||||
|
|
||||||
@ -335,6 +350,7 @@ impl Instruction {
|
|||||||
self.operation(),
|
self.operation(),
|
||||||
Operation::Add
|
Operation::Add
|
||||||
| Operation::Call
|
| Operation::Call
|
||||||
|
| Operation::CallNative
|
||||||
| Operation::Divide
|
| Operation::Divide
|
||||||
| Operation::GetLocal
|
| Operation::GetLocal
|
||||||
| Operation::LoadBoolean
|
| Operation::LoadBoolean
|
||||||
@ -542,16 +558,47 @@ impl Instruction {
|
|||||||
let argument_count = self.c();
|
let argument_count = self.c();
|
||||||
|
|
||||||
let mut output = format!("R{to_register} = R{function_register}(");
|
let mut output = format!("R{to_register} = R{function_register}(");
|
||||||
let first_argument = function_register + 1;
|
|
||||||
|
|
||||||
for (index, register) in
|
if argument_count != 0 {
|
||||||
(first_argument..first_argument + argument_count).enumerate()
|
let first_argument = function_register + 1;
|
||||||
{
|
|
||||||
if index > 0 {
|
for (index, register) in
|
||||||
output.push_str(", ");
|
(first_argument..first_argument + argument_count).enumerate()
|
||||||
|
{
|
||||||
|
if index > 0 {
|
||||||
|
output.push_str(", ");
|
||||||
|
}
|
||||||
|
|
||||||
|
output.push_str(&format!("R{}", register));
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
output.push_str(&format!("R{}", register));
|
output.push(')');
|
||||||
|
|
||||||
|
output
|
||||||
|
}
|
||||||
|
Operation::CallNative => {
|
||||||
|
let to_register = self.a();
|
||||||
|
let native_function = NativeFunction::from(self.b());
|
||||||
|
let argument_count = self.c();
|
||||||
|
let native_function_name = match native_function {
|
||||||
|
NativeFunction::Panic => "PANIC",
|
||||||
|
NativeFunction::ToString => "TO_STRING",
|
||||||
|
NativeFunction::WriteLine => "WRITE_LINE",
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut output = format!("R{to_register} = {native_function_name}(");
|
||||||
|
|
||||||
|
if argument_count != 0 {
|
||||||
|
let first_argument = to_register.saturating_sub(argument_count);
|
||||||
|
|
||||||
|
for (index, register) in (first_argument..to_register).enumerate() {
|
||||||
|
if index > 0 {
|
||||||
|
output.push_str(", ");
|
||||||
|
}
|
||||||
|
|
||||||
|
output.push_str(&format!("R{}", register));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
output.push(')');
|
output.push(')');
|
||||||
|
@ -152,14 +152,16 @@ impl<'src> Lexer<'src> {
|
|||||||
if let Some(c) = self.peek_char() {
|
if let Some(c) = self.peek_char() {
|
||||||
self.position += 1;
|
self.position += 1;
|
||||||
|
|
||||||
if let Some('\'') = self.peek_char() {
|
let peek = self.peek_char();
|
||||||
|
|
||||||
|
if let Some('\'') = peek {
|
||||||
self.position += 1;
|
self.position += 1;
|
||||||
|
|
||||||
(Token::Character(c), Span(self.position - 3, self.position))
|
(Token::Character(c), Span(self.position - 3, self.position))
|
||||||
} else {
|
} else {
|
||||||
return Err(LexError::ExpectedCharacter {
|
return Err(LexError::ExpectedCharacter {
|
||||||
expected: '\'',
|
expected: '\'',
|
||||||
actual: c,
|
actual: peek.unwrap_or('\0'),
|
||||||
position: self.position,
|
position: self.position,
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
@ -561,6 +563,7 @@ impl<'src> Lexer<'src> {
|
|||||||
"loop" => Token::Loop,
|
"loop" => Token::Loop,
|
||||||
"map" => Token::Map,
|
"map" => Token::Map,
|
||||||
"mut" => Token::Mut,
|
"mut" => Token::Mut,
|
||||||
|
"panic" => Token::Panic,
|
||||||
"return" => Token::Return,
|
"return" => Token::Return,
|
||||||
"str" => Token::Str,
|
"str" => Token::Str,
|
||||||
"struct" => Token::Struct,
|
"struct" => Token::Struct,
|
||||||
|
@ -4,6 +4,7 @@ mod formatter;
|
|||||||
mod identifier;
|
mod identifier;
|
||||||
mod instruction;
|
mod instruction;
|
||||||
mod lexer;
|
mod lexer;
|
||||||
|
mod native_function;
|
||||||
mod operation;
|
mod operation;
|
||||||
mod parser;
|
mod parser;
|
||||||
mod token;
|
mod token;
|
||||||
@ -11,14 +12,13 @@ mod r#type;
|
|||||||
mod value;
|
mod value;
|
||||||
mod vm;
|
mod vm;
|
||||||
|
|
||||||
use std::fmt::Display;
|
|
||||||
|
|
||||||
pub use chunk::{Chunk, ChunkDisassembler, ChunkError, Local};
|
pub use chunk::{Chunk, ChunkDisassembler, ChunkError, Local};
|
||||||
pub use dust_error::{AnnotatedError, DustError};
|
pub use dust_error::{AnnotatedError, DustError};
|
||||||
pub use formatter::{format, Formatter};
|
pub use formatter::{format, Formatter};
|
||||||
pub use identifier::Identifier;
|
pub use identifier::Identifier;
|
||||||
pub use instruction::Instruction;
|
pub use instruction::Instruction;
|
||||||
pub use lexer::{lex, LexError, Lexer};
|
pub use lexer::{lex, LexError, Lexer};
|
||||||
|
pub use native_function::NativeFunction;
|
||||||
pub use operation::Operation;
|
pub use operation::Operation;
|
||||||
pub use parser::{parse, ParseError, Parser};
|
pub use parser::{parse, ParseError, Parser};
|
||||||
pub use r#type::{EnumType, FunctionType, RangeableType, StructType, Type, TypeConflict};
|
pub use r#type::{EnumType, FunctionType, RangeableType, StructType, Type, TypeConflict};
|
||||||
@ -26,6 +26,8 @@ pub use token::{Token, TokenKind, TokenOwned};
|
|||||||
pub use value::{Function, Value, ValueError};
|
pub use value::{Function, Value, ValueError};
|
||||||
pub use vm::{run, Vm, VmError};
|
pub use vm::{run, Vm, VmError};
|
||||||
|
|
||||||
|
use std::fmt::Display;
|
||||||
|
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
||||||
|
39
dust-lang/src/native_function.rs
Normal file
39
dust-lang/src/native_function.rs
Normal file
@ -0,0 +1,39 @@
|
|||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
const PANIC: u8 = 0b0000_0000;
|
||||||
|
const TO_STRING: u8 = 0b0000_0001;
|
||||||
|
const WRITE_LINE: u8 = 0b0000_0010;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
|
||||||
|
pub enum NativeFunction {
|
||||||
|
Panic = PANIC as isize,
|
||||||
|
ToString = TO_STRING as isize,
|
||||||
|
WriteLine = WRITE_LINE as isize,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<u8> for NativeFunction {
|
||||||
|
fn from(byte: u8) -> Self {
|
||||||
|
match byte {
|
||||||
|
PANIC => NativeFunction::Panic,
|
||||||
|
TO_STRING => NativeFunction::ToString,
|
||||||
|
WRITE_LINE => NativeFunction::WriteLine,
|
||||||
|
_ => {
|
||||||
|
if cfg!(test) {
|
||||||
|
panic!("Invalid operation byte: {}", byte)
|
||||||
|
} else {
|
||||||
|
NativeFunction::Panic
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<NativeFunction> for u8 {
|
||||||
|
fn from(native_function: NativeFunction) -> Self {
|
||||||
|
match native_function {
|
||||||
|
NativeFunction::Panic => PANIC,
|
||||||
|
NativeFunction::ToString => TO_STRING,
|
||||||
|
NativeFunction::WriteLine => WRITE_LINE,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
@ -30,7 +30,8 @@ const NOT: u8 = 0b0001_0100;
|
|||||||
|
|
||||||
const JUMP: u8 = 0b0001_0101;
|
const JUMP: u8 = 0b0001_0101;
|
||||||
const CALL: u8 = 0b0001_0110;
|
const CALL: u8 = 0b0001_0110;
|
||||||
const RETURN: u8 = 0b0001_0111;
|
const CALL_NATIVE: u8 = 0b0001_0111;
|
||||||
|
const RETURN: u8 = 0b0001_1000;
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||||
pub enum Operation {
|
pub enum Operation {
|
||||||
@ -72,6 +73,7 @@ pub enum Operation {
|
|||||||
// Control flow
|
// Control flow
|
||||||
Jump = JUMP as isize,
|
Jump = JUMP as isize,
|
||||||
Call = CALL as isize,
|
Call = CALL as isize,
|
||||||
|
CallNative = CALL_NATIVE as isize,
|
||||||
Return = RETURN as isize,
|
Return = RETURN as isize,
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -125,6 +127,7 @@ impl From<u8> for Operation {
|
|||||||
NOT => Operation::Not,
|
NOT => Operation::Not,
|
||||||
JUMP => Operation::Jump,
|
JUMP => Operation::Jump,
|
||||||
CALL => Operation::Call,
|
CALL => Operation::Call,
|
||||||
|
CALL_NATIVE => Operation::CallNative,
|
||||||
RETURN => Operation::Return,
|
RETURN => Operation::Return,
|
||||||
_ => {
|
_ => {
|
||||||
if cfg!(test) {
|
if cfg!(test) {
|
||||||
@ -163,6 +166,7 @@ impl From<Operation> for u8 {
|
|||||||
Operation::Not => NOT,
|
Operation::Not => NOT,
|
||||||
Operation::Jump => JUMP,
|
Operation::Jump => JUMP,
|
||||||
Operation::Call => CALL,
|
Operation::Call => CALL,
|
||||||
|
Operation::CallNative => CALL_NATIVE,
|
||||||
Operation::Return => RETURN,
|
Operation::Return => RETURN,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -194,6 +198,7 @@ impl Display for Operation {
|
|||||||
Operation::Not => write!(f, "NOT"),
|
Operation::Not => write!(f, "NOT"),
|
||||||
Operation::Jump => write!(f, "JUMP"),
|
Operation::Jump => write!(f, "JUMP"),
|
||||||
Operation::Call => write!(f, "CALL"),
|
Operation::Call => write!(f, "CALL"),
|
||||||
|
Operation::CallNative => write!(f, "CALL_NATIVE"),
|
||||||
Operation::Return => write!(f, "RETURN"),
|
Operation::Return => write!(f, "RETURN"),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
|
|||||||
|
|
||||||
use crate::{
|
use crate::{
|
||||||
AnnotatedError, Chunk, ChunkError, DustError, FunctionType, Identifier, Instruction, LexError,
|
AnnotatedError, Chunk, ChunkError, DustError, FunctionType, Identifier, Instruction, LexError,
|
||||||
Lexer, Operation, Span, Token, TokenKind, TokenOwned, Type, Value,
|
Lexer, NativeFunction, Operation, Span, Token, TokenKind, TokenOwned, Type, Value,
|
||||||
};
|
};
|
||||||
|
|
||||||
pub fn parse(source: &str) -> Result<Chunk, DustError> {
|
pub fn parse(source: &str) -> Result<Chunk, DustError> {
|
||||||
@ -1058,6 +1058,42 @@ impl<'src> Parser<'src> {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn parse_panic(&mut self, _: Allowed) -> Result<(), ParseError> {
|
||||||
|
let start = self.current_position.0;
|
||||||
|
let start_register = self.next_register();
|
||||||
|
|
||||||
|
self.advance()?;
|
||||||
|
|
||||||
|
if self.allow(Token::LeftParenthesis)? {
|
||||||
|
while !self.allow(Token::RightParenthesis)? {
|
||||||
|
let expected_register = self.next_register();
|
||||||
|
|
||||||
|
self.parse_expression()?;
|
||||||
|
|
||||||
|
let actual_register = self.next_register() - 1;
|
||||||
|
|
||||||
|
if expected_register < actual_register {
|
||||||
|
self.emit_instruction(
|
||||||
|
Instruction::close(expected_register, actual_register),
|
||||||
|
self.current_position,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
self.allow(Token::Comma)?;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let end = self.current_position.1;
|
||||||
|
let to_register = self.next_register();
|
||||||
|
let argument_count = to_register - start_register;
|
||||||
|
|
||||||
|
self.emit_instruction(
|
||||||
|
Instruction::call_native(to_register, NativeFunction::Panic, argument_count),
|
||||||
|
Span(start, end),
|
||||||
|
);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
fn parse_statement(&mut self, allowed: Allowed) -> Result<(), ParseError> {
|
fn parse_statement(&mut self, allowed: Allowed) -> Result<(), ParseError> {
|
||||||
self.parse(Precedence::None, allowed)?;
|
self.parse(Precedence::None, allowed)?;
|
||||||
|
|
||||||
@ -1352,8 +1388,8 @@ impl<'src> Parser<'src> {
|
|||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
let start = self.current_position.0;
|
|
||||||
let function_register = last_instruction.a();
|
let function_register = last_instruction.a();
|
||||||
|
let start = self.current_position.0;
|
||||||
|
|
||||||
self.advance()?;
|
self.advance()?;
|
||||||
|
|
||||||
@ -1690,6 +1726,11 @@ impl From<&Token<'_>> for ParseRule<'_> {
|
|||||||
infix: None,
|
infix: None,
|
||||||
precedence: Precedence::None,
|
precedence: Precedence::None,
|
||||||
},
|
},
|
||||||
|
Token::Panic => ParseRule {
|
||||||
|
prefix: Some(Parser::parse_panic),
|
||||||
|
infix: None,
|
||||||
|
precedence: Precedence::Call,
|
||||||
|
},
|
||||||
Token::Percent => ParseRule {
|
Token::Percent => ParseRule {
|
||||||
prefix: None,
|
prefix: None,
|
||||||
infix: Some(Parser::parse_math_binary),
|
infix: Some(Parser::parse_math_binary),
|
||||||
|
@ -32,6 +32,7 @@ pub enum Token<'src> {
|
|||||||
Loop,
|
Loop,
|
||||||
Map,
|
Map,
|
||||||
Mut,
|
Mut,
|
||||||
|
Panic,
|
||||||
Return,
|
Return,
|
||||||
Str,
|
Str,
|
||||||
Struct,
|
Struct,
|
||||||
@ -119,6 +120,7 @@ impl<'src> Token<'src> {
|
|||||||
Token::LessEqual => 2,
|
Token::LessEqual => 2,
|
||||||
Token::Minus => 1,
|
Token::Minus => 1,
|
||||||
Token::MinusEqual => 2,
|
Token::MinusEqual => 2,
|
||||||
|
Token::Panic => 5,
|
||||||
Token::Percent => 1,
|
Token::Percent => 1,
|
||||||
Token::PercentEqual => 2,
|
Token::PercentEqual => 2,
|
||||||
Token::Plus => 1,
|
Token::Plus => 1,
|
||||||
@ -180,6 +182,7 @@ impl<'src> Token<'src> {
|
|||||||
Token::LessEqual => "<=",
|
Token::LessEqual => "<=",
|
||||||
Token::Minus => "-",
|
Token::Minus => "-",
|
||||||
Token::MinusEqual => "-=",
|
Token::MinusEqual => "-=",
|
||||||
|
Token::Panic => "panic",
|
||||||
Token::Percent => "%",
|
Token::Percent => "%",
|
||||||
Token::PercentEqual => "%=",
|
Token::PercentEqual => "%=",
|
||||||
Token::Plus => "+",
|
Token::Plus => "+",
|
||||||
@ -237,6 +240,7 @@ impl<'src> Token<'src> {
|
|||||||
Token::Minus => TokenOwned::Minus,
|
Token::Minus => TokenOwned::Minus,
|
||||||
Token::MinusEqual => TokenOwned::MinusEqual,
|
Token::MinusEqual => TokenOwned::MinusEqual,
|
||||||
Token::Mut => TokenOwned::Mut,
|
Token::Mut => TokenOwned::Mut,
|
||||||
|
Token::Panic => TokenOwned::Panic,
|
||||||
Token::Percent => TokenOwned::Percent,
|
Token::Percent => TokenOwned::Percent,
|
||||||
Token::PercentEqual => TokenOwned::PercentEqual,
|
Token::PercentEqual => TokenOwned::PercentEqual,
|
||||||
Token::Plus => TokenOwned::Plus,
|
Token::Plus => TokenOwned::Plus,
|
||||||
@ -298,6 +302,7 @@ impl<'src> Token<'src> {
|
|||||||
Token::Minus => TokenKind::Minus,
|
Token::Minus => TokenKind::Minus,
|
||||||
Token::MinusEqual => TokenKind::MinusEqual,
|
Token::MinusEqual => TokenKind::MinusEqual,
|
||||||
Token::Mut => TokenKind::Mut,
|
Token::Mut => TokenKind::Mut,
|
||||||
|
Token::Panic => TokenKind::Panic,
|
||||||
Token::Percent => TokenKind::Percent,
|
Token::Percent => TokenKind::Percent,
|
||||||
Token::PercentEqual => TokenKind::PercentEqual,
|
Token::PercentEqual => TokenKind::PercentEqual,
|
||||||
Token::Plus => TokenKind::Plus,
|
Token::Plus => TokenKind::Plus,
|
||||||
@ -351,6 +356,7 @@ impl<'src> Token<'src> {
|
|||||||
| Token::MinusEqual
|
| Token::MinusEqual
|
||||||
| Token::Percent
|
| Token::Percent
|
||||||
| Token::PercentEqual
|
| Token::PercentEqual
|
||||||
|
| Token::Panic
|
||||||
| Token::Plus
|
| Token::Plus
|
||||||
| Token::PlusEqual
|
| Token::PlusEqual
|
||||||
| Token::Slash
|
| Token::Slash
|
||||||
@ -403,6 +409,7 @@ impl<'src> Display for Token<'src> {
|
|||||||
Token::Minus => write!(f, "-"),
|
Token::Minus => write!(f, "-"),
|
||||||
Token::MinusEqual => write!(f, "-="),
|
Token::MinusEqual => write!(f, "-="),
|
||||||
Token::Mut => write!(f, "mut"),
|
Token::Mut => write!(f, "mut"),
|
||||||
|
Token::Panic => write!(f, "panic"),
|
||||||
Token::Percent => write!(f, "%"),
|
Token::Percent => write!(f, "%"),
|
||||||
Token::PercentEqual => write!(f, "%="),
|
Token::PercentEqual => write!(f, "%="),
|
||||||
Token::Plus => write!(f, "+"),
|
Token::Plus => write!(f, "+"),
|
||||||
@ -454,6 +461,7 @@ pub enum TokenOwned {
|
|||||||
Loop,
|
Loop,
|
||||||
Map,
|
Map,
|
||||||
Mut,
|
Mut,
|
||||||
|
Panic,
|
||||||
Return,
|
Return,
|
||||||
Str,
|
Str,
|
||||||
While,
|
While,
|
||||||
@ -536,6 +544,7 @@ impl Display for TokenOwned {
|
|||||||
TokenOwned::Minus => Token::Minus.fmt(f),
|
TokenOwned::Minus => Token::Minus.fmt(f),
|
||||||
TokenOwned::MinusEqual => Token::MinusEqual.fmt(f),
|
TokenOwned::MinusEqual => Token::MinusEqual.fmt(f),
|
||||||
TokenOwned::Mut => Token::Mut.fmt(f),
|
TokenOwned::Mut => Token::Mut.fmt(f),
|
||||||
|
TokenOwned::Panic => Token::Panic.fmt(f),
|
||||||
TokenOwned::Percent => Token::Percent.fmt(f),
|
TokenOwned::Percent => Token::Percent.fmt(f),
|
||||||
TokenOwned::PercentEqual => Token::PercentEqual.fmt(f),
|
TokenOwned::PercentEqual => Token::PercentEqual.fmt(f),
|
||||||
TokenOwned::Plus => Token::Plus.fmt(f),
|
TokenOwned::Plus => Token::Plus.fmt(f),
|
||||||
@ -584,6 +593,7 @@ pub enum TokenKind {
|
|||||||
Let,
|
Let,
|
||||||
Loop,
|
Loop,
|
||||||
Map,
|
Map,
|
||||||
|
Panic,
|
||||||
Return,
|
Return,
|
||||||
Str,
|
Str,
|
||||||
While,
|
While,
|
||||||
@ -667,6 +677,7 @@ impl Display for TokenKind {
|
|||||||
TokenKind::Minus => Token::Minus.fmt(f),
|
TokenKind::Minus => Token::Minus.fmt(f),
|
||||||
TokenKind::MinusEqual => Token::MinusEqual.fmt(f),
|
TokenKind::MinusEqual => Token::MinusEqual.fmt(f),
|
||||||
TokenKind::Mut => Token::Mut.fmt(f),
|
TokenKind::Mut => Token::Mut.fmt(f),
|
||||||
|
TokenKind::Panic => Token::Panic.fmt(f),
|
||||||
TokenKind::Percent => Token::Percent.fmt(f),
|
TokenKind::Percent => Token::Percent.fmt(f),
|
||||||
TokenKind::PercentEqual => Token::PercentEqual.fmt(f),
|
TokenKind::PercentEqual => Token::PercentEqual.fmt(f),
|
||||||
TokenKind::Plus => Token::Plus.fmt(f),
|
TokenKind::Plus => Token::Plus.fmt(f),
|
||||||
|
@ -2,7 +2,7 @@ use std::{cmp::Ordering, mem::replace};
|
|||||||
|
|
||||||
use crate::{
|
use crate::{
|
||||||
parse, value::Primitive, AnnotatedError, Chunk, ChunkError, DustError, FunctionType,
|
parse, value::Primitive, AnnotatedError, Chunk, ChunkError, DustError, FunctionType,
|
||||||
Identifier, Instruction, Operation, Span, Type, Value, ValueError,
|
Identifier, Instruction, NativeFunction, Operation, Span, Type, Value, ValueError,
|
||||||
};
|
};
|
||||||
|
|
||||||
pub fn run(source: &str) -> Result<Option<Value>, DustError> {
|
pub fn run(source: &str) -> Result<Option<Value>, DustError> {
|
||||||
@ -386,6 +386,50 @@ impl Vm {
|
|||||||
self.set(to_register, value, position)?;
|
self.set(to_register, value, position)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
Operation::CallNative => {
|
||||||
|
let to_register = instruction.a();
|
||||||
|
let native_function = NativeFunction::from(instruction.b());
|
||||||
|
let argument_count = instruction.c();
|
||||||
|
let return_value = match native_function {
|
||||||
|
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 = self.get(argument_index, position)?;
|
||||||
|
|
||||||
|
message.push_str(&argument.to_string());
|
||||||
|
}
|
||||||
|
|
||||||
|
Some(message)
|
||||||
|
};
|
||||||
|
|
||||||
|
return Err(VmError::Panic { message, position });
|
||||||
|
}
|
||||||
|
NativeFunction::ToString => {
|
||||||
|
let mut string = String::new();
|
||||||
|
|
||||||
|
for argument_index in 0..argument_count {
|
||||||
|
let argument = self.get(argument_index, position)?;
|
||||||
|
|
||||||
|
string.push_str(&argument.to_string());
|
||||||
|
}
|
||||||
|
|
||||||
|
Some(Value::Primitive(Primitive::String(string)))
|
||||||
|
}
|
||||||
|
NativeFunction::WriteLine => todo!(),
|
||||||
|
};
|
||||||
|
|
||||||
|
if let Some(value) = return_value {
|
||||||
|
self.set(to_register, value, position)?;
|
||||||
|
}
|
||||||
|
}
|
||||||
Operation::Return => {
|
Operation::Return => {
|
||||||
let should_return_value = instruction.b_as_boolean();
|
let should_return_value = instruction.b_as_boolean();
|
||||||
|
|
||||||
@ -626,6 +670,10 @@ pub enum VmError {
|
|||||||
found: Value,
|
found: Value,
|
||||||
position: Span,
|
position: Span,
|
||||||
},
|
},
|
||||||
|
Panic {
|
||||||
|
message: Option<String>,
|
||||||
|
position: Span,
|
||||||
|
},
|
||||||
RegisterIndexOutOfBounds {
|
RegisterIndexOutOfBounds {
|
||||||
index: usize,
|
index: usize,
|
||||||
position: Span,
|
position: Span,
|
||||||
@ -670,6 +718,7 @@ impl AnnotatedError for VmError {
|
|||||||
Self::EmptyRegister { .. } => "Empty register",
|
Self::EmptyRegister { .. } => "Empty register",
|
||||||
Self::ExpectedBoolean { .. } => "Expected boolean",
|
Self::ExpectedBoolean { .. } => "Expected boolean",
|
||||||
Self::ExpectedFunction { .. } => "Expected function",
|
Self::ExpectedFunction { .. } => "Expected function",
|
||||||
|
Self::Panic { .. } => "Explicit Panic",
|
||||||
Self::RegisterIndexOutOfBounds { .. } => "Register index out of bounds",
|
Self::RegisterIndexOutOfBounds { .. } => "Register index out of bounds",
|
||||||
Self::InvalidInstruction { .. } => "Invalid instruction",
|
Self::InvalidInstruction { .. } => "Invalid instruction",
|
||||||
Self::StackOverflow { .. } => "Stack overflow",
|
Self::StackOverflow { .. } => "Stack overflow",
|
||||||
@ -684,6 +733,7 @@ impl AnnotatedError for VmError {
|
|||||||
match self {
|
match self {
|
||||||
Self::EmptyRegister { index, .. } => Some(format!("Register {index} is empty")),
|
Self::EmptyRegister { index, .. } => Some(format!("Register {index} is empty")),
|
||||||
Self::ExpectedFunction { found, .. } => Some(format!("{found} is not a function")),
|
Self::ExpectedFunction { found, .. } => Some(format!("{found} is not a function")),
|
||||||
|
Self::Panic { message, .. } => message.clone(),
|
||||||
Self::RegisterIndexOutOfBounds { index, .. } => {
|
Self::RegisterIndexOutOfBounds { index, .. } => {
|
||||||
Some(format!("Register {index} does not exist"))
|
Some(format!("Register {index} does not exist"))
|
||||||
}
|
}
|
||||||
@ -702,6 +752,7 @@ impl AnnotatedError for VmError {
|
|||||||
Self::EmptyRegister { position, .. } => *position,
|
Self::EmptyRegister { position, .. } => *position,
|
||||||
Self::ExpectedBoolean { position, .. } => *position,
|
Self::ExpectedBoolean { position, .. } => *position,
|
||||||
Self::ExpectedFunction { position, .. } => *position,
|
Self::ExpectedFunction { position, .. } => *position,
|
||||||
|
Self::Panic { position, .. } => *position,
|
||||||
Self::RegisterIndexOutOfBounds { position, .. } => *position,
|
Self::RegisterIndexOutOfBounds { position, .. } => *position,
|
||||||
Self::InvalidInstruction { position, .. } => *position,
|
Self::InvalidInstruction { position, .. } => *position,
|
||||||
Self::StackUnderflow { position } => *position,
|
Self::StackUnderflow { position } => *position,
|
||||||
|
@ -569,75 +569,75 @@ fn if_else_complex() {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
// #[test]
|
||||||
fn if_else_nested() {
|
// fn if_else_nested() {
|
||||||
let source = r#"
|
// let source = r#"
|
||||||
if 0 == 1 {
|
// if 0 == 1 {
|
||||||
if 0 == 2 {
|
// if 0 == 2 {
|
||||||
1;
|
// 1;
|
||||||
} else {
|
// } else {
|
||||||
2;
|
// 2;
|
||||||
}
|
// }
|
||||||
} else {
|
// } else {
|
||||||
if 0 == 3 {
|
// if 0 == 3 {
|
||||||
3;
|
// 3;
|
||||||
} else {
|
// } else {
|
||||||
4;
|
// 4;
|
||||||
}
|
// }
|
||||||
}"#;
|
// }"#;
|
||||||
|
|
||||||
assert_eq!(
|
// assert_eq!(
|
||||||
parse(source),
|
// parse(source),
|
||||||
Ok(Chunk::with_data(
|
// Ok(Chunk::with_data(
|
||||||
None,
|
// None,
|
||||||
vec![
|
// vec![
|
||||||
(
|
// (
|
||||||
*Instruction::equal(true, 0, 1)
|
// *Instruction::equal(true, 0, 1)
|
||||||
.set_b_is_constant()
|
// .set_b_is_constant()
|
||||||
.set_c_is_constant(),
|
// .set_c_is_constant(),
|
||||||
Span(14, 16)
|
// Span(14, 16)
|
||||||
),
|
// ),
|
||||||
(Instruction::jump(7), Span(14, 16)),
|
// (Instruction::jump(7), Span(14, 16)),
|
||||||
(
|
// (
|
||||||
*Instruction::equal(true, 0, 2)
|
// *Instruction::equal(true, 0, 2)
|
||||||
.set_b_is_constant()
|
// .set_b_is_constant()
|
||||||
.set_c_is_constant(),
|
// .set_c_is_constant(),
|
||||||
Span(38, 41)
|
// Span(38, 41)
|
||||||
),
|
// ),
|
||||||
(Instruction::jump(3), Span(38, 41)),
|
// (Instruction::jump(3), Span(38, 41)),
|
||||||
(Instruction::load_constant(0, 1, false), Span(61, 62)),
|
// (Instruction::load_constant(0, 1, false), Span(61, 62)),
|
||||||
(Instruction::jump(11), Span(95, 95)),
|
// (Instruction::jump(11), Span(95, 95)),
|
||||||
(
|
// (
|
||||||
*Instruction::equal(true, 0, 3)
|
// *Instruction::equal(true, 0, 3)
|
||||||
.set_b_is_constant()
|
// .set_b_is_constant()
|
||||||
.set_c_is_constant(),
|
// .set_c_is_constant(),
|
||||||
Span(77, 79)
|
// Span(77, 79)
|
||||||
),
|
// ),
|
||||||
(Instruction::jump(3), Span(77, 79)),
|
// (Instruction::jump(3), Span(77, 79)),
|
||||||
(Instruction::load_constant(0, 2, false), Span(94, 95)),
|
// (Instruction::load_constant(0, 2, false), Span(94, 95)),
|
||||||
(Instruction::jump(11), Span(95, 95)),
|
// (Instruction::jump(11), Span(95, 95)),
|
||||||
(Instruction::load_constant(0, 3, false), Span(114, 115)),
|
// (Instruction::load_constant(0, 3, false), Span(114, 115)),
|
||||||
(Instruction::jump(11), Span(95, 95)),
|
// (Instruction::jump(11), Span(95, 95)),
|
||||||
(Instruction::load_constant(0, 4, false), Span(134, 135)),
|
// (Instruction::load_constant(0, 4, false), Span(134, 135)),
|
||||||
(Instruction::r#return(true), Span(146, 146)),
|
// (Instruction::r#return(true), Span(146, 146)),
|
||||||
],
|
// ],
|
||||||
vec![
|
// vec![
|
||||||
Value::integer(0),
|
// Value::integer(0),
|
||||||
Value::integer(1),
|
// Value::integer(1),
|
||||||
Value::integer(0),
|
// Value::integer(0),
|
||||||
Value::integer(2),
|
// Value::integer(2),
|
||||||
Value::integer(1),
|
// Value::integer(1),
|
||||||
Value::integer(0),
|
// Value::integer(0),
|
||||||
Value::integer(3),
|
// Value::integer(3),
|
||||||
Value::integer(3),
|
// Value::integer(3),
|
||||||
Value::integer(4)
|
// Value::integer(4)
|
||||||
],
|
// ],
|
||||||
vec![]
|
// vec![]
|
||||||
))
|
// ))
|
||||||
);
|
// );
|
||||||
|
|
||||||
assert_eq!(run(source), Ok(Some(Value::integer(4))));
|
// assert_eq!(run(source), Ok(Some(Value::integer(4))));
|
||||||
}
|
// }
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn if_else_simple() {
|
fn if_else_simple() {
|
||||||
|
35
dust-lang/tests/native_functions.rs
Normal file
35
dust-lang/tests/native_functions.rs
Normal file
@ -0,0 +1,35 @@
|
|||||||
|
use dust_lang::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn panic() {
|
||||||
|
let source = "panic(\"Goodbye world!\", 42)";
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
parse(source),
|
||||||
|
Ok(Chunk::with_data(
|
||||||
|
None,
|
||||||
|
vec![
|
||||||
|
(Instruction::load_constant(0, 0, false), Span(6, 22)),
|
||||||
|
(Instruction::load_constant(1, 1, false), Span(24, 26)),
|
||||||
|
(
|
||||||
|
Instruction::call_native(2, NativeFunction::Panic, 2),
|
||||||
|
Span(0, 27)
|
||||||
|
),
|
||||||
|
(Instruction::r#return(true), Span(27, 27))
|
||||||
|
],
|
||||||
|
vec![Value::string("Goodbye world!"), Value::integer(42)],
|
||||||
|
vec![]
|
||||||
|
)),
|
||||||
|
);
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
run(source),
|
||||||
|
Err(DustError::Runtime {
|
||||||
|
error: VmError::Panic {
|
||||||
|
message: Some("Goodbye world! 42".to_string()),
|
||||||
|
position: Span(0, 27)
|
||||||
|
},
|
||||||
|
source
|
||||||
|
})
|
||||||
|
)
|
||||||
|
}
|
Loading…
Reference in New Issue
Block a user