From 47d6ea417d263252ecacac2bcc9b11677cd1baaa Mon Sep 17 00:00:00 2001 From: Jeff Date: Wed, 25 Sep 2024 01:27:10 -0400 Subject: [PATCH] Improve logs; Clean up --- dust-lang/src/parser/mod.rs | 27 +++++++++++++++++---------- dust-lang/src/token.rs | 14 +++++++------- dust-lang/src/vm.rs | 34 +++++----------------------------- dust-shell/src/main.rs | 19 +++++++++---------- 4 files changed, 38 insertions(+), 56 deletions(-) diff --git a/dust-lang/src/parser/mod.rs b/dust-lang/src/parser/mod.rs index 1cb927d..ffc7d3c 100644 --- a/dust-lang/src/parser/mod.rs +++ b/dust-lang/src/parser/mod.rs @@ -7,6 +7,8 @@ use std::{ num::{ParseFloatError, ParseIntError}, }; +use colored::Colorize; + use crate::{ AnnotatedError, Chunk, ChunkError, DustError, Identifier, Instruction, LexError, Lexer, Operation, Span, Token, TokenKind, TokenOwned, Value, @@ -40,7 +42,11 @@ impl<'src> Parser<'src> { pub fn new(mut lexer: Lexer<'src>) -> Result { let (current_token, current_position) = lexer.next_token()?; - log::info!("Starting parser with token \"{current_token}\" at {current_position}"); + log::info!( + "{} at {}", + current_token.to_string().bold(), + current_position.to_string() + ); Ok(Parser { lexer, @@ -96,7 +102,11 @@ impl<'src> Parser<'src> { let (new_token, position) = self.lexer.next_token()?; - log::info!("Parsing \"{new_token}\" at {position}"); + log::info!( + "{} at {}", + new_token.to_string().bold(), + position.to_string() + ); self.previous_token = replace(&mut self.current_token, new_token); self.previous_position = replace(&mut self.current_position, position); @@ -705,9 +715,7 @@ impl<'src> Parser<'src> { ); } - if !self.allow(TokenKind::Comma)? { - self.expect(TokenKind::RightSquareBrace)?; - } + self.allow(TokenKind::Comma)?; } let end_register = self.current_register - 1; @@ -717,7 +725,6 @@ impl<'src> Parser<'src> { Instruction::load_list(self.current_register, start_register, end_register), Span(start, end), ); - self.increment_register()?; Ok(()) } @@ -900,8 +907,8 @@ impl<'src> Parser<'src> { if let Some(prefix_parser) = ParseRule::from(&self.current_token.kind()).prefix { log::debug!( - "Prefix \"{}\" has precedence {precedence}", - self.current_token, + "{} is {precedence} prefix", + self.current_token.to_string().bold(), ); prefix_parser(self, allow_assignment, allow_return)?; @@ -912,8 +919,8 @@ impl<'src> Parser<'src> { while precedence <= infix_rule.precedence { if let Some(infix_parser) = infix_rule.infix { log::debug!( - "Infix \"{}\" has precedence {precedence}", - self.current_token, + "{} is {precedence} infix", + self.current_token.to_string().bold(), ); if allow_assignment && self.current_token == Token::Equal { diff --git a/dust-lang/src/token.rs b/dust-lang/src/token.rs index 6b2d7e3..0159382 100644 --- a/dust-lang/src/token.rs +++ b/dust-lang/src/token.rs @@ -238,10 +238,10 @@ impl<'src> Display for Token<'src> { Token::BangEqual => write!(f, "!="), Token::Bang => write!(f, "!"), Token::Bool => write!(f, "bool"), - Token::Boolean(value) => write!(f, "{}", value), + Token::Boolean(value) => write!(f, "{value}"), Token::Break => write!(f, "break"), - Token::Byte(value) => write!(f, "{}", value), - Token::Character(value) => write!(f, "'{}'", value), + Token::Byte(value) => write!(f, "{value}"), + Token::Character(value) => write!(f, "{value}"), Token::Colon => write!(f, ":"), Token::Comma => write!(f, ","), Token::Dot => write!(f, "."), @@ -252,14 +252,14 @@ impl<'src> Display for Token<'src> { Token::Else => write!(f, "else"), Token::Eof => write!(f, "EOF"), Token::Equal => write!(f, "="), - Token::Float(value) => write!(f, "{}", value), + Token::Float(value) => write!(f, "{value}"), Token::FloatKeyword => write!(f, "float"), Token::Greater => write!(f, ">"), Token::GreaterEqual => write!(f, ">="), - Token::Identifier(value) => write!(f, "{}", value), + Token::Identifier(value) => write!(f, "{value}"), Token::If => write!(f, "if"), Token::Int => write!(f, "int"), - Token::Integer(value) => write!(f, "{}", value), + Token::Integer(value) => write!(f, "{value}"), Token::LeftCurlyBrace => write!(f, "{{"), Token::LeftParenthesis => write!(f, "("), Token::LeftSquareBrace => write!(f, "["), @@ -281,7 +281,7 @@ impl<'src> Display for Token<'src> { Token::Slash => write!(f, "/"), Token::Star => write!(f, "*"), Token::Str => write!(f, "str"), - Token::String(value) => write!(f, "\"{}\"", value), + Token::String(value) => write!(f, "{value}"), Token::Struct => write!(f, "struct"), Token::While => write!(f, "while"), } diff --git a/dust-lang/src/vm.rs b/dust-lang/src/vm.rs index 0101f9f..af3c92a 100644 --- a/dust-lang/src/vm.rs +++ b/dust-lang/src/vm.rs @@ -56,11 +56,11 @@ impl Vm { } while let Ok((instruction, position)) = self.read(Span(0, 0)).copied() { - log::info!( - "Running IP {} {} at {position}", - self.ip - 1, - instruction.operation() - ); + let ip = self.ip - 1; + let operation = instruction.operation(); + let position_display = position.to_string(); + + log::info!("{ip:^3} | {position_display:^10} | {operation}"); match instruction.operation() { Operation::Move => { @@ -68,8 +68,6 @@ impl Vm { let to = instruction.a(); let value = self.take(from, position)?; - log::debug!("R{from} -{{{value}}}-> R{to}"); - self.insert(value, to, position)?; } Operation::Close => { @@ -106,8 +104,6 @@ impl Vm { let length = last_register - first_register + 1; let mut list = Vec::with_capacity(length as usize); - log::debug!("R{to_register} = [R{first_register}..=R{last_register}]"); - for register_index in first_register..=last_register { let value = match self.take(register_index, position) { Ok(value) => value, @@ -171,8 +167,6 @@ impl Vm { .add(right) .map_err(|error| VmError::Value { error, position })?; - log::debug!("{left} + {right} = {sum}"); - self.insert(sum, instruction.a(), position)?; } Operation::Subtract => { @@ -181,8 +175,6 @@ impl Vm { .subtract(right) .map_err(|error| VmError::Value { error, position })?; - log::debug!("{left} - {right} = {difference}"); - self.insert(difference, instruction.a(), position)?; } Operation::Multiply => { @@ -192,8 +184,6 @@ impl Vm { .multiply(right) .map_err(|error| VmError::Value { error, position })?; - log::debug!("{position} {left} * {right}"); - self.insert(product, instruction.a(), position)?; } Operation::Divide => { @@ -202,8 +192,6 @@ impl Vm { .divide(right) .map_err(|error| VmError::Value { error, position })?; - log::debug!("{left} / {right} = {quotient}"); - self.insert(quotient, instruction.a(), position)?; } Operation::Modulo => { @@ -212,8 +200,6 @@ impl Vm { .modulo(right) .map_err(|error| VmError::Value { error, position })?; - log::debug!("{left} % {right} = {remainder}"); - self.insert(remainder, instruction.a(), position)?; } Operation::Test => { @@ -262,8 +248,6 @@ impl Vm { })?; let compare_to = instruction.a_as_boolean(); - log::debug!("{left} == {right} = {boolean} == {compare_to}"); - if boolean == compare_to { self.ip += 1; } else { @@ -295,8 +279,6 @@ impl Vm { })?; let compare_to = instruction.a_as_boolean(); - log::debug!("{left} < {right} = {boolean} == {compare_to}"); - if boolean == compare_to { self.ip += 1; } else { @@ -327,8 +309,6 @@ impl Vm { })?; let compare_to = instruction.a_as_boolean(); - log::debug!("{left} <= {right} = {boolean} == {compare_to}"); - if boolean == compare_to { self.ip += 1; } else { @@ -353,8 +333,6 @@ impl Vm { .negate() .map_err(|error| VmError::Value { error, position })?; - log::debug!("-({value}) = {negated}"); - self.insert(negated, instruction.a(), position)?; } Operation::Not => { @@ -367,8 +345,6 @@ impl Vm { .not() .map_err(|error| VmError::Value { error, position })?; - log::debug!("!{value} = {not}"); - self.insert(not, instruction.a(), position)?; } Operation::Jump => { diff --git a/dust-shell/src/main.rs b/dust-shell/src/main.rs index 1618fba..5d5be04 100644 --- a/dust-shell/src/main.rs +++ b/dust-shell/src/main.rs @@ -23,22 +23,21 @@ fn main() { env_logger::builder() .parse_env("DUST_LOG") .format(|buf, record| { - let level = match record.level() { - Level::Info => "INFO".white().bold(), - Level::Debug => "DEBUG".blue().bold(), - Level::Warn => "WARN".yellow().bold(), - Level::Error => "ERROR".red().bold(), - Level::Trace => "TRACE".purple().bold(), - } - .bold(); - let level_display = format!("{level:<5}"); + let level_display = match record.level() { + Level::Info => "INFO".bold().white(), + Level::Debug => "DEBUG".bold().blue(), + Level::Warn => "WARN".bold().yellow(), + Level::Error => "ERROR".bold().red(), + Level::Trace => "TRACE".bold().purple(), + }; let module = record .module_path() .map(|path| path.split("::").last().unwrap_or(path)) .unwrap_or("unknown") .dimmed(); + let display = format!("{level_display:5} {module:^6} {args}", args = record.args()); - writeln!(buf, "{level_display:^10} {module:^6} {}", record.args()) + writeln!(buf, "{display}") }) .init();