- created dsx and dsx_server in place of dsx-build
- dsx replaces dsx-build and is a build tool/package manager for the DSA ecosystem - dsx_server is the repository/server for dsx packages. dsx is a WIP.
This commit is contained in:
@@ -0,0 +1,53 @@
|
||||
use std::process::{Command, Stdio};
|
||||
use std::{
|
||||
env, fs,
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
|
||||
use dsx::common::builder;
|
||||
|
||||
pub mod new;
|
||||
|
||||
fn main() {
|
||||
// Very small CLI – only three sub‑commands.
|
||||
let args: Vec<String> = env::args().collect();
|
||||
if args.len() < 2 {
|
||||
eprintln!("Usage: dsx-build <new|build|package> [options]");
|
||||
std::process::exit(1);
|
||||
}
|
||||
match args[1].as_str() {
|
||||
"new" => new::new_project(&args[2..]),
|
||||
"build" => {
|
||||
if let Some(dir) = find_project_root() {
|
||||
builder::build_project(&dir).expect("Build failed!");
|
||||
} else {
|
||||
eprintln!("No Dsx.toml found");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
"package" => todo!("Package manager stub – not implemented yet."),
|
||||
_ => {
|
||||
eprintln!("Unknown command: {}", args[1]);
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn find_project_root() -> Option<PathBuf> {
|
||||
// check if current dir has Dsx.toml otherwise check parent dir recursively
|
||||
let mut cwd = env::current_dir().unwrap();
|
||||
loop {
|
||||
let dsx_toml = cwd.join("Dsx.toml");
|
||||
if dsx_toml.exists() {
|
||||
return Some(cwd);
|
||||
}
|
||||
|
||||
if let Some(parent) = cwd.parent() {
|
||||
cwd = parent.to_path_buf();
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
use std::{env, fmt, fs, path::PathBuf};
|
||||
|
||||
use dsx::common::{
|
||||
config::DsxConfig,
|
||||
templates::{self, Dsa, Dsc, Template},
|
||||
};
|
||||
|
||||
// ---------- new project ----------------------------------------------------
|
||||
pub fn new_project(args: &[String]) {
|
||||
// get project details from args.
|
||||
let lang = Language::from_args(args);
|
||||
let lib = args.contains(&"--lib".to_string());
|
||||
let name = project_name(args).unwrap_or_else(|| {
|
||||
eprintln!("Error: --name argument required");
|
||||
std::process::exit(1);
|
||||
});
|
||||
|
||||
let project_path = env::current_dir().unwrap().join(name);
|
||||
let src_path = project_path.join("src");
|
||||
|
||||
fs::create_dir_all(&src_path).expect("Failed to create project directory");
|
||||
|
||||
let config_template = DsxConfig::new(name);
|
||||
fs::write(
|
||||
project_path.join("Dsx.toml"),
|
||||
toml::to_string(&config_template).unwrap(),
|
||||
)
|
||||
.expect("Unable to write default config");
|
||||
|
||||
let (path, template) = match lang {
|
||||
Language::Unknown | Language::Dsa => {
|
||||
(src_path.join("main.dsa"), Dsa::create(name, lib))
|
||||
}
|
||||
Language::Dsc => (src_path.join("main.dsc"), Dsc::create(name, lib)),
|
||||
};
|
||||
|
||||
fs::write(path, template).expect("Unable to write DSA file");
|
||||
|
||||
fs::create_dir_all(src_path.join("lib")).expect("Failed to create lib directory");
|
||||
fs::write(
|
||||
src_path.join("lib/print.dsa"),
|
||||
templates::create_print_lib(),
|
||||
)
|
||||
.expect("Failed to create print.dsa");
|
||||
fs::write(
|
||||
src_path.join("lib/maths.dsa"),
|
||||
templates::create_maths_lib(),
|
||||
)
|
||||
.expect("Failed to create maths.dsa");
|
||||
|
||||
println!(
|
||||
"Created new {} project in {}.",
|
||||
lang,
|
||||
src_path.parent().unwrap().display()
|
||||
);
|
||||
}
|
||||
|
||||
// helpers
|
||||
|
||||
enum Language {
|
||||
Unknown,
|
||||
Dsa,
|
||||
Dsc,
|
||||
}
|
||||
|
||||
impl Language {
|
||||
fn from_args(args: &[String]) -> Self {
|
||||
let mut lang = Language::Unknown;
|
||||
for i in 0..args.len() {
|
||||
if args[i] == "--lang" && i + 1 < args.len() {
|
||||
match args[i + 1].as_str() {
|
||||
"dsa" => lang = Language::Dsa,
|
||||
"dsc" => lang = Language::Dsc,
|
||||
_ => {
|
||||
eprintln!("Error: Invalid language argument");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
lang
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Language {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Unknown => write!(f, "Unknown"),
|
||||
Self::Dsa => write!(f, "Dsa"),
|
||||
Self::Dsc => write!(f, "Dsc"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn project_name(args: &[String]) -> Option<&str> {
|
||||
for i in 0..args.len() {
|
||||
if args[i] == "--name" && i + 1 < args.len() {
|
||||
return Some(&args[i + 1]);
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
use std::{
|
||||
env, fs, io,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
};
|
||||
|
||||
use crate::common::config::DsxConfig;
|
||||
|
||||
use assembler::prelude::Assembler;
|
||||
use common::build::{BuildError, Builder};
|
||||
use compiler::Compiler;
|
||||
|
||||
// ---------- build ----------------------------------------------------------
|
||||
pub fn build_project(cwd: &Path) -> Result<(), BuildError> {
|
||||
let config: DsxConfig = toml::from_str(&fs::read_to_string(cwd.join("Dsx.toml"))?)
|
||||
.map_err(|deser_err| {
|
||||
io::Error::new(io::ErrorKind::InvalidData, deser_err.to_string())
|
||||
})?;
|
||||
|
||||
let src_dir = cwd.join("src");
|
||||
if !src_dir.exists() {
|
||||
return Err(BuildError::Generic(String::from(
|
||||
"Source Directory does not exist",
|
||||
)));
|
||||
}
|
||||
|
||||
// make sure there's a main file to assemble later.
|
||||
if !main_exists(&src_dir)? {
|
||||
return Err(BuildError::Generic(String::from(
|
||||
"No main.dsa or main.dsc file found in top level of src directory.",
|
||||
)));
|
||||
}
|
||||
|
||||
// check is redundant as we're already checking for main files.
|
||||
// if !has_dsc && !has_dsa {
|
||||
// return Err(io::Error::new(
|
||||
// io::ErrorKind::NotFound,
|
||||
// "No .dsc or .dsa source found in src directory.",
|
||||
// ));
|
||||
// }
|
||||
|
||||
// detect src.
|
||||
let (has_dsa, has_dsc) = detect_source_language(&src_dir);
|
||||
|
||||
// create a build dir and copy all files across
|
||||
let build_dir = cwd.join("build");
|
||||
fs::create_dir_all(&build_dir)?;
|
||||
env::set_current_dir(&build_dir)?;
|
||||
|
||||
copy_recursively(&src_dir, &build_dir)?;
|
||||
|
||||
if has_dsc {
|
||||
build_all_dsc(&build_dir)?;
|
||||
}
|
||||
|
||||
// Replace .dsc with .dsa only in include statements, recursively for each file.
|
||||
let mut sed_cmd = Command::new("bash");
|
||||
sed_cmd.args([
|
||||
"-c",
|
||||
&format!(
|
||||
"find \"{}\" -type f -name '*.dsa' -exec sed -i '/^include/ s/\\.dsc/.dsa/g' {{}} +",
|
||||
build_dir.display()
|
||||
),
|
||||
]);
|
||||
run(&mut sed_cmd);
|
||||
|
||||
// assemble result
|
||||
{
|
||||
fs::create_dir_all(cwd.join("artifacts"))?;
|
||||
let mut asm = Assembler::new("./main.dsa");
|
||||
asm.start();
|
||||
asm.write_result("../artifacts/out.dsb")?;
|
||||
}
|
||||
|
||||
println!("Build finished. Binary at {}/main.dsb", build_dir.display());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ----- Helpers -------------------------------
|
||||
|
||||
struct BuildStep;
|
||||
impl BuildStep {
|
||||
pub fn compiling(path: &Path) {
|
||||
println!("Compiling {}", path.display());
|
||||
}
|
||||
|
||||
pub fn assembling(path: &Path) {
|
||||
println!("Assembling {}", path.display());
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks what source languages are used in the project.
|
||||
fn detect_source_language(src_dir: &Path) -> (bool, bool) {
|
||||
let mut contains_dsc = false;
|
||||
let mut contains_dsa = false;
|
||||
|
||||
for entry in walkdir::WalkDir::new(src_dir).into_iter().flatten() {
|
||||
match entry.path().extension().and_then(|s| s.to_str()) {
|
||||
Some("dsc") => contains_dsc = true,
|
||||
Some("dsa") => contains_dsa = true,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
(contains_dsa, contains_dsc)
|
||||
}
|
||||
|
||||
// Checks if either main.dsa or main.dsc exist in the source directory
|
||||
fn main_exists(src_dir: &Path) -> Result<bool, std::io::Error> {
|
||||
for entry in fs::read_dir(src_dir).into_iter().flatten() {
|
||||
match entry?.path().file_name().and_then(|s| s.to_str()) {
|
||||
Some("main.dsc") => return Ok(true),
|
||||
Some("main.dsa") => return Ok(true),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
// Copy contents of one directory to another
|
||||
fn copy_recursively(src: &Path, dst: &Path) -> Result<(), std::io::Error> {
|
||||
if src.is_file() {
|
||||
fs::create_dir_all(dst.parent().unwrap())?;
|
||||
fs::copy(src, dst)?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if src.is_dir() {
|
||||
for entry in fs::read_dir(src)? {
|
||||
let entry = entry?;
|
||||
let child_src = entry.path();
|
||||
let child_dst = dst.join(entry.file_name());
|
||||
copy_recursively(&child_src, &child_dst)?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn build_all_dsc(path: &Path) -> Result<(), BuildError> {
|
||||
if path.is_dir() {
|
||||
for entry in fs::read_dir(path)? {
|
||||
let entry = entry?;
|
||||
build_all_dsc(&entry.path())?;
|
||||
}
|
||||
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if path.extension().and_then(|s| s.to_str()) == Some("dsc") {
|
||||
let input_path = path;
|
||||
let output_path = path.with_extension("dsa");
|
||||
|
||||
let mut compiler = Compiler::new(input_path);
|
||||
compiler.start();
|
||||
compiler.write_result(output_path.clone())?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Run a command and exit on failure.
|
||||
fn run(cmd: &mut Command) {
|
||||
let status = cmd.status().expect("failed to execute command");
|
||||
if !status.success() {
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
use rocket::serde;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct DsxConfig {
|
||||
pub name: String,
|
||||
|
||||
#[serde(default)]
|
||||
pub description: Option<String>,
|
||||
|
||||
#[serde(default)]
|
||||
pub remote_url: Option<String>,
|
||||
|
||||
#[serde(default)]
|
||||
pub binaries: Vec<Binary>,
|
||||
// todo!
|
||||
// #[serde(default)]
|
||||
// pub libraries: Vec<Library>,
|
||||
}
|
||||
|
||||
impl DsxConfig {
|
||||
pub fn new(name: &str) -> Self {
|
||||
Self {
|
||||
name: name.to_string(),
|
||||
description: None,
|
||||
remote_url: None,
|
||||
binaries: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct Binary {
|
||||
pub name: String,
|
||||
pub path: String,
|
||||
}
|
||||
|
||||
impl Binary {
|
||||
pub fn new(name: &str, path: &str) -> Self {
|
||||
Self {
|
||||
name: name.to_string(),
|
||||
path: path.to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
pub mod builder;
|
||||
pub mod config;
|
||||
pub mod templates;
|
||||
@@ -0,0 +1,589 @@
|
||||
pub trait Template {
|
||||
fn lib(project: &str) -> String;
|
||||
fn bin(project: &str) -> String;
|
||||
|
||||
fn create(project: &str, lib: bool) -> String {
|
||||
if lib {
|
||||
Self::lib(project)
|
||||
} else {
|
||||
Self::bin(project)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Dsa;
|
||||
pub struct Dsc;
|
||||
|
||||
impl Template for Dsa {
|
||||
fn lib(project: &str) -> String {
|
||||
format!(
|
||||
r#"//
|
||||
lib.dsa
|
||||
// usage:
|
||||
//
|
||||
// include {project} "<relative path>"
|
||||
//
|
||||
// usage for {project}_main:
|
||||
// push (arg1)
|
||||
// push (arg0)
|
||||
// call {project}::{project}_main
|
||||
// pop (arg0)
|
||||
// pop (arg1)
|
||||
|
||||
// Example data declarations
|
||||
// dw example_data: 0x0000
|
||||
|
||||
// Main function template
|
||||
{project}_main:
|
||||
// the correct way to start a function as defined by the calling convention
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
// explanation of how to access args
|
||||
ldw bpr, rg0, 8 // arg 0
|
||||
ldw bpr, rg0, 12 // arg 1
|
||||
|
||||
// your code goes here
|
||||
// Example: load example_data into rg1
|
||||
// ldw example_data, rg1
|
||||
|
||||
// the correct way to end a function as defined by the calling convention
|
||||
mov bpr, spr
|
||||
pop bpr
|
||||
return
|
||||
"#,
|
||||
)
|
||||
}
|
||||
|
||||
fn bin(project: &str) -> String {
|
||||
format!(
|
||||
r#"
|
||||
// GENERATED BY DSX-BUILD
|
||||
// Generated at: {timestamp}
|
||||
// Project name: {project}
|
||||
|
||||
// Imports
|
||||
include print: "./lib/print.dsa"
|
||||
|
||||
// Globals & Reserved Memory
|
||||
dw stack: 0x10000
|
||||
db message: "Process Exited with code:"
|
||||
|
||||
// Entry Point
|
||||
_init:
|
||||
ldw stack, bpr
|
||||
mov bpr, spr
|
||||
push zero
|
||||
call main
|
||||
call print::print_newline
|
||||
lwi message, rg0
|
||||
push rg0
|
||||
call print::print
|
||||
pop zero
|
||||
call print::print_hex_word
|
||||
pop zero
|
||||
hlt
|
||||
|
||||
main:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
// Your code goes here
|
||||
|
||||
// Return zero
|
||||
stw zero, bpr, 8
|
||||
|
||||
mov bpr, spr
|
||||
pop bpr
|
||||
return"#,
|
||||
timestamp = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S").to_string()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl Template for Dsc {
|
||||
fn lib(project: &str) -> String {
|
||||
format!(
|
||||
r#"
|
||||
// GENERATED BY DSX-BUILD
|
||||
// Generated at: {timestamp}
|
||||
// Project name: {project}
|
||||
|
||||
// Imports
|
||||
include print: "./lib/print.dsa";
|
||||
|
||||
// Main Function
|
||||
fn {project}_main() -> u32 {{
|
||||
return 0;
|
||||
}}"#,
|
||||
timestamp = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S").to_string()
|
||||
)
|
||||
}
|
||||
|
||||
fn bin(project: &str) -> String {
|
||||
format!(
|
||||
r#"
|
||||
// GENERATED BY DSX-BUILD
|
||||
// Generated at: {timestamp}
|
||||
// Project name: {project}
|
||||
|
||||
// Imports
|
||||
include print: "./lib/print.dsa";
|
||||
|
||||
// Main Function
|
||||
fn main() -> u32 {{
|
||||
return 0;
|
||||
}}"#,
|
||||
timestamp = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S").to_string()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_print_lib() -> String {
|
||||
format!(
|
||||
r#"
|
||||
// lib:
|
||||
// print.dsa
|
||||
|
||||
// usage:
|
||||
//
|
||||
// include print "<relative path>""
|
||||
//
|
||||
// usage for print:
|
||||
// push (register containing address of string)
|
||||
// push pcx
|
||||
// jmp print::print
|
||||
//
|
||||
// usage for reset:
|
||||
// push pcx
|
||||
// jmp print::reset
|
||||
//
|
||||
// usage for clear:
|
||||
// push pcx
|
||||
// jmp print::clear
|
||||
//
|
||||
// usage for print_byte:
|
||||
// push (register containing byte)
|
||||
// push pcx
|
||||
// jmp print::print_byte
|
||||
//
|
||||
// usage for print_word:
|
||||
// push (register containing word)
|
||||
// push pcx
|
||||
// jmp print::print_word
|
||||
//
|
||||
// usage for print_num:
|
||||
// push (register containing number to print in decimal)
|
||||
// push pcx
|
||||
// jmp print::print_num
|
||||
//
|
||||
|
||||
include maths "./maths.dsa"
|
||||
|
||||
dw display: 0x20000
|
||||
dw current: 0x20000
|
||||
|
||||
// ------------------------------------------
|
||||
// prints the string at addr(arg[0]) to the screen. (no trailing whitespace unless explicitly provided)
|
||||
print:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8
|
||||
ldw current, rg1
|
||||
|
||||
_print_loop:
|
||||
ldb rg0, acc
|
||||
cmp acc, zero
|
||||
jeq _end
|
||||
stb acc, rg1
|
||||
|
||||
addi rg0, 1
|
||||
addi rg1, 1
|
||||
|
||||
jmp _print_loop
|
||||
|
||||
// ------------------------------------------
|
||||
println:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8
|
||||
ldw current, rg1
|
||||
|
||||
_println_loop:
|
||||
ldb rg0, acc
|
||||
cmp acc, zero
|
||||
jeq _println_end
|
||||
stb acc, rg1
|
||||
|
||||
addi rg0, 1
|
||||
addi rg1, 1
|
||||
|
||||
jmp _println_loop
|
||||
|
||||
_println_end:
|
||||
call print_newline
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// prints the value of arg[0] to the screen.
|
||||
print_word:
|
||||
// initialise
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
// load byte into acc
|
||||
ldw bpr, rg0, 8
|
||||
ldw current, rg1
|
||||
|
||||
addi rg1, 3
|
||||
|
||||
stb rg0, rg1
|
||||
subi rg1, 1
|
||||
shr rg0, 8
|
||||
stb rg0, rg1
|
||||
subi rg1, 1
|
||||
shr rg0, 8
|
||||
stb rg0, rg1
|
||||
subi rg1, 1
|
||||
shr rg0, 8
|
||||
stb rg0, rg1
|
||||
|
||||
addi rg1, 4
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// prints the last byte of arg[0] to the screen.
|
||||
print_byte:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8
|
||||
ldw current, rg1
|
||||
|
||||
stb rg0, rg1
|
||||
addi rg1, 1
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// prints the value of arg[0] to the screen in hex.
|
||||
print_hex_word:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw current, rg1
|
||||
|
||||
ldb bpr, rg0, 8
|
||||
push rg0
|
||||
call _print_hex_byte
|
||||
addi spr, 4
|
||||
|
||||
ldb bpr, rg0, 9
|
||||
push rg0
|
||||
call _print_hex_byte
|
||||
addi spr, 4
|
||||
|
||||
ldb bpr, rg0, 10
|
||||
push rg0
|
||||
call _print_hex_byte
|
||||
addi spr, 4
|
||||
|
||||
ldb bpr, rg0, 11
|
||||
push rg0
|
||||
call _print_hex_byte
|
||||
addi spr, 4
|
||||
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// prints the last byte of arg[0] to the screen in hex.
|
||||
print_hex_byte:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8
|
||||
ldw current, rg1
|
||||
|
||||
call _print_hex_byte
|
||||
jmp _end
|
||||
|
||||
// function body
|
||||
_print_hex_byte:
|
||||
// mask to get lower nibble
|
||||
lli 0xF, rg2
|
||||
// save rg0 state
|
||||
push rg0
|
||||
|
||||
shr rg0, 4
|
||||
and rg0, rg2, rg0
|
||||
call _print_hex_nibble
|
||||
pop rg0
|
||||
|
||||
and rg0, rg2, rg0
|
||||
call _print_hex_nibble
|
||||
return
|
||||
|
||||
// print a hex digit
|
||||
_print_hex_nibble:
|
||||
lli 10, rg3
|
||||
cmp rg0, rg3
|
||||
jlt _print_hex_nibble_number
|
||||
addi rg0, 0x37, rg0
|
||||
stb rg0, rg1
|
||||
addi rg1, 1
|
||||
return
|
||||
|
||||
// helper function.
|
||||
_print_hex_nibble_number:
|
||||
addi rg0, 0x30, rg0
|
||||
stb rg0, rg1
|
||||
addi rg1, 1
|
||||
return
|
||||
|
||||
// ------------------------------------------
|
||||
// print whitespace
|
||||
print_whitespace:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw current, rg1
|
||||
lli 0x20, rg0
|
||||
stb rg0, rg1
|
||||
addi rg1, 1
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// print newline
|
||||
print_newline:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
// load variables into registers
|
||||
ldw display, rg0
|
||||
ldw current, rg1
|
||||
|
||||
// get the offset from the display base
|
||||
sub rg1, rg0, rg0
|
||||
|
||||
lwi 80, rg2
|
||||
pusha 3
|
||||
push rg0
|
||||
push rg2
|
||||
call maths::divmod
|
||||
pop zero // result
|
||||
pop rg3 // remainder
|
||||
popa 3
|
||||
|
||||
sub rg1, rg3, rg2
|
||||
addi rg2, 80, rg1
|
||||
|
||||
// _end saves the display state
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// prints arg[0] as a decimal number to the screen.
|
||||
print_num:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8 // load number to print
|
||||
lli 0, rg5 // rg5 = digit counter
|
||||
|
||||
// check if number is zero
|
||||
cmp rg0, zero
|
||||
jne _print_num_extract_digits
|
||||
|
||||
// special case: print '0' for zero
|
||||
lli 0x30, rg6
|
||||
push rg6 // push digit to stack buffer
|
||||
lli 1, rg5 // we have 1 digit
|
||||
jmp _print_num_output
|
||||
|
||||
_print_num_extract_digits:
|
||||
// divide by 10 repeatedly to get digits
|
||||
cmp rg0, zero
|
||||
jeq _print_num_output
|
||||
|
||||
// call divmod(rg0, 10)
|
||||
push rg0 // dividend
|
||||
lli 10, rg1
|
||||
push rg1 // divisor (10)
|
||||
call maths::divmod
|
||||
pop rg0 // quotient (continue dividing this)
|
||||
pop rg1 // remainder (the digit)
|
||||
|
||||
// convert digit to ASCII and push to stack buffer
|
||||
addi rg1, 0x30, rg6 // convert to ASCII
|
||||
push rg6 // push digit to stack
|
||||
inc rg5 // increment digit counter
|
||||
|
||||
jmp _print_num_extract_digits
|
||||
|
||||
_print_num_output:
|
||||
// now print digits (pop them off in reverse order)
|
||||
ldw current, rg1 // get display pointer
|
||||
|
||||
_print_num_output_loop:
|
||||
// check if we've printed all digits
|
||||
cmp rg5, zero
|
||||
jeq _print_num_done
|
||||
|
||||
// pop digit and print it
|
||||
pop rg6
|
||||
stb rg6, rg1
|
||||
addi rg1, 1
|
||||
dec rg5
|
||||
|
||||
jmp _print_num_output_loop
|
||||
|
||||
_print_num_done:
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// resets the cursor position on the screen to 0x20000. (0,0)
|
||||
reset:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
ldw display, rg1
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// clears the screen
|
||||
clear:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
// display size = 2000 bytes / 500 words
|
||||
lli 500 rg0
|
||||
ldw display, rg1
|
||||
|
||||
_clear_loop:
|
||||
dec rg0
|
||||
stw zero, rg1
|
||||
addi rg1, 4
|
||||
cmp rg0, zero
|
||||
jgt _clear_loop
|
||||
jmp _end
|
||||
|
||||
// ------------------------------------------
|
||||
// return
|
||||
_end:
|
||||
stw rg1, current
|
||||
|
||||
mov bpr, spr
|
||||
pop bpr
|
||||
return
|
||||
"#
|
||||
)
|
||||
}
|
||||
|
||||
pub fn create_maths_lib() -> String {
|
||||
format!(
|
||||
r#"
|
||||
// multiply.dsa
|
||||
// usage:
|
||||
//
|
||||
// include multiply "<relative path>"
|
||||
//
|
||||
// usage for multiply:
|
||||
// push (arg1)
|
||||
// push (arg0)
|
||||
// call multiply::multiply
|
||||
// pop (arg0)
|
||||
// pop (arg1)
|
||||
|
||||
multiply:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8 // load op 2
|
||||
ldw bpr, rg1, 12 // load op 1
|
||||
lwi 0, rg2 // initialise rg2 to zero
|
||||
|
||||
_multiply_loop:
|
||||
add rg2, rg0, rg2
|
||||
dec rg1
|
||||
|
||||
cmp rg1, zero
|
||||
jgt _multiply_loop
|
||||
|
||||
_multiply_end:
|
||||
stw rg2, bpr, 8
|
||||
|
||||
mov bpr, spr
|
||||
pop bpr
|
||||
return
|
||||
|
||||
divmod:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg1, 8 // load op 2
|
||||
ldw bpr, rg0, 12 // load op 1
|
||||
|
||||
lli 0, rg3
|
||||
|
||||
_divmod_loop:
|
||||
cmp rg0, rg1
|
||||
jlt _divmod_end
|
||||
|
||||
sub rg0, rg1, rg0
|
||||
inc rg3
|
||||
|
||||
jmp _divmod_loop
|
||||
|
||||
_divmod_end:
|
||||
// store div in first arg
|
||||
// store mod in second arg
|
||||
stw rg3, bpr, 8
|
||||
stw rg0, bpr, 12
|
||||
|
||||
mov bpr, spr
|
||||
pop bpr
|
||||
return
|
||||
|
||||
// multiply.dsa - improved version
|
||||
// Multiplies two 32-bit numbers using shift-and-add
|
||||
//
|
||||
// Usage:
|
||||
// push operand2 (multiplier)
|
||||
// push operand1 (multiplicand)
|
||||
// call multiply::multiply
|
||||
// pop result
|
||||
// pop zero (discard second argument)
|
||||
|
||||
new_multiply:
|
||||
push bpr
|
||||
mov spr, bpr
|
||||
|
||||
ldw bpr, rg0, 8 // rg0 = multiplicand
|
||||
ldw bpr, rg1, 12 // rg1 = multiplier
|
||||
|
||||
lli 0, rg2 // rg2 = result (accumulator)
|
||||
lli 32, rg3 // rg3 = bit counter
|
||||
|
||||
mult_loop:
|
||||
// Check if lowest bit of multiplier is 1
|
||||
lli 1, acc
|
||||
and rg1, acc, acc // acc = rg1 & 1
|
||||
cmp acc, zero
|
||||
jeq skip_add // if (rg1 & 1) == 0, skip addition
|
||||
|
||||
// Add multiplicand to result
|
||||
add rg2, rg0, rg2
|
||||
|
||||
skip_add:
|
||||
shl rg0, 1 // shift multiplicand left
|
||||
shr rg1, 1 // shift multiplier right
|
||||
|
||||
dec rg3
|
||||
cmp rg3, zero
|
||||
jgt mult_loop
|
||||
|
||||
stw rg2, bpr, 8 // store result
|
||||
mov bpr, spr
|
||||
pop bpr
|
||||
return
|
||||
"#
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod common;
|
||||
@@ -0,0 +1,38 @@
|
||||
use common::build::BuildError;
|
||||
use rocket::{Response, http::Status, response::Responder};
|
||||
use serde::Serialize;
|
||||
|
||||
#[derive(Debug, Serialize, Responder)]
|
||||
pub enum ApiError {
|
||||
#[response(status = 404)]
|
||||
NotFound(String),
|
||||
|
||||
#[response(status = 500)]
|
||||
InternalServerError(()),
|
||||
|
||||
#[response(status = 500)]
|
||||
ServerError(String),
|
||||
|
||||
#[response(status = 401)]
|
||||
Unauthorized(String),
|
||||
#[response(status = 403)]
|
||||
Forbidden(String),
|
||||
|
||||
#[response(status = 400)]
|
||||
BadRequest(String),
|
||||
}
|
||||
|
||||
impl From<std::io::Error> for ApiError {
|
||||
fn from(err: std::io::Error) -> Self {
|
||||
ApiError::InternalServerError(())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<BuildError> for ApiError {
|
||||
fn from(err: BuildError) -> Self {
|
||||
match err {
|
||||
BuildError::IoError(err) => ApiError::ServerError(err.to_string()),
|
||||
BuildError::Generic(err) => ApiError::ServerError(err),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
use std::fs;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use dsx::common::config::DsxConfig;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{DATA_DIR, error::ApiError};
|
||||
|
||||
// stored as a Config.toml above the repository root.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct PackageMeta {
|
||||
pub id: String,
|
||||
|
||||
#[serde(default)]
|
||||
pub latest_build_date: Option<String>,
|
||||
#[serde(default)]
|
||||
pub latest_build_status: Option<String>,
|
||||
#[serde(default)]
|
||||
pub latest_build_id: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct Package {
|
||||
pub config: DsxConfig,
|
||||
pub meta: PackageMeta,
|
||||
pub files: Vec<FileObj>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct FileObj {
|
||||
pub name: String,
|
||||
pub path: String,
|
||||
pub is_dir: bool,
|
||||
pub size: u64,
|
||||
pub extension: String,
|
||||
}
|
||||
|
||||
impl Package {
|
||||
pub fn load(name: &str) -> Result<Self, ApiError> {
|
||||
let repo_path = DATA_DIR.join("repos").join(name);
|
||||
|
||||
let config_contents = fs::read_to_string(repo_path.join("repo/Dsx.toml"))
|
||||
.map_err(|e| {
|
||||
warn!("unable to read config for repo, {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
let config: DsxConfig = toml::from_str(&config_contents).map_err(|e| {
|
||||
warn!("Invalid config file for repo! {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
let meta_contents =
|
||||
fs::read_to_string(repo_path.join("Package.toml")).map_err(|e| {
|
||||
warn!("unable to read config for repo, {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
let meta: PackageMeta = toml::from_str(&meta_contents).map_err(|e| {
|
||||
warn!("Invalid meta file for repo! {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
let dir = fs::read_dir(repo_path.join("repo")).map_err(|e| {
|
||||
warn!("unable to read files for repo, {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
let mut files = Vec::new();
|
||||
for entry in dir {
|
||||
let entry = entry.map_err(|e| {
|
||||
warn!("unable to read file entry for repo, {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
let path = entry.path();
|
||||
let metadata = fs::metadata(&path).map_err(|e| {
|
||||
warn!("unable to read file metadata for repo, {e}");
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
let is_dir = metadata.is_dir();
|
||||
let size = metadata.len();
|
||||
let extension = path
|
||||
.extension()
|
||||
.map_or(String::new(), |ext| ext.to_string_lossy().to_string());
|
||||
files.push(FileObj {
|
||||
path: path.to_string_lossy().to_string(),
|
||||
name: path.file_name().unwrap().to_string_lossy().to_string(),
|
||||
is_dir,
|
||||
size,
|
||||
extension,
|
||||
});
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
config,
|
||||
meta,
|
||||
files,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn unpack(archive: &std::path::Path) -> Result<Self, ApiError> {
|
||||
let repo_name = archive.file_name().unwrap().to_str().unwrap();
|
||||
let dest = DATA_DIR.join("repos").join(repo_name).join("repo");
|
||||
unpack_tarball(archive, &dest)?;
|
||||
let package = Self::load(repo_name)?;
|
||||
Ok(package)
|
||||
}
|
||||
|
||||
pub fn tarball(&self) -> Result<Vec<u8>, ApiError> {
|
||||
let src_dir = self.path().join("repo");
|
||||
pack_tarball(&src_dir)
|
||||
}
|
||||
|
||||
pub fn path(&self) -> PathBuf {
|
||||
DATA_DIR.join("repos").join(&self.meta.id)
|
||||
}
|
||||
}
|
||||
|
||||
// ── Tar helpers ───────────────────────────────────────────────────────────────
|
||||
|
||||
use flate2::read::GzDecoder;
|
||||
use flate2::{Compression, write::GzEncoder};
|
||||
use std::fs::File;
|
||||
use tar::Builder;
|
||||
|
||||
fn unpack_tarball(
|
||||
archive: &std::path::Path,
|
||||
dest: &std::path::Path,
|
||||
) -> Result<(), ApiError> {
|
||||
let file = File::open(archive)?;
|
||||
let gz = GzDecoder::new(file);
|
||||
let mut tar = tar::Archive::new(gz);
|
||||
tar.unpack(dest)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn pack_tarball(src_dir: &std::path::Path) -> Result<Vec<u8>, ApiError> {
|
||||
let buf = Vec::new();
|
||||
let gz = GzEncoder::new(buf, Compression::default());
|
||||
let mut tar = Builder::new(gz);
|
||||
tar.append_dir_all(".", src_dir)?;
|
||||
let gz = tar.into_inner()?;
|
||||
Ok(gz.finish()?)
|
||||
}
|
||||
@@ -0,0 +1,270 @@
|
||||
#[macro_use]
|
||||
extern crate rocket;
|
||||
|
||||
use std::fs;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::LazyLock;
|
||||
|
||||
use anyhow::anyhow;
|
||||
use rocket::Data;
|
||||
use rocket::data::ToByteUnit;
|
||||
use rocket::serde::json::Json;
|
||||
use rocket::{fs::FileServer, serde::Deserialize};
|
||||
|
||||
use rocket_dyn_templates::{Template, context};
|
||||
|
||||
use dotenv::dotenv;
|
||||
use serde::Serialize;
|
||||
use tracing::{info, warn};
|
||||
|
||||
use crate::error::ApiError;
|
||||
use crate::model::{Package, PackageMeta};
|
||||
use dsx::common::config::DsxConfig;
|
||||
|
||||
mod error;
|
||||
mod model;
|
||||
|
||||
static DATA_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
|
||||
PathBuf::from(std::env::var("$DATA_DIR").unwrap_or("./data".to_string()))
|
||||
});
|
||||
|
||||
// Search for a package
|
||||
#[get("/?<q>")]
|
||||
fn search_packages(q: Option<String>) -> Result<Template, ApiError> {
|
||||
#[derive(Serialize)]
|
||||
struct Package {
|
||||
name: String,
|
||||
description: String,
|
||||
updated_at: String,
|
||||
}
|
||||
|
||||
let mut packages = Vec::new();
|
||||
|
||||
let dir = match fs::read_dir(DATA_DIR.join("repos")) {
|
||||
Ok(dir) => dir,
|
||||
Err(e) => {
|
||||
warn!("failed to read repos directory: {}", e);
|
||||
return Err(ApiError::InternalServerError(()));
|
||||
}
|
||||
};
|
||||
|
||||
for entry in dir {
|
||||
let entry = entry.map_err(|e| {
|
||||
warn!("failed to read entry: {}", e);
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
let config_path = entry.path().join("repo").join("Dsx.toml");
|
||||
if config_path.exists() {
|
||||
let text = fs::read_to_string(&config_path).map_err(|e| {
|
||||
warn!("failed to read config file: {}", e);
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
let config: DsxConfig = toml::from_str(&text).map_err(|e| {
|
||||
warn!("failed to parse config file: {}", e);
|
||||
ApiError::InternalServerError(())
|
||||
})?;
|
||||
|
||||
error!("{}", config.description.clone().unwrap_or_default());
|
||||
|
||||
// skip repo if it doesnt match query params
|
||||
if let Some(query) = &q
|
||||
&& !(config.name.contains(query)
|
||||
|| config
|
||||
.description
|
||||
.clone()
|
||||
.unwrap_or_default()
|
||||
.contains(query))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
packages.push(Package {
|
||||
name: config.name,
|
||||
description: config.description.unwrap_or_default(),
|
||||
updated_at: String::from("0:00"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Template::render(
|
||||
"packages",
|
||||
context! {
|
||||
packages,
|
||||
query: q.clone().unwrap_or_default()
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
// Main page for a repository, shows status, files, name etc.
|
||||
#[get("/<name>")]
|
||||
fn package_main(name: &str) -> Result<Template, ApiError> {
|
||||
// get package info
|
||||
let package = Package::load(name)?;
|
||||
|
||||
println!("{}", package.config.name);
|
||||
|
||||
Ok(Template::render(
|
||||
"package_home",
|
||||
context! {
|
||||
parent_path: String::new(),
|
||||
current_path: String::from("/"),
|
||||
package: package,
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
// Path for a file within a repo
|
||||
#[get("/<name>/~repo/<path..>")]
|
||||
fn repo_file(name: &str, path: std::path::PathBuf) -> Result<Template, ApiError> {
|
||||
let package = Package::load(name)?;
|
||||
|
||||
Ok(Template::render(
|
||||
"file",
|
||||
context! {
|
||||
package: package,
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
// Search within a package's files
|
||||
#[get("/<name>/~repo?<q>")]
|
||||
fn search_repo_files(name: &str, q: Option<String>) -> String {
|
||||
format!("Search within {} for {:?}", name, q)
|
||||
}
|
||||
|
||||
// Page listing repo artifacts by date
|
||||
#[get("/<name>/artifacts")]
|
||||
fn list_artifacts(name: &str) -> String {
|
||||
format!("Artifacts for package {}", name)
|
||||
}
|
||||
|
||||
// Page for a specific artifact and status/logs
|
||||
#[get("/<name>/artifacts/<id>")]
|
||||
fn artifact_detail(name: &str, id: u64) -> String {
|
||||
format!("Artifact {} details for package {}", id, name)
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(crate = "rocket::serde")]
|
||||
struct NewRepo<'r> {
|
||||
name: &'r str,
|
||||
}
|
||||
|
||||
// Create repo
|
||||
#[post("/pkg", data = "<repo>")]
|
||||
fn create_repo(repo: Json<NewRepo<'_>>) -> Result<(), &'static str> {
|
||||
let path = DATA_DIR.join("repos").join(repo.name);
|
||||
|
||||
if repo.name.is_empty() {
|
||||
return Err("Repository name cannot be empty!");
|
||||
}
|
||||
|
||||
if path.exists() {
|
||||
tracing::info!(
|
||||
"Attempt to create repository '{}' which already exists.",
|
||||
repo.name
|
||||
);
|
||||
return Err("This repository already exists!");
|
||||
}
|
||||
|
||||
if let Err(e) = fs::create_dir_all(path) {
|
||||
tracing::error!(
|
||||
"Attempted to create package with name {} - Error: {e},",
|
||||
repo.name
|
||||
);
|
||||
return Err("Internal server error");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Repo status/metadata
|
||||
#[get("/pkg/<name>")]
|
||||
fn get_pkg(name: &str) -> Result<Json<(PackageMeta, DsxConfig)>, ApiError> {
|
||||
let package = Package::load(name).map_err(|e| {
|
||||
ApiError::NotFound(String::from("repo with name {name} does not exist"))
|
||||
})?;
|
||||
|
||||
Ok(Json((package.meta, package.config)))
|
||||
}
|
||||
|
||||
// Upload source tarball
|
||||
#[post("/pkg/<name>/push", data = "<data>")]
|
||||
async fn push_tarball(name: &str, data: Data<'_>) -> Result<(), ApiError> {
|
||||
let repo_dir = DATA_DIR.join("repos").join(name);
|
||||
let tmp_path = repo_dir.join("upload.tar.gz");
|
||||
let stream = data
|
||||
.open(256.mebibytes())
|
||||
.into_file(&tmp_path)
|
||||
.await
|
||||
.map_err(|e| ApiError::InternalServerError(()))?;
|
||||
|
||||
if !stream.is_complete() {
|
||||
return Err(ApiError::BadRequest("Incomplete upload".to_string()));
|
||||
}
|
||||
|
||||
// Unpack over the existing repo dir.
|
||||
if repo_dir.exists() {
|
||||
fs::remove_dir_all(&repo_dir).map_err(|e| ApiError::InternalServerError(()))?;
|
||||
}
|
||||
fs::create_dir_all(&repo_dir).map_err(|e| ApiError::InternalServerError(()))?;
|
||||
|
||||
let _ = Package::unpack(&tmp_path)?;
|
||||
fs::remove_file(&tmp_path).ok();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Download source tarball
|
||||
#[get("/pkg/<name>/pull")]
|
||||
fn pull_tarball(
|
||||
name: &str,
|
||||
) -> Result<(rocket::http::ContentType, Vec<u8>), Json<ApiError>> {
|
||||
if let Ok(package) = Package::load(name) {
|
||||
let tarball = package.tarball()?;
|
||||
Ok((
|
||||
rocket::http::ContentType::new("application", "octet-stream"),
|
||||
tarball,
|
||||
))
|
||||
} else {
|
||||
Err(Json(ApiError::NotFound(format!(
|
||||
"repo with name {name} does not exist"
|
||||
))))
|
||||
}
|
||||
}
|
||||
|
||||
// Download compiled binary
|
||||
#[get("/pkg/<name>/artifact")]
|
||||
fn download_artifact(name: &str) -> &'static str {
|
||||
"Download artifact"
|
||||
}
|
||||
|
||||
#[launch]
|
||||
fn rocket() -> _ {
|
||||
dotenv().unwrap();
|
||||
|
||||
rocket::build()
|
||||
.mount(
|
||||
"/packages",
|
||||
routes![
|
||||
search_packages,
|
||||
package_main,
|
||||
repo_file,
|
||||
search_repo_files,
|
||||
list_artifacts,
|
||||
artifact_detail,
|
||||
],
|
||||
)
|
||||
.mount(
|
||||
"/api",
|
||||
routes![
|
||||
create_repo,
|
||||
get_pkg,
|
||||
push_tarball,
|
||||
pull_tarball,
|
||||
download_artifact
|
||||
],
|
||||
)
|
||||
.attach(Template::fairing())
|
||||
.mount("/static", FileServer::from("./static"))
|
||||
}
|
||||
Reference in New Issue
Block a user