parser2
This commit is contained in:
+2
-172
@@ -1,178 +1,8 @@
|
||||
#![feature(box_patterns)]
|
||||
#![feature(try_trait_v2)]
|
||||
#![feature(associated_type_defaults)]
|
||||
#![feature(trait_alias)]
|
||||
#![feature(let_chains)]
|
||||
#![feature(iterator_try_collect)]
|
||||
// dawg what
|
||||
#![feature(str_as_str)]
|
||||
|
||||
pub const FILE_EXT: &str = "lang";
|
||||
|
||||
use common::{CompilerOutput, SrcFile};
|
||||
use ir::{LProgram, UProgram};
|
||||
use parser::{Import, Imports, PModule, ParserCtx};
|
||||
use std::{
|
||||
collections::HashSet,
|
||||
fs::{create_dir_all, OpenOptions},
|
||||
io::stdout,
|
||||
os::unix::fs::OpenOptionsExt,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
};
|
||||
|
||||
mod common;
|
||||
mod compiler;
|
||||
mod ir;
|
||||
mod parser;
|
||||
mod util;
|
||||
|
||||
fn main() {
|
||||
let file = std::env::args_os().nth(1);
|
||||
// TODO: professional arg parsing
|
||||
let gdb = std::env::args().nth(2).is_some_and(|a| a == "--debug");
|
||||
let asm = std::env::args().nth(2).is_some_and(|a| a == "--asm");
|
||||
if let Some(path) = file {
|
||||
let path = PathBuf::from(path);
|
||||
run_file(&path, gdb, asm);
|
||||
} else {
|
||||
run_stdin();
|
||||
}
|
||||
}
|
||||
|
||||
impl UProgram {
|
||||
pub fn from_path(path: &Path) -> (Self, CompilerOutput) {
|
||||
let parent = path.parent().expect("bruh");
|
||||
let mut program = Self::new();
|
||||
let mut output = CompilerOutput::new();
|
||||
|
||||
let mut imports = Imports::new();
|
||||
imports.insert(Import(vec![path
|
||||
.file_name()
|
||||
.expect("bruh")
|
||||
.to_str()
|
||||
.expect("bruh")
|
||||
.to_string()]));
|
||||
let mut imported = HashSet::new();
|
||||
let mut fid = 0;
|
||||
|
||||
while !imports.is_empty() {
|
||||
let iter = std::mem::take(&mut imports);
|
||||
for i in iter {
|
||||
let import_path = &i.0;
|
||||
if imported.contains(&i) {
|
||||
continue;
|
||||
}
|
||||
let mut file_path = parent.to_path_buf();
|
||||
file_path.extend(import_path);
|
||||
file_path.set_extension(FILE_EXT);
|
||||
let text = std::fs::read_to_string(&file_path).expect("failed to read file");
|
||||
output.file_map.insert(
|
||||
fid,
|
||||
SrcFile {
|
||||
path: file_path,
|
||||
text: text.clone(),
|
||||
},
|
||||
);
|
||||
let mut ctx = ParserCtx::new(fid, text.as_str(), &mut output);
|
||||
fid += 1;
|
||||
let res = PModule::parse(&mut ctx);
|
||||
// println!("Parsed:");
|
||||
// println!("{:#?}", res.node);
|
||||
res.lower(import_path.clone(), &mut program, &mut imports, &mut output);
|
||||
imported.insert(i);
|
||||
}
|
||||
}
|
||||
(program, output)
|
||||
}
|
||||
}
|
||||
|
||||
fn run_file(path: &Path, gdb: bool, asm: bool) {
|
||||
let (mut program, mut output) = UProgram::from_path(path);
|
||||
program.resolve(&mut output);
|
||||
// println!("vars:");
|
||||
// for (id, def) in program.iter_vars() {
|
||||
// println!(" {id:?} = {}: {}", program.names.path(id), program.type_name(&def.ty));
|
||||
// }
|
||||
// for (id, f) in program.iter_fns() {
|
||||
// println!("{}:{id:?} = {:#?}", program.names.path(id), f);
|
||||
// }
|
||||
if !output.errs.is_empty() {
|
||||
output.write_to(&mut stdout());
|
||||
return;
|
||||
}
|
||||
let program = LProgram::create(&program).expect("morir");
|
||||
let unlinked = compiler::compile(&program);
|
||||
if asm {
|
||||
println!("{:?}", unlinked);
|
||||
} else {
|
||||
let bin = unlinked.link().to_elf();
|
||||
println!("compiled");
|
||||
save_run(&bin, gdb);
|
||||
}
|
||||
output.write_to(&mut stdout());
|
||||
}
|
||||
|
||||
fn save_run(binary: &[u8], run_gdb: bool) {
|
||||
use std::io::prelude::*;
|
||||
let dir = Path::new("./build");
|
||||
create_dir_all(dir).expect("Failed to create or confirm build directory");
|
||||
let name = Path::new("test");
|
||||
let path = dir.join(name);
|
||||
let path = path.as_os_str();
|
||||
let mut file = OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.truncate(true)
|
||||
.mode(0o750)
|
||||
.open(path)
|
||||
.expect("Failed to create file");
|
||||
file.write_all(binary).expect("Failed to write to file");
|
||||
file.sync_all().expect("Failed to sync file");
|
||||
println!("running...");
|
||||
let mut p = Command::new("qemu-riscv64");
|
||||
let proc = if run_gdb {
|
||||
p.arg("-g").arg("1234").arg(path).spawn()
|
||||
} else {
|
||||
p.arg(path).spawn()
|
||||
};
|
||||
if let Ok(mut process) = proc {
|
||||
if run_gdb {
|
||||
match Command::new("gdb")
|
||||
.arg("-q")
|
||||
.arg("-ex")
|
||||
.arg("target remote :1234")
|
||||
.arg(path)
|
||||
.spawn()
|
||||
{
|
||||
Ok(mut gdb) => {
|
||||
gdb.wait().expect("xd");
|
||||
}
|
||||
Err(e) => {
|
||||
println!("gdb error: {e:?}");
|
||||
process.kill().expect("uh oh");
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Ok(status) = process.wait() {
|
||||
if let Some(code) = status.code() {
|
||||
std::process::exit(code);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_stdin() {
|
||||
println!("todo");
|
||||
// for line in BufReader::new(std::io::stdin()).lines() {
|
||||
// let str = &line.expect("failed to read line");
|
||||
// let mut ctx = ParserCtx::from(&str[..]);
|
||||
// if let Some(expr) = PStatement::parse_node(&mut ctx).node.as_ref() {
|
||||
// if ctx.next().is_none() {
|
||||
// println!("{:?}", expr);
|
||||
// } else {
|
||||
// println!("uhhhh ehehe");
|
||||
// }
|
||||
// }
|
||||
// ctx.output.write_for(&mut stdout(), str);
|
||||
// }
|
||||
parser::parse(include_str!("test.lang"));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user