mclang/mclangc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mclang:debcf6ad6cc5cdb362ad1655008ab0dd89d4d14a
Branches Tags
mclang:main
mclang:old
...
compare: mclang:323d3342a3d37ef37710664ecb885036c39544ce
Branches Tags
mclang:main
mclang:old

7 Commits
debcf6ad6c ... 323d3342a3

Author SHA1 Message Date
MCorange
323d3342a3
Add a default binary so cargo doesnt ask me everyt time what to run 2024-12-21 23:09:29 +02:00
MCorange
9d243e33b6
Setup parser testing with various tests 2024-12-21 23:09:10 +02:00
MCorange
77738f7e20
Remove unused import 2024-12-21 23:08:45 +02:00
MCorange
bf7f44e776
Dehardcode main function, impemented basic cli 2024-12-21 23:08:29 +02:00
MCorange
857471c6a9
Add the location of the log lines in the compiler code when running a debug build 2024-12-21 23:07:51 +02:00
MCorange
6c01265f0b
Fix array type parsing, where it crashes with "IOT instruction, stack overflow" 2024-12-21 23:07:12 +02:00
MCorange
8bb0e28d80
Fix error when parsing a block where if its empty it errors asking for semicolon 2024-12-21 23:06:02 +02:00
19 changed files with 659 additions and 57 deletions
Show Stats Expand all files Collapse all files

2
Cargo.toml
View File

@ -2,7 +2,7 @@
name = "mclangc"
version = "0.1.0"
edition = "2021"
default-run = "mclangc"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]

1
src/bin/test/main.rs
View File

@ -1,5 +1,4 @@
use std::{collections::HashMap, ffi::OsStr, io::Write, os::unix::ffi::OsStrExt, path::{Path, PathBuf}, process::ExitCode};
use anyhow::bail;
use camino::Utf8PathBuf;
use clap::Parser;
use mclangc;

36
src/cli.rs
View File

@ -1,3 +1,39 @@
use clap::{error::ErrorKind, CommandFactory};
use crate::logger::Level;
#[derive(Debug, clap::Parser)]
pub struct CliArgs {
/// Output more info, will get overwritten if -q|--quiet is specified
#[arg(long, short)]
verbose: bool,
/// Output nothing, except errors, will overwrite -v|--verbose
#[arg(long, short)]
quiet: bool,
/// Output file
#[arg(long, short, default_value="a.out")]
pub output: String,
/// All input files
#[clap(num_args = 1..)]
pub input: Vec<String>
}
impl CliArgs {
pub fn set_log_level(&self) {
if self.quiet {
unsafe {
crate::logger::LEVEL = Level::Error;
}
} else if self.verbose {
unsafe {
crate::logger::LEVEL = Level::Debug;
}
}
}
pub fn validate(&self) {
if self.input.len() < 1 {
CliArgs::command().error(ErrorKind::TooFewValues, "at least one value is required for '<INPUT>' but none was supplied").exit();
}
}
}

112
src/logger.rs
View File

