blah 0.1.0

Unified Toolchain for Brainfuck.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::collections::HashMap;
use std::fs::{self, write};
use std::path::{Path, PathBuf};

use blah::compiler::CodeGen;
use blah::interpreter::Interpreter;
use blah::package::{self, Manifest};
use blah::shared::Operation;
use clap::{CommandFactory, Parser, Subcommand};
use inkwell::context::Context;

#[derive(Parser, Debug)]
#[command(version, about = "Barb: Unified Toolchain for Brainfuck.")]
struct Cli {
    #[arg(short, long, global = true)]
    interpret: bool,

    #[command(subcommand)]
    command: Option<Commands>,

    file: Option<PathBuf>,
}

#[derive(Subcommand, Debug)]
enum Commands {
    #[command(about = "Run a brainfuck file.")]
    Run { file: PathBuf },

    #[command(about = "Build native binary.")]
    Build {
        file: PathBuf,

        #[arg(short, long, default_value = "build/")]
        output_dir: PathBuf,
    },

    #[command(about = "Create a new project.")]
    New { name: String },

    #[command(about = "Install packages from bark.toml.")]
    Install,
}

fn main() {
    let cli = Cli::parse();

    match &cli.command {
        Some(Commands::Run { file }) => {
            let operations = parse(file);
            run(operations, cli.interpret);
        }
        Some(Commands::Build { file, output_dir }) => {
            let operations = parse(file);
            let context = Context::create();
            let codegen = CodeGen::new(&context);
            codegen.compile(&operations);
            codegen.build(output_dir, file);
        }
        Some(Commands::New { name }) => {
            let dir = Path::new(name);
            fs::create_dir_all(dir).unwrap();

            let manifest = Manifest {
                name: name.clone(),
                features: HashMap::new(),
                dependencies: HashMap::new(),
            };

            write(dir.join("bark.toml"), toml::to_string(&manifest).unwrap()).unwrap();

            let hello = ">++++++++[<+++++++++>-]<.>++++[<+++++++>-]<+.+++++++..+++.>>++++++[<+++++++>-]<++.------------.>++++++[<+++++++++>-]<+.<.+++.------.--------.>>>++++[<++++++++>-]<+.";
            write(dir.join("main.bf"), hello).unwrap();

            println!("Created project: {name}");
        }
        Some(Commands::Install) => {
            let root = std::env::current_dir().unwrap();
            match package::Resolver::new(&root) {
                Some(ref r) => {
                    let _ = r;
                    println!("Dependencies resolved");
                }
                None => eprintln!("error: no bark.toml found in the current directory"),
            }
        }
        None => {
            let file = cli.file.as_ref().unwrap_or_else(|| {
                Cli::command()
                    .error(
                        clap::error::ErrorKind::MissingRequiredArgument,
                        "requires a brainfuck file",
                    )
                    .exit();
            });
            let operations = parse(file);
            run(operations, cli.interpret);
        }
    }
}

fn parse(path: &Path) -> Vec<Operation> {
    package::parse_source(path)
}

fn run(operations: Vec<Operation>, interpret: bool) {
    if interpret {
        let mut interpreter = Interpreter {
            memory: [0; 30000],
            data_ptr: 0,
            instr_ptr: 0,
            program: operations,
        };
        interpreter.run();
    } else {
        let context = Context::create();
        let codegen = CodeGen::new(&context);
        codegen.compile(&operations);
        codegen.jit_run();
    }
}