Compare commits

..

No commits in common. "2303bf757a5fbbfd53571ebf9ca7389b5a923481" and "f700c577f1a70ec2c30f9c92a58a871cfbfa522f" have entirely different histories.

9 changed files with 49 additions and 190 deletions

View File

@ -1,8 +1,5 @@
import std::String;
import std::print;
fn main() -> u8 {
let bytes = include_bytes!("./macro_easy_file.txt");
print(String::new() + bytes.length());
return (bytes as *u8)[0];
// let message = String::from(include_bytes!("./macro_easy_file.txt"));
let bytes = test_macro!("./examples/macro_easy_file.txt");
return bytes[0];
}

View File

@ -58,28 +58,6 @@ pub fn form_intrinsics() -> Vec<FunctionDefinition> {
}
pub fn get_intrinsic_assoc_func(ty: &TypeKind, name: &str) -> Option<FunctionDefinition> {
if let TypeKind::Array(_, len) = ty {
match name {
"length" => {
return Some(FunctionDefinition {
name: "length".to_owned(),
linkage_name: None,
is_pub: true,
is_imported: false,
return_type: TypeKind::U64,
parameters: vec![FunctionParam {
name: String::from("self"),
ty: TypeKind::Borrow(Box::new(ty.clone()), false),
meta: Default::default(),
}],
kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicConst(*len))),
source: None,
})
}
_ => {}
}
}
match name {
"sizeof" => Some(FunctionDefinition {
name: "sizeof".to_owned(),
@ -430,14 +408,6 @@ impl IntrinsicFunction for IntrinsicNullPtr {
))
}
}
#[derive(Clone, Debug)]
pub struct IntrinsicConst(u64);
impl IntrinsicFunction for IntrinsicConst {
fn codegen<'ctx, 'a>(&self, scope: &mut Scope<'ctx, 'a>, _: &[StackValue]) -> Result<StackValue, ErrorKind> {
let zero = scope.block.build(Instr::Constant(ConstValueKind::U64(self.0))).unwrap();
Ok(StackValue(StackValueKind::Literal(zero), TypeKind::U64))
}
}
// impl IntrinsicFunction for IntrinsicIAdd {
// fn codegen<'ctx, 'a>(

View File

