jeff/dust
1
0
Fork 0
Code

Tweak control flow jumping and compile-time optimizations

Browse Source
This commit is contained in:
Jeff 2024-10-20 22:18:58 -04:00
parent 648bbdbc4d
commit c0f74f1e09
2 changed files with 145 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
dust-lang/src/parser.rs
View File

@ -22,10 +22,11 @@ pub fn parse(source: &str) -> Result<Chunk, DustError> {
.parse_statement(Allowed {
assignment: true,
explicit_return: false,
implicit_return: true,
})
.map_err(|error| DustError::Parse { error, source })?;
parser.commit_current_statement();
parser
.commit_staged()
.map_err(|error| DustError::Parse { error, source })?;
}
Ok(parser.finish())
@ -36,7 +37,7 @@ pub struct Parser<'src> {
lexer: Lexer<'src>,
chunk: Chunk,
current_statement: Vec<(Instruction, Span)>,
staged_instructions: Vec<(Instruction, Span)>,
current_is_expression: bool,
minimum_register: u8,
@ -62,7 +63,7 @@ impl<'src> Parser<'src> {
Ok(Parser {
lexer,
chunk: Chunk::new(None),
current_statement: Vec::new(),
staged_instructions: Vec::new(),
current_is_expression: false,
minimum_register: 0,
current_token,
@ -84,7 +85,7 @@ impl<'src> Parser<'src> {
}
fn next_register(&mut self) -> u8 {
self.current_statement
self.staged_instructions
.iter()
.rev()
.find_map(|(instruction, _)| {
@ -145,15 +146,30 @@ impl<'src> Parser<'src> {
position.to_string()
);
self.current_statement.push((instruction, position));
self.staged_instructions.push((instruction, position));
}
fn commit_current_statement(&mut self) -> Result<(), ParseError> {
fn commit_staged(&mut self) -> Result<(), ParseError> {
if self.staged_instructions.len() == 4
&& self.staged_instructions[0].0.operation().is_comparison()
&& matches!(self.staged_instructions[1].0.operation(), Operation::Jump)
&& matches!(
self.staged_instructions[2].0.operation(),
Operation::LoadBoolean | Operation::LoadConstant
)
&& matches!(
self.staged_instructions[3].0.operation(),
Operation::LoadBoolean | Operation::LoadConstant
)
{
self.staged_instructions[2].0.set_c_to_boolean(true);
}
self.parse_implicit_return()?;
let next_register = self.next_register();
for (instruction, position) in self.current_statement.drain(..) {
for (instruction, position) in self.staged_instructions.drain(..) {
self.chunk.push_instruction(instruction, position);
}
@ -164,14 +180,18 @@ impl<'src> Parser<'src> {
}
fn get_statement_operations<const COUNT: usize>(&self) -> Option<[(Operation, Span); COUNT]> {
if self.current_statement.len() < COUNT {
if self.staged_instructions.len() < COUNT {
return None;
}
let mut operations = [(Operation::Return, Span(0, 0)); COUNT];
for (index, (instruction, position)) in
self.current_statement.iter().rev().enumerate().take(COUNT)
for (index, (instruction, position)) in self
.staged_instructions
.iter()
.rev()
.enumerate()
.take(COUNT)
{
operations[index] = (instruction.operation(), *position);
}
@ -180,7 +200,7 @@ impl<'src> Parser<'src> {
}
fn get_last_jump_mut(&mut self) -> Option<&mut Instruction> {
self.current_statement
self.staged_instructions
.iter_mut()
.rev()
.find_map(|(instruction, _)| {
@ -224,7 +244,7 @@ impl<'src> Parser<'src> {
let boolean = text.parse::<bool>().unwrap();
let register = if let Some(instruction) = self
.current_statement
.staged_instructions
.last()
.map(|(instruction, _)| instruction)
{
@ -396,7 +416,7 @@ impl<'src> Parser<'src> {
self.parse_expression()?;
let (previous_instruction, previous_position) =
self.current_statement
self.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -485,7 +505,7 @@ impl<'src> Parser<'src> {
fn parse_math_binary(&mut self) -> Result<(), ParseError> {
let (left_instruction, left_position) =
self.current_statement
self.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -517,7 +537,7 @@ impl<'src> Parser<'src> {
self.parse_sub_expression(&rule.precedence)?;
let (right_instruction, right_position) =
self.current_statement
self.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -602,7 +622,7 @@ impl<'src> Parser<'src> {
}
let (left_instruction, left_position) =
self.current_statement
self.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -619,7 +639,7 @@ impl<'src> Parser<'src> {
self.parse_sub_expression(&rule.precedence)?;
let (right_instruction, right_position) =
self.current_statement
self.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -672,7 +692,7 @@ impl<'src> Parser<'src> {
self.emit_instruction(instruction, operator_position);
let jump_to = (self.chunk.len() + self.current_statement.len() + 2) as u8;
let jump_to = (self.chunk.len() + self.staged_instructions.len() + 2) as u8;
self.emit_instruction(Instruction::jump(jump_to), operator_position);
self.emit_instruction(
@ -691,7 +711,7 @@ impl<'src> Parser<'src> {
fn parse_logical_binary(&mut self) -> Result<(), ParseError> {
let (left_instruction, left_position) =
self.current_statement
self.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -718,7 +738,7 @@ impl<'src> Parser<'src> {
self.emit_instruction(left_instruction, left_position);
self.emit_instruction(instruction, operator_position);
let jump_to = (self.chunk.len() + self.current_statement.len() + 2) as u8;
let jump_to = (self.chunk.len() + self.staged_instructions.len() + 2) as u8;
self.emit_instruction(Instruction::jump(jump_to), operator_position);
self.parse_sub_expression(&rule.precedence)?;
@ -796,7 +816,7 @@ impl<'src> Parser<'src> {
self.parse_expression()?;
let (mut previous_instruction, previous_position) = self
.current_statement
.staged_instructions
.pop()
.ok_or_else(|| ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
@ -918,14 +938,13 @@ impl<'src> Parser<'src> {
[(Operation::LoadBoolean, _), (Operation::LoadBoolean, _), (Operation::Jump, _), (Operation::Equal | Operation::Less | Operation::LessEqual, _)],
) = self.get_statement_operations()
{
self.current_statement.pop();
self.current_statement.pop();
self.staged_instructions.pop();
self.staged_instructions.pop();
}
let block_allowed = Allowed {
assignment: allowed.assignment,
explicit_return: allowed.explicit_return,
implicit_return: false,
};
if let Token::LeftCurlyBrace = self.current_token {
@ -938,64 +957,61 @@ impl<'src> Parser<'src> {
});
}
let if_block_end = self.current_statement.len();
let if_block_index = self.staged_instructions.len();
let if_block_end = (self.chunk.len() + if_block_index) as u8;
if let Some(if_jump) = self.get_last_jump_mut() {
if_jump.set_b(if_block_end as u8);
if_jump.set_b(if_block_end);
}
if self.allow(Token::Else)? {
if let Token::If = self.current_token {
return self.parse_if(allowed);
}
self.parse_if(allowed)?;
if let Token::LeftCurlyBrace = self.current_token {
let if_block_index = self.staged_instructions.len();
let if_block_end = (self.chunk.len() + if_block_index) as u8;
if let Some(if_jump) = self.get_last_jump_mut() {
if_jump.set_b(if_block_end + 1);
}
} else if let Token::LeftCurlyBrace = self.current_token {
self.parse_block(block_allowed)?;
let else_end = self.current_statement.len();
let else_end = self.chunk.len() + self.staged_instructions.len();
if else_end - if_block_end > 1 {
self.current_statement.insert(
if_block_end,
if else_end - if_block_index > 1 {
self.staged_instructions.insert(
if_block_index,
(
Instruction::jump((else_end + 1) as u8),
self.current_position,
),
);
} else {
self.current_statement
.iter_mut()
.rev()
.filter(|(instruction, _)| {
matches!(
instruction.operation(),
Operation::LoadBoolean | Operation::LoadConstant
)
})
.nth(1)
.map(|(instruction, _)| instruction.set_c_to_boolean(true));
}
self.current_is_expression = self
.current_statement
.staged_instructions
.last()
.map_or(false, |(instruction, _)| instruction.yields_value());
self.commit_current_statement()?;
return Ok(());
self.commit_staged()?;
} else {
return Err(ParseError::ExpectedTokenMultiple {
expected: &[TokenKind::If, TokenKind::LeftCurlyBrace],
found: self.current_token.to_owned(),
position: self.current_position,
});
}
return Err(ParseError::ExpectedTokenMultiple {
expected: &[TokenKind::If, TokenKind::LeftCurlyBrace],
found: self.current_token.to_owned(),
position: self.current_position,
});
self.current_is_expression = self
.staged_instructions
.last()
.map_or(false, |(instruction, _)| instruction.yields_value());
} else {
self.current_is_expression = false;
}
self.current_is_expression = false;
self.commit_current_statement()?;
self.commit_staged()?;
Ok(())
}
@ -1003,7 +1019,7 @@ impl<'src> Parser<'src> {
fn parse_while(&mut self, allowed: Allowed) -> Result<(), ParseError> {
self.advance()?;
let jump_start = (self.chunk.len() + self.current_statement.len()) as u8;
let jump_start = (self.chunk.len() + self.staged_instructions.len()) as u8;
self.parse_expression()?;
@ -1011,17 +1027,16 @@ impl<'src> Parser<'src> {
[(Operation::LoadBoolean, _), (Operation::LoadBoolean, _), (Operation::Jump, _), (Operation::Equal | Operation::Less | Operation::LessEqual, _)],
) = self.get_statement_operations()
{
self.current_statement.pop();
self.current_statement.pop();
self.staged_instructions.pop();
self.staged_instructions.pop();
}
self.parse_block(Allowed {
assignment: true,
explicit_return: allowed.explicit_return,
implicit_return: false,
})?;
let jump_end = (self.chunk.len() + self.current_statement.len()) as u8;
let jump_end = (self.chunk.len() + self.staged_instructions.len()) as u8;
if let Some(jump) = self.get_last_jump_mut() {
jump.set_b(jump_end + 1);
@ -1030,7 +1045,7 @@ impl<'src> Parser<'src> {
let jump_back = Instruction::jump(jump_start);
self.emit_instruction(jump_back, self.current_position);
self.commit_current_statement()?;
self.commit_staged()?;
self.current_is_expression = false;
@ -1049,7 +1064,6 @@ impl<'src> Parser<'src> {
Allowed {
assignment: false,
explicit_return: false,
implicit_return: false,
},
)
}
@ -1060,7 +1074,6 @@ impl<'src> Parser<'src> {
Allowed {
assignment: false,
explicit_return: false,
implicit_return: false,
},
)
}
@ -1092,7 +1105,7 @@ impl<'src> Parser<'src> {
self.current_is_expression = false;
self.commit_current_statement()?;
self.commit_staged()?;
Ok(())
}
@ -1108,7 +1121,7 @@ impl<'src> Parser<'src> {
);
let has_semicolon = self.allow(Token::Semicolon)?;
let returned = self
.current_statement
.staged_instructions
.last()
.map(|(instruction, _)| matches!(instruction.operation(), Operation::Return))
.unwrap_or(false);
@ -1169,7 +1182,7 @@ impl<'src> Parser<'src> {
self.current_is_expression = false;
self.commit_current_statement()?;
self.commit_staged()?;
Ok(())
}
@ -1266,9 +1279,8 @@ impl<'src> Parser<'src> {
function_parser.parse_statement(Allowed {
assignment: true,
explicit_return: true,
implicit_return: true,
})?;
function_parser.commit_current_statement()?;
function_parser.commit_staged()?;
}
function_parser.advance()?;
@ -1306,7 +1318,7 @@ impl<'src> Parser<'src> {
self.current_is_expression = false;
self.commit_current_statement()?;
self.commit_staged()?;
} else {
self.emit_constant(function, Span(function_start, function_end))?;
@ -1317,7 +1329,7 @@ impl<'src> Parser<'src> {
}
fn parse_call(&mut self) -> Result<(), ParseError> {
let (last_instruction, _) = self.current_statement.last().copied().ok_or_else(|| {
let (last_instruction, _) = self.staged_instructions.last().copied().ok_or_else(|| {
ParseError::ExpectedExpression {
found: self.previous_token.to_owned(),
position: self.previous_position,
@ -1473,7 +1485,6 @@ pub enum Context {
struct Allowed {
pub assignment: bool,
pub explicit_return: bool,
pub implicit_return: bool,
}
type PrefixFunction<'a> = fn(&mut Parser<'a>, Allowed) -> Result<(), ParseError>;

97
dust-lang/src/vm.rs
View File

@ -425,11 +425,21 @@ impl Vm {
Ok(())
}
Ordering::Greater => Err(VmError::SkippedRegister {
index: to_register,
length,
position,
}),
Ordering::Greater => {
let difference = to_register - length;
for index in 0..difference {
log::trace!("Set R{index} to empty");
self.stack.push(Register::Empty);
}
log::trace!("Set R{to_register} to {value}");
self.stack.push(Register::Value(value));
Ok(())
}
}
}
@ -461,48 +471,68 @@ impl Vm {
Ok(())
}
Ordering::Greater => Err(VmError::SkippedRegister {
index: to_register,
length,
position,
}),
Ordering::Greater => {
let difference = to_register - length;
for index in 0..difference {
log::trace!("Set R{index} to empty");
self.stack.push(Register::Empty);
}
log::trace!("Set R{to_register} to R{from_register}");
self.stack.push(Register::Pointer(from_register));
Ok(())
}
}
}
fn set_constant(
&mut self,
index: u8,
to_register: u8,
constant_index: u8,
position: Span,
) -> Result<(), VmError> {
let length = self.stack.len();
let index = index as usize;
let to_register = to_register as usize;
if length == Self::STACK_LIMIT {
return Err(VmError::StackOverflow { position });
}
if index == length {
log::trace!("Change register {index} to C{constant_index}");
match to_register.cmp(&length) {
Ordering::Less => {
log::trace!("Change R{to_register} to C{constant_index}");
self.stack.push(Register::Constant(constant_index));
self.stack[to_register] = Register::Constant(constant_index);
return Ok(());
Ok(())
}
Ordering::Equal => {
log::trace!("Set R{to_register} to C{constant_index}");
self.stack.push(Register::Constant(constant_index));
Ok(())
}
Ordering::Greater => {
let difference = to_register - length;
for index in 0..difference {
log::trace!("Set R{index} to empty");
self.stack.push(Register::Empty);
}
log::trace!("Set R{to_register} to C{constant_index}");
self.stack.push(Register::Constant(constant_index));
Ok(())
}
}
if index < length {
log::trace!("Set register {index} to C{constant_index}");
self.stack[index] = Register::Constant(constant_index);
return Ok(());
}
Err(VmError::SkippedRegister {
index,
length: self.stack.len(),
position,
})
}
pub fn get(&self, index: u8, position: Span) -> Result<&Value, VmError> {
@ -596,11 +626,6 @@ pub enum VmError {
instruction: Instruction,
position: Span,
},
SkippedRegister {
index: usize,
length: usize,
position: Span,
},
StackOverflow {
position: Span,
},
@ -639,7 +664,6 @@ impl AnnotatedError for VmError {
Self::ExpectedFunction { .. } => "Expected function",
Self::RegisterIndexOutOfBounds { .. } => "Register index out of bounds",
Self::InvalidInstruction { .. } => "Invalid instruction",
Self::SkippedRegister { .. } => "Skipped register",
Self::StackOverflow { .. } => "Stack overflow",
Self::StackUnderflow { .. } => "Stack underflow",
Self::UndefinedVariable { .. } => "Undefined variable",
@ -672,7 +696,6 @@ impl AnnotatedError for VmError {
Self::ExpectedFunction { position, .. } => *position,
Self::RegisterIndexOutOfBounds { position, .. } => *position,
Self::InvalidInstruction { position, .. } => *position,
Self::SkippedRegister { position, .. } => *position,
Self::StackUnderflow { position } => *position,
Self::StackOverflow { position } => *position,
Self::UndefinedVariable { position, .. } => *position,