xasm 0.5.10

Compiler for the xasm programming language
Documentation 
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

use std::fs::{create_dir_all, rename, write};
use std::path::Path;
use std::process::{Command, Stdio};
use fs_extra::dir::{copy, CopyOptions};
use xassembler::Golang;

use crate::compile::Compile;


fn gopath() -> Result<String, String> {
    if cfg!(unix) {
        Ok(format!("{}/go", Golang::home_dir()?))
    } else {
        Ok(String::from("C:\\Go"))
    }
}


impl Compile for Golang {
    fn compile_subcommand(compiled: &str, dependency_paths: Vec<&str>, output_path: &str) -> Result<(), String> {
        Self::build(compiled, dependency_paths)?;

        match (rename(Self::build_dir()? + "/main", output_path), 
				rename(Self::build_dir()? + "/main.exe", output_path),
				rename(Self::build_dir()? + "/main.bin", output_path)) {
			(Err(_), Err(_), Err(_)) => {
                return Err(format!("Could not move compiled executable to `{}`. Your program most likely did not compile successfully. Check your foreign functions' names", output_path))
			}
            _ => {}
        };

        Ok(())
    }

    fn run_subcommand(compiled: &str, dependency_paths: Vec<&str>) -> Result<(), String> {
        Self::build(compiled, dependency_paths)?;

        if let Err(_) = Command::new("go")
            .args(&["run", "main.go"])
            .current_dir(Self::build_dir()?)
            .stdout(Stdio::inherit())
            .stdin(Stdio::inherit())
            .output() {
			return Err(String::from("Could not run `go`, is golang properly installed?"))
		}

        Ok(())
    }

    fn build(compiled: &str, dependency_paths: Vec<&str>) -> Result<(), String> {
        match create_dir_all(Self::build_dir()?) {
            _ => {}
        };

		let mut copy_opts = CopyOptions::new();
		copy_opts.overwrite = true;

		for dep in &dependency_paths {
			// Get the path to the `src` folder in the GOPATH
			let import_path = format!("{}/src/", gopath()?);

			// Copy the dependency to the `src` folder in the GOPATH
			if let Err(_) = copy(dep, &import_path, &copy_opts) {
				return Err(format!("Could not copy package `{}` to `{}`", dep, import_path))
			};
		}

        let result = format!("package main\nimport (\n{}\n)\n{}", dependency_paths
                                        .iter()
                                        .map(|s|
                                            format!(". \"{}\"",
												Path::new(s).file_name().unwrap()
                                                            .to_str().unwrap()
											))
                                        .collect::<Vec<String>>()
                                        .join("\n"), compiled);

        write(Self::build_dir()? + "/main.go", result).expect("Could not write to file main.go");

		// Install xgopher
        if let Err(_) = Command::new("go")
            .args(&["get", "github.com/adam-mcdaniel/xgopher"])
            .current_dir(Self::build_dir()?)
            .stdout(Stdio::inherit())
            .output() {
			return Err(String::from("Could not run `go`, is golang properly installed?"))
		}

		// Build main.go
        if let Err(_) = Command::new("go")
            .args(&["build", "main.go"])
            .current_dir(Self::build_dir()?)
            .stdout(Stdio::inherit())
            .output() {
			return Err(String::from("Could not run `go`, is golang properly installed?"))
		}

        Ok(())
    }

    const TERMINATE: &'static str = "\n}";
    const BUILD_DIR_NAME: &'static str = "xasm_go_build";
    const PRELUDE: &'static str = r#"
import (
	. "github.com/adam-mcdaniel/xgopher"
)

func Xasm_dict(m *Machine) {
	m.Push(NewEmptyTree())
}

func main() {
	xasm := MakeMachine()
    xasm.Push(NewFunction(Xasm_dict, xasm))
    xasm.Push(NewString("dict"))
    xasm.Store()
	
"#;
}