@ -1313,7 +1313,7 @@ impl mir::Expression {
Some(val)
} else {
match (&val.1, type_kind) {
(TypeKind::CodegenPtr(inner), TypeKind::UserPtr(ty2)) => match *inner.clone() {
(TypeKind::CodegenPtr(inner), TypeKind::UserPtr(_)) => match *inner.clone() {
TypeKind::UserPtr(_) => Some(StackValue(
val.0.derive(
scope
@ -1326,27 +1326,6 @@ impl mir::Expression {
),
TypeKind::CodegenPtr(Box::new(type_kind.clone())),
)),
TypeKind::Borrow(ty1, _) => match *ty1.clone() {
TypeKind::Array(ty1, _) => {
if ty1 == *ty2 {
Some(StackValue(
val.0.derive(
scope
.block
.build(Instr::BitCast(
val.instr(),
Type::Ptr(Box::new(type_kind.get_type(scope.type_values))),
))
.unwrap(),
),
TypeKind::CodegenPtr(Box::new(type_kind.clone())),
))
} else {
return Err(ErrorKind::Null);
}
}
_ => return Err(ErrorKind::Null),
},
_ => panic!(),
},
(TypeKind::UserPtr(_), TypeKind::UserPtr(_))
@ -1381,7 +1360,7 @@ impl mir::Expression {
let global_value = scope.globals.get(global_name).unwrap();
let a = Some(StackValue(
StackValueKind::Literal(scope.block.build(Instr::GetGlobal(global_value.clone())).unwrap()),
ty.clone(),
TypeKind::UserPtr(Box::new(ty.clone())),
));
a
}

View File

@ -82,7 +82,7 @@ pub struct ErrorModule {
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ErrorModules {
pub(super) module_map: HashMap<mir::SourceModuleId, ErrorModule>,
module_map: HashMap<mir::SourceModuleId, ErrorModule>,
module_counter: mir::SourceModuleId,
}

View File

@ -41,7 +41,7 @@
//! - Debug Symbols
//! ```
use std::{collections::HashMap, path::PathBuf, thread, time::Duration};
use std::{path::PathBuf, thread, time::Duration};
use ast::{
lexer::{self, FullToken, Token},
@ -58,7 +58,7 @@ use reid_lib::{compile::CompileOutput, Context};
use crate::{
ast::TopLevelStatement,
mir::macros::{form_macros, MacroModule, MacroPass},
mir::macros::{form_macros, MacroPass},
};
mod ast;
@ -156,16 +156,7 @@ pub fn perform_all_passes<'map>(
));
}
let mut macro_modules: HashMap<_, MacroModule> = HashMap::new();
for (k, v) in &context.modules {
macro_modules.insert(k.clone(), v.into());
}
let mut macro_pass = MacroPass {
macros: form_macros(),
module_map: macro_modules,
};
let state = context.pass(&mut macro_pass)?;
let state = context.pass(&mut MacroPass { macros: form_macros() })?;
#[cfg(debug_assertions)]
println!("{:-^100}", "MACRO OUTPUT");

View File

@ -49,9 +49,6 @@ impl Display for Module {
for typedef in &self.typedefs {
writeln!(inner_f, "{}", typedef)?;
}
for global in &self.globals {
writeln!(inner_f, "global {} = {}", global.name, global.kind)?;
}
for (ty, fun) in &self.associated_functions {
writeln!(inner_f, "(Assoc {}) {}", ty, fun)?;
}
@ -62,26 +59,6 @@ impl Display for Module {
}
}
impl Display for GlobalKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
GlobalKind::Literal(literal) => Display::fmt(literal, f),
GlobalKind::Array(global_kinds) => {
f.write_char('[')?;
let mut iter = global_kinds.iter();
if let Some(global) = iter.next() {
Display::fmt(global, f)?;
while let Some(global) = iter.next() {
write!(f, ", ")?;
Display::fmt(global, f)?;
}
}
f.write_char(']')
}
}
}
}
impl Display for Import {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "import {}", self.0.join("::"))
@ -303,7 +280,7 @@ impl Display for ExprKind {
write!(f, "::")?;
Display::fmt(function_call, f)
}
ExprKind::GlobalRef(global_value, type_kind) => write!(f, "global<{}>(${})", type_kind, global_value),
ExprKind::GlobalRef(global_value, type_kind) => write!(f, "todo globals"),
}
}
}

View File

@ -429,7 +429,7 @@ impl Expression {
Err(_) => Ok((ReturnKind::Soft, type_kind.clone())),
},
AssociatedFunctionCall(_, fcall) => fcall.return_type(),
GlobalRef(_, type_kind) => Ok((ReturnKind::Soft, type_kind.clone())),
GlobalRef(_, type_kind) => Ok((ReturnKind::Soft, TypeKind::UserPtr(Box::new(type_kind.clone())))),
}
}

View File

