pub fn parse_program(program: &str) -> Result<Program, Vec<(u64, String)>>Expand description
Parse an entire program, returning either a ready-to-execute MLeM program or a Vec of error messages, with line numbers, of all errors in the program.
ยงExample
A valid program:
use mlem_asm::*;
let valid_program = "
noop
move R:R0 R:SP;
input R:R0;
; comment only
";
let expected_program = Ok(vec![
Instruction::NoOp,
Instruction::Move(Address::RegAbs(Register::R0), Address::RegAbs(Register::SP)),
Instruction::Input(Address::RegAbs(Register::R0))
]);
let program = parse_program(valid_program);
assert!(program == expected_program, "Program resulted in: {:?} not: {:?}", program, expected_program);An invalid program:
use mlem_asm::*;
let invalid_program = "
noop
move R:R0 R:xx;
output invalid;
; comment only
";
let expected_errors = Err(vec![(2, "Unknown register name: xx".into()), (3, "Malformed address.".into())]);
let errors = parse_program(invalid_program);
assert!(errors == expected_errors, "Program resulted in: {:?} not: {:?}", errors, expected_errors);Examples found in repository?
examples/mlem-asm.rs (line 74)
49fn load_and_process(args: Vec<String>, mode: Mode) {
50 let mut f = BufReader::new(File::open(&args[2]).unwrap());
51 let mut contents = String::new();
52 f.read_to_string(&mut contents).unwrap();
53
54 let mut out: Option<Output> = None;
55 let mut inp: Option<Input> = None;
56
57 match mode {
58 Mode::Assemble => {
59 out = Some(if args.len() == 4 {
60 Output::File(BufWriter::new(File::create(&args[3]).unwrap()))
61 } else {
62 Output::StdOut(BufWriter::new(std::io::stdout()))
63 });
64 },
65 Mode::Execute => {
66 inp = Some(if args.len() == 4 {
67 Input::File(BufReader::new(File::create(&args[3]).unwrap()))
68 } else {
69 Input::StdIn(BufReader::new(std::io::stdin()))
70 });
71 }
72 };
73
74 let result = parse_program(&contents);
75
76 match result {
77 Ok(p) => {
78 match mode {
79 Mode::Assemble => {
80 match out.unwrap() {
81 Output::File(mut o) => { program_to_writer(&p, &mut o).unwrap(); },
82 Output::StdOut(mut o) => { program_to_writer(&p, &mut o).unwrap(); }
83 }
84 },
85 Mode::Execute => {
86 match inp.unwrap() {
87 Input::File(mut i) => {
88 let mut o = std::io::stdout();
89 let mut m = Machine::new(65535, &mut i, &mut o);
90 m.load_program(p);
91 println!("\n{:?}", m.run())
92 },
93 Input::StdIn(mut i) => {
94 let mut o = std::io::stdout();
95 let mut m = Machine::new(65535, &mut i, &mut o);
96 m.load_program(p);
97 println!("\n{:?}", m.run())
98 }
99 }
100 }
101 }
102 }
103 Err(e) => {
104 println!("Could not assemble program.");
105 for error in e {
106 println!("{:2}: {}", error.0, error.1);
107 }
108 std::process::exit(1);
109 }
110 }
111}