Skip to content

Commit 116ba28

Browse files
aceinetxaceinetx
committed
restructure
1 parent 3649f1b commit 116ba28

File tree

3 files changed

+154
-137
lines changed

3 files changed

+154
-137
lines changed

‎zenlang-cli/src/argparser.rs‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
pub struct ArgParser {
2+
pub filename: String,
3+
pub compile: bool,
4+
}
5+
6+
impl ArgParser {
7+
pub fn new() -> Self {
8+
return Self {
9+
filename: String::new(),
10+
compile: false,
11+
};
12+
}
13+
14+
pub fn parse(&mut self, args: &Vec<String>) {
15+
for arg in args {
16+
if arg == "-compile" {
17+
self.compile = true;
18+
} else {
19+
self.filename = arg.to_string();
20+
}
21+
}
22+
}
23+
}

‎zenlang-cli/src/main.rs‎

Lines changed: 18 additions & 137 deletions
Original file line numberDiff line numberDiff line change
@@ -1,123 +1,11 @@
1-
use std::{
2-
env,
3-
fs::{self},
4-
io::Read,
5-
path::Path,
6-
};
7-
use zenlang::{compiler, module, parser, strong_u64::U64BitsControl, tokenizer, vm};
8-
use zenlang_platform_std::*;
1+
use std::{env, fs, io::Read, path::Path};
92

10-
fn run_vm(vm: &mut vm::VM) {
11-
if let Err(e) = vm.set_entry_function("main") {
12-
println!("vm error: {}", e);
13-
return;
14-
}
15-
//println!("{:?}", vm.modules);
16-
17-
vm.run_until_halt();
18-
19-
if !vm.error.is_empty() {
20-
let mut pc = vm.pc;
21-
pc.sub_low(1);
22-
23-
println!("\n-- begin runtime error --");
24-
println!("{}", vm.error);
25-
if let Some(name) = vm.get_function_name_from_pc(pc) {
26-
println!("runtime error in function {}", name,);
27-
}
28-
println!("runtime error at pc = {}:{}", pc.get_low(), pc.get_high(),);
29-
println!("-- end runtime error --");
30-
return;
31-
}
32-
33-
println!("returned {}", vm.ret);
34-
35-
if !vm.stack.is_empty() {
36-
println!("{} values remained on stack!", vm.stack.len());
37-
} else {
38-
println!("no values leaked on stack");
39-
}
40-
}
41-
42-
fn run_code(code: String, module_name: String) {
43-
let mut tokenizer = tokenizer::Tokenizer::new(code);
44-
let mut parser = parser::Parser::new(&mut tokenizer);
45-
let mut compiler = compiler::Compiler::new(&mut parser);
46-
47-
if let Err(e) = compiler.compile() {
48-
println!("compile error: {}", e);
49-
return;
50-
}
51-
52-
if compiler.warnings.len() > 0 {
53-
println!("compile warnings:");
54-
for warning in compiler.warnings.iter() {
55-
println!("- {}", warning);
56-
}
57-
}
58-
59-
let module = compiler.get_module();
60-
module.name = module_name;
61-
62-
let mut vm = vm::VM::new();
63-
vm.platform = Some(Box::new(Platform::new()));
64-
65-
if let Err(e) = vm.load_module(&module) {
66-
println!("{}", e);
67-
return;
68-
}
69-
70-
run_vm(&mut vm);
71-
}
72-
73-
fn compile_code(code: String, module_name: String, out_filename: String) {
74-
let mut tokenizer = tokenizer::Tokenizer::new(code);
75-
let mut parser = parser::Parser::new(&mut tokenizer);
76-
let mut compiler = compiler::Compiler::new(&mut parser);
3+
use crate::argparser::ArgParser;
774

78-
if let Err(e) = compiler.compile() {
79-
println!("compile error: {}", e);
80-
return;
81-
}
82-
83-
if compiler.warnings.len() > 0 {
84-
println!("compile warnings:");
85-
for warning in compiler.warnings.iter() {
86-
println!("- {}", warning);
87-
}
88-
}
89-
90-
let module = compiler.get_module();
91-
module.name = module_name;
92-
match module.compile() {
93-
Err(e) => {
94-
println!("module compile error: {}", e);
95-
}
96-
Ok(bytes) => {
97-
let _ = fs::write(out_filename, bytes);
98-
}
99-
}
100-
}
5+
mod argparser;
6+
mod runner;
1017