@ -1,19 +1,11 @@
use std::{collections::HashMap, path::PathBuf};
use std::collections::HashMap;
use crate::mir::{
self, FunctionCall, GlobalKind, GlobalValue, IfExpression, Literal, Module, SourceModuleId, TypeKind,
WhileStatement,
};
use crate::mir::{self, FunctionCall, GlobalKind, GlobalValue, IfExpression, Literal, TypeKind, WhileStatement};
use super::pass::{Pass, PassResult, PassState};
pub trait MacroFunction: std::fmt::Debug {
fn generate<'ctx, 'a>(
&self,
module: &MacroModule,
params: &[mir::Literal],
prefix: String,
) -> Result<(Vec<GlobalValue>, mir::ExprKind), ErrorKind>;
fn generate<'ctx, 'a>(&self, params: &[mir::Literal]) -> Result<(Vec<GlobalValue>, mir::ExprKind), ErrorKind>;
}
#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
@ -32,28 +24,13 @@ pub enum ErrorKind {
MacroExecutionError(String),
}
type MacroModuleMap = HashMap<SourceModuleId, MacroModule>;
/// Struct used to implement a type-checking pass that can be performed on the
/// MIR.
pub struct MacroPass {
pub(crate) macros: HashMap<String, Box<dyn MacroFunction>>,
pub module_map: MacroModuleMap,
}
pub struct MacroModule {
path: Option<PathBuf>,
}
impl From<&Module> for MacroModule {
fn from(value: &Module) -> Self {
MacroModule {
path: value.path.clone(),
}
}
}
type MacroPassState<'map, 'st, 'sc> = PassState<'st, 'sc, (), ErrorKind>;
type MacroPassState<'st, 'sc> = PassState<'st, 'sc, (), ErrorKind>;
impl Pass for MacroPass {
type Data = ();
@ -66,7 +43,7 @@ impl Pass for MacroPass {
fn module(&mut self, module: &mut mir::Module, mut state: PassState<Self::Data, Self::TError>) -> PassResult {
for function in &mut module.functions {
let globals = match &mut function.kind {
mir::FunctionDefinitionKind::Local(block, _) => block.gen_macros(self, &mut state, &self.module_map),
mir::FunctionDefinitionKind::Local(block, _) => block.gen_macros(self, &mut state),
_ => Vec::new(),
};
@ -77,36 +54,36 @@ impl Pass for MacroPass {
}
impl mir::Block {
fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState, map: &MacroModuleMap) -> Vec<GlobalValue> {
fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> Vec<GlobalValue> {
let mut globals = Vec::new();
for statement in &mut self.statements {
globals.extend(statement.gen_macros(data, state, map));
globals.extend(statement.gen_macros(data, state));
}
if let Some((_, Some(return_expr))) = &mut self.return_expression {
globals.extend(return_expr.gen_macros(data, state, map));
globals.extend(return_expr.gen_macros(data, state));
}
globals
}
}
impl mir::Statement {
fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState, map: &MacroModuleMap) -> Vec<GlobalValue> {
fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> Vec<GlobalValue> {
let mut globals = Vec::new();
match &mut self.0 {
mir::StmtKind::Let(.., expr) => {
globals.extend(expr.gen_macros(data, state, map));
globals.extend(expr.gen_macros(data, state));
}
mir::StmtKind::Set(lhs, rhs) => {
globals.extend(lhs.gen_macros(data, state, map));
globals.extend(rhs.gen_macros(data, state, map));
globals.extend(lhs.gen_macros(data, state));
globals.extend(rhs.gen_macros(data, state));
}
mir::StmtKind::Import(_) => {}
mir::StmtKind::Expression(expr) => {
globals.extend(expr.gen_macros(data, state, map));
globals.extend(expr.gen_macros(data, state));
}
mir::StmtKind::While(WhileStatement { condition, block, .. }) => {
globals.extend(condition.gen_macros(data, state, map));
globals.extend(block.gen_macros(data, state, map));
globals.extend(condition.gen_macros(data, state));
globals.extend(block.gen_macros(data, state));
}
};
globals
@ -114,7 +91,7 @@ impl mir::Statement {
}
impl mir::Expression {
fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState, map: &MacroModuleMap) -> Vec<GlobalValue> {
fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> Vec<GlobalValue> {
let mut globals = Vec::new();
match &mut self.0 {
mir::ExprKind::FunctionCall(function_call) => {
@ -129,14 +106,7 @@ impl mir::Expression {
}
let (generated_globals, expr) = state.or_else(
existing_macro
.generate(
map.get(&state.scope.module_id.unwrap()).unwrap(),
&literals,
format!(
"macro.{}.{}.{}",
function_call.name, self.1.range.start, self.1.range.end
),
)
.generate(&literals)
.map(|(globals, kind)| (globals, mir::Expression(kind, self.1))),
(Vec::new(), self.clone()),
self.1,
@ -153,26 +123,26 @@ impl mir::Expression {
}
mir::ExprKind::Variable(_) => {}
mir::ExprKind::Indexed(expression, _, expression1) => {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression1.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
globals.extend(expression1.gen_macros(data, state));
}
mir::ExprKind::Accessed(expression, ..) => {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
}
mir::ExprKind::Array(expressions) => {
for expression in expressions {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
}
}
mir::ExprKind::Struct(_, items) => {
for item in items {
globals.extend(item.1.gen_macros(data, state, map));
globals.extend(item.1.gen_macros(data, state));
}
}
mir::ExprKind::Literal(_) => {}
mir::ExprKind::BinOp(_, expression, expression1, _) => {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression1.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
globals.extend(expression1.gen_macros(data, state));
}
mir::ExprKind::AssociatedFunctionCall(
_,
@ -181,27 +151,27 @@ impl mir::Expression {
},
) => {
for expression in parameters {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
}
}
mir::ExprKind::If(IfExpression(cond, lhs, rhs)) => {
globals.extend(cond.gen_macros(data, state, map));
globals.extend(lhs.gen_macros(data, state, map));
globals.extend(cond.gen_macros(data, state));
globals.extend(lhs.gen_macros(data, state));
if let Some(rhs) = rhs.as_mut() {
globals.extend(rhs.gen_macros(data, state, map));
globals.extend(rhs.gen_macros(data, state));
}
}
mir::ExprKind::Block(block) => {
globals.extend(block.gen_macros(data, state, map));
globals.extend(block.gen_macros(data, state));
}
mir::ExprKind::Borrow(expression, _) => {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
}
mir::ExprKind::Deref(expression) => {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
}
mir::ExprKind::CastTo(expression, _) => {
globals.extend(expression.gen_macros(data, state, map));
globals.extend(expression.gen_macros(data, state));
}
mir::ExprKind::GlobalRef(..) => {}
}
@ -212,20 +182,15 @@ impl mir::Expression {
pub fn form_macros() -> HashMap<String, Box<dyn MacroFunction>> {
let mut macros: HashMap<String, Box<dyn MacroFunction>> = HashMap::new();
macros.insert("include_bytes".to_owned(), Box::new(IncludeBytes));
macros.insert("test_macro".to_owned(), Box::new(TestMacro));
macros
}
#[derive(Debug)]
pub struct IncludeBytes;
impl MacroFunction for IncludeBytes {
fn generate<'ctx, 'a>(
&self,
module: &MacroModule,
literals: &[mir::Literal],
global_name: String,
) -> Result<(Vec<GlobalValue>, mir::ExprKind), ErrorKind> {
pub struct TestMacro;
impl MacroFunction for TestMacro {
fn generate<'ctx, 'a>(&self, literals: &[mir::Literal]) -> Result<(Vec<GlobalValue>, mir::ExprKind), ErrorKind> {
if literals.len() != 1 {
return Err(ErrorKind::InvalidAmountOfParams(literals.len() as u32, 1));
}
@ -237,14 +202,6 @@ impl MacroFunction for IncludeBytes {
));
};
let path = module
.path
.as_ref()
.expect("Module has no path!")
.parent()
.expect("Module path has no parent!")
.join(path);
let contents = match std::fs::read(path) {
Ok(content) => content,
Err(e) => return Err(ErrorKind::MacroExecutionError(format!("{}", e))),
@ -257,6 +214,7 @@ impl MacroFunction for IncludeBytes {
let len = literals.len();
let global_name = "sometestglobalvalue".to_owned();
let global = GlobalValue {
name: global_name.clone(),
kind: GlobalKind::Array(literals),
@ -264,10 +222,7 @@ impl MacroFunction for IncludeBytes {
Ok((
vec![global.clone()],
mir::ExprKind::GlobalRef(
global_name,
TypeKind::Borrow(Box::new(TypeKind::Array(Box::new(TypeKind::U8), len as u64)), false),
),
mir::ExprKind::GlobalRef(global_name, TypeKind::U8),
))
}
}

View File

@ -256,16 +256,6 @@ impl TypeKind {
let other_cat = other.category();
match (self, other) {
(TypeKind::UserPtr(_), TypeKind::UserPtr(_)) => Ok(other.clone()),
(TypeKind::Borrow(ty1, _), TypeKind::UserPtr(ty2)) => match *ty1.clone() {
TypeKind::Array(ty1, _) => {
if ty1 == *ty2 {
Ok(other.clone())
} else {
Err(ErrorKind::NotCastableTo(self.clone(), other.clone()))
}
}
_ => Err(ErrorKind::NotCastableTo(self.clone(), other.clone())),
},
(TypeKind::Char, TypeKind::U8) => Ok(other.clone()),
(TypeKind::U8, TypeKind::Char) => Ok(other.clone()),
_ => match (&self_cat, &other_cat) {