@ -1,8 +1,8 @@
use crate::common::Loc;
pub static mut LEVEL: Level = Level::Info;
#[allow(dead_code)]
#[repr(u8)]
#[derive(Debug, Default)]
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Level {
Off = 0,
Error,
@ -20,26 +20,38 @@ const C_INFO: &'static str = "\x1B[1;32m";
const C_DEBUG: &'static str = "\x1B[1;35m";
const C_HELP: &'static str = "\x1B[1;36m";
pub fn _log(level: Level, str: &str) {
match level {
Level::Off => return,
Level::Error => println!("{C_ERROR}error{C_RESET}: {str}"),
Level::Warn => println!("{C_WARN}warn{C_RESET}: {str}"),
Level::Info => println!("{C_INFO}info{C_RESET}: {str}"),
Level::Help => println!("{C_HELP}help{C_RESET}: {str}"),
Level::Debug => println!("{C_DEBUG}debug{C_RESET}: {str}"),
}
pub fn _log(dbg_loc: Option<(&'static str, u32, u32)>, level: Level, str: &str) {
if level > unsafe { LEVEL }{
return;
}
let dbg = if let Some((file, line, col)) = dbg_loc {
format!("{file}:{line}:{col}: ")
} else {String::new()};
match level {
Level::Off => return,
Level::Error => println!("{dbg}{C_ERROR}error{C_RESET}: {str}"),
Level::Warn => println!("{dbg}{C_WARN}warn{C_RESET}: {str}"),
Level::Info => println!("{dbg}{C_INFO}info{C_RESET}: {str}"),
Level::Help => println!("{dbg}{C_HELP}help{C_RESET}: {str}"),
Level::Debug => println!("{dbg}{C_DEBUG}debug{C_RESET}: {str}"),
}
}
pub fn _log_with_loc(loc: &Loc, level: Level, str: &str) {
match level {
pub fn _log_with_loc(dbg_loc: Option<(&'static str, u32, u32)>, loc: String, level: Level, str: &str) {
if level > unsafe { LEVEL }{
return;
}
let dbg = if let Some((file, line, col)) = dbg_loc {
format!("{file}:{line}:{col}: ")
} else {String::new()};
match level {
Level::Off => return,
Level::Error => println!("{loc}: {C_ERROR}error{C_RESET}: {str}"),
Level::Warn => println!("{loc}: {C_WARN}warn{C_RESET}: {str}"),
Level::Info => println!("{loc}: {C_INFO}info{C_RESET}: {str}"),
Level::Help => println!("{loc}: {C_HELP}help{C_RESET}: {str}"),
Level::Debug => println!("{loc}: {C_DEBUG}debug{C_RESET}: {str}"),
}
Level::Error => println!("{dbg}{loc}: {C_ERROR}error{C_RESET}: {str}"),
Level::Warn => println!("{dbg}{loc}: {C_WARN}warn{C_RESET}: {str}"),
Level::Info => println!("{dbg}{loc}: {C_INFO}info{C_RESET}: {str}"),
Level::Help => println!("{dbg}{loc}: {C_HELP}help{C_RESET}: {str}"),
Level::Debug => println!("{dbg}{loc}: {C_DEBUG}debug{C_RESET}: {str}"),
}
}
#[macro_use]
@ -47,31 +59,51 @@ pub mod log {
#[macro_export]
macro_rules! error {
($($arg:tt)*) => {
crate::logger::_log(crate::logger::Level::Error, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Error, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Error, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! warn {
($($arg:tt)*) => {
crate::logger::_log(crate::logger::Level::Warn, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Warn, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Warn, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! info {
($($arg:tt)*) => {
crate::logger::_log(crate::logger::Level::Info, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Info, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Info, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! help {
($($arg:tt)*) => {
crate::logger::_log(crate::logger::Level::Help, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Help, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Help, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! debug {
($($arg:tt)*) => {
crate::logger::_log(crate::logger::Level::Debug, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Debug, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Debug, &format!($($arg)*))
}
};
}
@ -79,31 +111,51 @@ pub mod log {
#[macro_export]
macro_rules! lerror {
($loc:expr, $($arg:tt)*) => {
crate::logger::_log_with_loc($loc, crate::logger::Level::Error, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Error, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Error, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! lwarn {
($loc:expr, $($arg:tt)*) => {
crate::logger::_log_with_loc($loc, crate::logger::Level::Warn, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Warn, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Warn, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! linfo {
($loc:expr, $($arg:tt)*) => {
crate::logger::_log_with_loc($loc, crate::logger::Level::Info, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Info, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Info, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! lhelp {
($loc:expr, $($arg:tt)*) => {
crate::logger::_log_with_loc($loc, crate::logger::Level::Help, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Help, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Help, &format!($($arg)*))
}
};
}
#[macro_export]
macro_rules! ldebug {
($loc:expr, $($arg:tt)*) => {
crate::logger::_log_with_loc($loc, crate::logger::Level::Debug, &format!($($arg)*))
if cfg!(debug_assertions) {
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Debug, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Debug, &format!($($arg)*))
}
};
}
}

40
src/main.rs
View File

@ -1,11 +1,39 @@
use std::{path::PathBuf, process::ExitCode};
use clap::Parser;
// Importing logger here too cause the logger macros dont work outside the mclanc lib
mod logger;
fn main() -> anyhow::Result<()> {
let data = std::fs::read_to_string("test.mcl").unwrap();
let tokens = mclangc::tokeniser::tokenise(&data, "test.mcl")?;
let prog = mclangc::parser::parse_program(tokens)?;
mclangc::validator::validate_code(&prog);
Ok(())
fn main() -> ExitCode {
let cli = mclangc::cli::CliArgs::parse();
cli.set_log_level();
cli.validate();
for file in &cli.input {
let fp = PathBuf::from(file);
if !fp.exists() {
error!("File {fp:?} doesnt exits, exiting");
return ExitCode::FAILURE;
}
let data = std::fs::read_to_string(fp).unwrap();
info!("Tokenising {file}");
let Ok(tokens) = mclangc::tokeniser::tokenise(&data, &file) else {
error!("Failed to tokenise file, exiting");
return ExitCode::FAILURE;
};
info!("Parsing {file}");
let Ok(prog) = mclangc::parser::parse_program(tokens) else {
error!("Failed to parse file, exiting");
return ExitCode::FAILURE;
};
info!("Validating {file}");
let Ok(validated) = mclangc::validator::validate_code(&prog) else {
error!("Failed to validate file, exiting");
return ExitCode::FAILURE;
};
}
ExitCode::SUCCESS
}

29
src/parser/expr.rs
View File

@ -2,7 +2,7 @@ use std::collections::HashMap;
use anyhow::{bail, Result};
use crate::{debug, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token};
use crate::{debug, error, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token};
use super::{ast::{expr::{Block, CallParams, Expr, IfBranchExpr, IfExpr, Path}, literal::Literal, TokenType}, parse_item, utils, Delimiter, Keyword};
@ -108,12 +108,11 @@ pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool
if let Some(_) = utils::check_from_many(tokens, BINOP_LIST) {
return Ok(Some(parse_binop(tokens, res, precedence)?));
} else {
if consume_semi {
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "Expected ; at the end of the expression")?;
}
return Ok(Some(res));
}
}
if consume_semi {
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "Expected ; at the end of the expression")?;
}
Ok(res)
}
@ -138,7 +137,17 @@ fn parse_if(tokens: &mut Vec<Token>) -> Result<IfExpr> {
lerror!(loc.loc(), "Expected test for if statement, got nothing");
bail!("")
};
let block = parse_block(tokens)?;
let block = if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyL)) {
if let Some(_) = utils::check_2_last(tokens, TokenType::Delim(Delimiter::CurlyR)) {
_ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyR));
Block(Vec::new())
} else {
parse_block(tokens)?
}
} else {
lerror!(loc.loc(), "Expected '{{'");
bail!("")
};
if let Some(_) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Else)) {
if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::If)) {
let branch = IfBranchExpr::ElseIf(Box::new(parse_if(tokens)?));
@ -181,7 +190,7 @@ fn parse_for_loop(tokens: &mut Vec<Token>) -> Result<Expr> {
lerror!(loc.loc(), "Expected init stat for a for loop, got nothing");
bail!("")
};
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "");
// Semicolon parsed out by parse_item above
let Some(test) = parse_expr(tokens, 0, false)? else {
lerror!(loc.loc(), "Expected test comparrison for a for loop, got nothing");
bail!("")
@ -440,14 +449,14 @@ pub fn parse_block(tokens: &mut Vec<Token>) -> Result<Block> {
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyL), "")?;
let mut items = Vec::new();
while !tokens.is_empty() {
if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyR)) {
break;
}
if let Some(item) = parse_item(tokens)? {
items.push(item);
} else {
break;
}
if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyR)) {
break;
}
}
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyR), "")?;
Ok(Block(items))

5
src/parser/typ.rs
View File

@ -1,6 +1,6 @@
use anyhow::Result;
use crate::tokeniser::Token;
use crate::{parser::Delimiter, tokeniser::Token};
use super::{ast::{typ::Type, TokenType}, expr::parse_expr, utils, Keyword, Punctuation};
@ -15,7 +15,7 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
}
let mut typ;
if let Some(_) = utils::check(tokens, TokenType::Delim(super::Delimiter::SquareL)) {
if let Some(_) = utils::check_consume(tokens, TokenType::Delim(super::Delimiter::SquareL)) {
let itm_typ = parse_type(tokens)?;
if let Some(_) = utils::check_consume(tokens, TokenType::Punct(Punctuation::Semi)) {
let count = parse_expr(tokens, 0, false)?.unwrap();
@ -28,6 +28,7 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
inner: Box::new(itm_typ),
}
}
_ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?;
} else {
let ident = utils::check_consume_or_err(tokens, TokenType::ident(""), "a")?;
typ = Type::Owned(ident.tt().unwrap_ident());

29
tests/parser/enumerations.exp
View File

@ -1,6 +1,33 @@
Program {
ast: Block(
[],
[
Statement(
Enum {
name: Ident(
"Foo",
),
fields: [],
},
),
Statement(
Enum {
name: Ident(
"Bar",
),
fields: [
Ident(
"A",
),
Ident(
"B",
),
Ident(
"C",
),
],
},
),
],
),
structs: {},
enums: {},

7
tests/parser/enumerations.mcl
View File

@ -0,0 +1,7 @@
enum Foo {}
enum Bar {
A,
B,
C,
}

53
tests/parser/expressions.exp
View File

@ -1,6 +1,57 @@
Program {
ast: Block(
[],
[
Expr(
BinOp {
typ: Eq,
left: UnOp {
typ: Star,
right: Path(
Path(
[
Ident(
"a",
),
],
),
),
},
right: BinOp {
typ: EqEq,
left: BinOp {
typ: Star,
left: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
right: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
},
right: Literal(
Number(
Number {
val: 4,
base: 10,
signed: false,
},
),
),
},
},
),
],
),
structs: {},
enums: {},

8
tests/parser/expressions.mcl
View File

@ -0,0 +1,8 @@
*a = 1 * 3 == 4;
b.c = 3/4 == *a;
c->d = (a->b.c->d) / 2;
*d->e.f = 2 / a->b.c->d;
e = a->b.c->d / 2;
f = a.b.c.d / 2;
g = a.b[*a.c] * 5;

187
tests/parser/functions.exp
View File

@ -1,6 +1,191 @@
Program {
ast: Block(
[],
[
Statement(
Fn {
struct_name: None,
name: Ident(
"main",
),
params: [
(
Ident(
"argc",
),
Owned(
Ident(
"i32",
),
),
),
(
Ident(
"argv",
),
Ref {
inner: Array {
inner: Owned(
Ident(
"Str",
),
),
},
mutable: false,
},
),
],
ret_type: Some(
Owned(
Ident(
"i32",
),
),
),
qual_const: false,
qual_extern: None,
body: Some(
Block(
[
Expr(
Return(
Some(
Literal(
Number(
Number {
val: 0,
base: 10,
signed: false,
},
),
),
),
),
),
],
),
),
},
),
Statement(
Fn {
struct_name: Some(
Ident(
"Baz",
),
),
name: Ident(
"main",
),
params: [
(
Ident(
"self",
),
Ref {
inner: Owned(
Ident(
"Baz",
),
),
mutable: true,
},
),
(
Ident(
"a",
),
Ref {
inner: Owned(
Ident(
"Foo",
),
),
mutable: false,
},
),
(
Ident(
"b",
),
Ref {
inner: Owned(
Ident(
"Bar",
),
),
mutable: true,
},
),
],
ret_type: Some(
Ref {
inner: Owned(
Ident(
"Nya",
),
),
mutable: false,
},
),
qual_const: false,
qual_extern: None,
body: None,
},
),
Statement(
Fn {
struct_name: Some(
Ident(
"Baz",
),
),
name: Ident(
"main",
),
params: [
(
Ident(
"a",
),
Ref {
inner: Owned(
Ident(
"Foo",
),
),
mutable: false,
},
),
(
Ident(
"b",
),
Ref {
inner: Owned(
Ident(
"Bar",
),
),
mutable: true,
},
),
],
ret_type: Some(
Ref {
inner: Owned(
Ident(
"Nya",
),
),
mutable: false,
},
),
qual_const: false,
qual_extern: None,
body: None,
},
),
],
),
structs: {},
enums: {},

5
tests/parser/functions.mcl
View File

@ -0,0 +1,5 @@
fn main(argc: i32, argv: &[Str]) -> i32 {
return 0;
}
fn Baz.main(self: &mut Baz, a: &Foo, b: &mut Bar) -> &Nya;
fn Baz.main(a: &Foo, b: &mut Bar) -> &Nya;

34
tests/parser/if-statements.exp
View File

@ -1,6 +1,38 @@
Program {
ast: Block(
[],
[
Expr(
If(
IfExpr {
test: BinOp {
typ: Gt,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
},
body: Block(
[],
),
else_if: None,
},
),
),
],
),
structs: {},
enums: {},

18
tests/parser/if-statements.mcl
View File

@ -0,0 +1,18 @@
if i > 3 {
}
if 1 {
} else {
}
if 1 {
} else if a > 3 {
} else {
}

106
tests/parser/loops.exp
View File

@ -1,6 +1,110 @@
Program {
ast: Block(
[],
[
Expr(
ForLoop {
init: Statement(
Let {
name: Ident(
"i",
),
typ: None,
val: Some(
Literal(
Number(
Number {
val: 0,
base: 10,
signed: false,
},
),
),
),
},
),
test: BinOp {
typ: Lt,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 10,
base: 10,
signed: false,
},
),
),
},
on_loop: BinOp {
typ: AddEq,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
},
body: Block(
[],
),
},
),
Expr(
WhileLoop {
test: BinOp {
typ: Gt,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
},
body: Block(
[],
),
},
),
Expr(
InfLoop {
body: Block(
[],
),
},
),
],
),
structs: {},
enums: {},

3
tests/parser/loops.mcl
View File

@ -0,0 +1,3 @@
for let i = 0; i < 10; i += 1 {}
while i > 3 {}
loop {}

33
tests/parser/structs.exp
View File

@ -1,6 +1,37 @@
Program {
ast: Block(
[],
[
Statement(
Struct {
name: Ident(
"foo_t",
),
fields: [],
},
),
Statement(
Struct {
name: Ident(
"bar_t",
),
fields: [
(
Ident(
"a",
),
Ref {
inner: Owned(
Ident(
"bar_t",
),
),
mutable: false,
},
),
],
},
),
],
),
structs: {},
enums: {},

6
tests/parser/structs.mcl
View File

@ -0,0 +1,6 @@
struct foo_t {}
struct bar_t {
a: &bar_t
}