102-
fn run_bytes(bytes: Vec<u8>) {
103-
let mut module = module::Module::new();
104-
if let Err(e) = module.load(bytes) {
105-
println!("load error: {}", e);
106-
return;
107-
}
108-
109-
let mut vm = vm::VM::new();
110-
vm.platform = Some(Box::new(Platform::new()));
111-
112-
if let Err(e) = vm.load_module(&module) {
113-
println!("{}", e);
114-
return;
115-
}
116-
117-
run_vm(&mut vm);
118-
}
119-
120-
fn get_module_name_from_path(path: String) -> String {
8+
pub fn get_module_name_from_path(path: &String) -> String {
1219
let path = Path::new(&path);
12210

12311
if let Some(stem) = path.file_stem() {
@@ -128,35 +16,28 @@ fn get_module_name_from_path(path: String) -> String {
12816
}
12917

13018
fn main() {
131-
let mut args: Vec<String> = env::args().collect();
132-
args.push("/home/aceinet/ZenLang/a.zen".into());
19+
let mut args = ArgParser::new();
20+
args.parse(&env::args().collect::<Vec<String>>());
13321

134-
if args.len() < 2 {
22+
if args.filename.is_empty() {
13523
println!("zenlang: no filename provided");
13624
return;
13725
}
13826

139-
let mut compile: bool = false;
140-
if args.len() >= 3 {
141-
if args[2] == "compile" {
142-
compile = true;
143-
}
144-
}
145-
146-
let module_name = get_module_name_from_path(args[1].clone());
147-
match fs::File::open(&args[1]) {
27+
let module_name = get_module_name_from_path(&args.filename);
28+
match fs::File::open(&args.filename) {
14829
Ok(mut file) => {
149-
if !compile {
150-
if args[1].ends_with(".zen") {
30+
if !args.compile {
31+
if args.filename.ends_with(".zen") {
15132
let mut text = String::new();
15233
if let Err(error) = file.read_to_string(&mut text) {
15334
println!("read error: {}", error);
15435
return;
15536
}
156-
run_code(text, module_name);
157-
} else if args[1].ends_with(".zenc") {
37+
runner::run_code(text, module_name);
38+
} else if args.filename.ends_with(".zenc") {
15839
let bytes: Vec<u8>;
159-
match fs::read(&args[1]) {
40+
match fs::read(args.filename) {
16041
Err(e) => {
16142
println!("read error: {}", e);
16243
return;
@@ -165,7 +46,7 @@ fn main() {
16546
bytes = data;
16647
}
16748
}
168-
run_bytes(bytes);
49+
runner::run_bytes(bytes);
16950
}
17051
} else {
17152
let mut text = String::new();
@@ -174,11 +55,11 @@ fn main() {
17455
return;
17556
}
17657
let filename = format!("{}.zenc", module_name);
177-
compile_code(text, module_name, filename);
58+
runner::compile_code(text, module_name, filename);
17859
}
17960
}
18061
Err(e) => {
181-
println!("failed to open {}: {}", &args[1], e);
62+
println!("failed to open {}: {}", args.filename, e);
18263
}
18364
}
18465
}

‎zenlang-cli/src/runner.rs‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,113 @@
1+
use std::fs;
2+
use zenlang::{compiler, module, parser, strong_u64::U64BitsControl, tokenizer, vm};
3+
use zenlang_platform_std::*;
4+
5+
fn run_vm(vm: &mut vm::VM) {
6+
if let Err(e) = vm.set_entry_function("main") {
7+
println!("vm error: {}", e);
8+
return;
9+
}
10+
//println!("{:?}", vm.modules);
11+
12+
vm.run_until_halt();
13+
14+
if !vm.error.is_empty() {
15+
let mut pc = vm.pc;
16+
pc.sub_low(1);
17+
18+
println!("\n-- begin runtime error --");
19+
println!("{}", vm.error);
20+
if let Some(name) = vm.get_function_name_from_pc(pc) {
21+
println!("runtime error in function {}", name,);
22+
}
23+
println!("runtime error at pc = {}:{}", pc.get_low(), pc.get_high(),);
24+
println!("-- end runtime error --");
25+
return;
26+
}
27+
28+
println!("returned {}", vm.ret);
29+
30+
if !vm.stack.is_empty() {
31+
println!("{} values remained on stack!", vm.stack.len());
32+
} else {
33+
println!("no values leaked on stack");
34+
}
35+
}
36+
37+
pub fn run_code(code: String, module_name: String) {
38+
let mut tokenizer = tokenizer::Tokenizer::new(code);
39+
let mut parser = parser::Parser::new(&mut tokenizer);
40+
let mut compiler = compiler::Compiler::new(&mut parser);
41+
42+
if let Err(e) = compiler.compile() {
43+
println!("compile error: {}", e);
44+
return;
45+
}
46+
47+
if compiler.warnings.len() > 0 {
48+
println!("compile warnings:");
49+
for warning in compiler.warnings.iter() {
50+
println!("- {}", warning);
51+
}
52+
}
53+
54+
let module = compiler.get_module();
55+
module.name = module_name;
56+
57+
let mut vm = vm::VM::new();
58+
vm.platform = Some(Box::new(Platform::new()));
59+
60+
if let Err(e) = vm.load_module(&module) {
61+
println!("{}", e);
62+
return;
63+
}
64+
65+
run_vm(&mut vm);
66+
}
67+
68+
pub fn compile_code(code: String, module_name: String, out_filename: String) {
69+
let mut tokenizer = tokenizer::Tokenizer::new(code);
70+
let mut parser = parser::Parser::new(&mut tokenizer);
71+
let mut compiler = compiler::Compiler::new(&mut parser);
72+
73+
if let Err(e) = compiler.compile() {
74+
println!("compile error: {}", e);
75+
return;
76+
}
77+
78+
if compiler.warnings.len() > 0 {
79+
println!("compile warnings:");
80+
for warning in compiler.warnings.iter() {
81+
println!("- {}", warning);
82+
}
83+
}
84+
85+
let module = compiler.get_module();
86+
module.name = module_name;
87+
match module.compile() {
88+
Err(e) => {
89+
println!("module compile error: {}", e);
90+
}
91+
Ok(bytes) => {
92+
let _ = fs::write(out_filename, bytes);
93+
}
94+
}
95+
}
96+
97+
pub fn run_bytes(bytes: Vec<u8>) {
98+
let mut module = module::Module::new();
99+
if let Err(e) = module.load(bytes) {
100+
println!("load error: {}", e);
101+
return;
102+
}
103+
104+
let mut vm = vm::VM::new();
105+
vm.platform = Some(Box::new(Platform::new()));
106+
107+
if let Err(e) = vm.load_module(&module) {
108+
println!("{}", e);
109+
return;
110+
}
111+
112+
run_vm(&mut vm);
113+
}

0 commit comments

Comments
 (0)