restructuring igloo majorly. im simplifying the hierarchy for now and will improve it later. learning rust is a weird tree of unknowns is hard. this should make development faster for now
parent
3f638f6475
commit
d33f842166
@ -1,10 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "igloo_base"
|
|
||||||
version = "0.1.0"
|
|
||||||
authors = ["Penguin <penguin@epenguin.net>"]
|
|
||||||
edition = "2018"
|
|
||||||
|
|
||||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
directories = "3.0.1"
|
|
||||||
@ -1,128 +0,0 @@
|
|||||||
use std::path::PathBuf;
|
|
||||||
use std::env;
|
|
||||||
use directories::*;
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
#[test]
|
|
||||||
fn it_works() {
|
|
||||||
assert_eq!(2 + 2, 4);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// #[macro_export]
|
|
||||||
// macro_rules! igloo_println
|
|
||||||
// {
|
|
||||||
|
|
||||||
// }
|
|
||||||
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
#[derive(PartialEq)]
|
|
||||||
pub enum IglooInstType
|
|
||||||
{
|
|
||||||
Null = -1,
|
|
||||||
New = 0,
|
|
||||||
Run = 1,
|
|
||||||
Push = 2,
|
|
||||||
Pull = 3,
|
|
||||||
Debug = 4,
|
|
||||||
Clean = 5,
|
|
||||||
Erase = 6,
|
|
||||||
GenDoc = 7,
|
|
||||||
Info = 8,
|
|
||||||
Target = 9,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
#[derive(PartialEq)]
|
|
||||||
pub enum IglooDebugSeverity
|
|
||||||
{
|
|
||||||
CRITICAL = 0,
|
|
||||||
WARNING = 1,
|
|
||||||
INFO = 2,
|
|
||||||
TRACE = 3,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
#[derive(PartialEq)]
|
|
||||||
/// Igloo Error Type
|
|
||||||
pub enum IglooErrType
|
|
||||||
{
|
|
||||||
ErrNone = 0,
|
|
||||||
ErrUnknown = 1,
|
|
||||||
ConfigNotFound = 2,
|
|
||||||
ConfigFound = 3,
|
|
||||||
UnknownInstType = 4,
|
|
||||||
NewCalledInsideProject = 5,
|
|
||||||
FolderAlreadyExists = 6,
|
|
||||||
InvalidProjectName = 7,
|
|
||||||
InvalidEnvInfo = 8,
|
|
||||||
InvalidTarget = 9,
|
|
||||||
/// Failed to load ePenguin Make Manifest
|
|
||||||
/// This means igloo couldn't find the master
|
|
||||||
/// make manifest
|
|
||||||
FailedToLoadMasterMakeManifest = 10,
|
|
||||||
/// Failed to load ePenguin Target Manifest
|
|
||||||
/// This means igloo couldn't find the master
|
|
||||||
/// target manifest
|
|
||||||
FailedToLoadMasterTargetManifest = 11,
|
|
||||||
/// This means igloo couldn't find the scripts dir
|
|
||||||
/// which should be located within a target directory
|
|
||||||
/// It should be impossible for igloo to generate a target
|
|
||||||
/// inside a project without also generating a scripts directory.
|
|
||||||
/// The likely culprit of this failure is a user has messed with the folder
|
|
||||||
FailedToFindTargetScriptsDir = 12,
|
|
||||||
ActionCalledOutsideProject = 13,
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
#[derive(PartialEq)]
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct IglooEnvInfo
|
|
||||||
{
|
|
||||||
// Current Working Directory
|
|
||||||
pub cwd: PathBuf,
|
|
||||||
// Home Directory
|
|
||||||
pub hd: PathBuf,
|
|
||||||
// ESF Directory
|
|
||||||
pub esfd: PathBuf,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl IglooEnvInfo
|
|
||||||
{
|
|
||||||
/// Returns the environment information for the igloo call
|
|
||||||
pub fn get_env_info() -> IglooEnvInfo
|
|
||||||
{
|
|
||||||
IglooEnvInfo
|
|
||||||
{
|
|
||||||
cwd: env::current_dir().unwrap(),
|
|
||||||
hd: match UserDirs::new()
|
|
||||||
{
|
|
||||||
Some(v) => v.home_dir().to_owned(),
|
|
||||||
None =>
|
|
||||||
{
|
|
||||||
println!("Error: Failed to get home directory.\n\
|
|
||||||
This should never happen. Exiting...");
|
|
||||||
std::process::exit(1);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
esfd: match std::env::var("ESF_DIR")
|
|
||||||
{
|
|
||||||
Ok(v) =>
|
|
||||||
{
|
|
||||||
std::path::PathBuf::from(&v.to_owned())
|
|
||||||
}
|
|
||||||
Err(e) =>
|
|
||||||
{
|
|
||||||
// Note: Need to change new to return errors
|
|
||||||
// instead of exiting early
|
|
||||||
println!("Error: $ESF_DIR not defined as an environment\
|
|
||||||
variable -- {:?}", e);
|
|
||||||
std::process::exit(1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,12 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "igloo_cli"
|
|
||||||
version = "0.1.0"
|
|
||||||
authors = ["Penguin <penguin@epenguin.net>"]
|
|
||||||
edition = "2018"
|
|
||||||
|
|
||||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
igloo_base = { path = "../igloo_base" }
|
|
||||||
clap = "3.0.0-beta.2"
|
|
||||||
config = "0.10"
|
|
||||||
@ -1,58 +0,0 @@
|
|||||||
use igloo_base::*;
|
|
||||||
use igloo_base::IglooErrType::*;
|
|
||||||
|
|
||||||
use crate::Igloo;
|
|
||||||
use crate::igloo_project::IglooPrj;
|
|
||||||
|
|
||||||
pub fn iac_run(prj_name: &str, target: &str) -> IglooErrType
|
|
||||||
{
|
|
||||||
let res_err: IglooErrType = ErrNone;
|
|
||||||
res_err
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn new(inst: &Igloo, prj_name: &str, target: &str)
|
|
||||||
-> IglooErrType
|
|
||||||
{
|
|
||||||
let mut res_err: IglooErrType = ErrNone;
|
|
||||||
// Check if we are already inside of an igloo project
|
|
||||||
// Creating an igloo project inside an igloo project
|
|
||||||
// is a no no
|
|
||||||
if IglooPrj::is_igloo_prj(&std::env::current_dir().unwrap())
|
|
||||||
{
|
|
||||||
println!("Calling igloo new from igloo project...");
|
|
||||||
res_err = NewCalledInsideProject;
|
|
||||||
return res_err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the project folder already exists
|
|
||||||
// Don't want to accidentally overwrite anything
|
|
||||||
if std::path::Path::new(prj_name).exists()
|
|
||||||
{
|
|
||||||
res_err = FolderAlreadyExists;
|
|
||||||
return res_err
|
|
||||||
}
|
|
||||||
|
|
||||||
let project = IglooPrj::new(inst, prj_name, target);
|
|
||||||
match project
|
|
||||||
{
|
|
||||||
Err(e) =>
|
|
||||||
{
|
|
||||||
println!("Error spawning project: {:?}", e);
|
|
||||||
res_err = e;
|
|
||||||
return res_err
|
|
||||||
}
|
|
||||||
_ => (),
|
|
||||||
}
|
|
||||||
|
|
||||||
let res_err = project.unwrap().populate();
|
|
||||||
if res_err != ErrNone
|
|
||||||
{
|
|
||||||
return res_err
|
|
||||||
}
|
|
||||||
res_err
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn push(inst: &Igloo)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,207 +0,0 @@
|
|||||||
use igloo_base::*;
|
|
||||||
use igloo_base::IglooErrType::*;
|
|
||||||
|
|
||||||
use crate::IglooPrj;
|
|
||||||
use crate::Igloo;
|
|
||||||
|
|
||||||
use crate::config::Config;
|
|
||||||
use std::collections::HashMap;
|
|
||||||
use std::path::PathBuf;
|
|
||||||
use std::fs::OpenOptions;
|
|
||||||
use std::fs::File;
|
|
||||||
use std::io::prelude::*;
|
|
||||||
|
|
||||||
pub struct IglooTarget
|
|
||||||
{
|
|
||||||
// name, links, and includes are extracted from a manifest
|
|
||||||
pub name: String,
|
|
||||||
pub links: HashMap<String, config::Value>,
|
|
||||||
pub includes: Vec<config::Value>,
|
|
||||||
pub openocd: HashMap<String, config::Value>,
|
|
||||||
pub make_manifest: HashMap<String, config::Value>,
|
|
||||||
pub root: PathBuf,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl IglooTarget
|
|
||||||
{
|
|
||||||
pub fn default() -> IglooTarget
|
|
||||||
{
|
|
||||||
IglooTarget
|
|
||||||
{
|
|
||||||
name: String::from(""),
|
|
||||||
root: PathBuf::default(),
|
|
||||||
make_manifest: HashMap::default(),
|
|
||||||
links: HashMap::default(),
|
|
||||||
includes: Vec::default(),
|
|
||||||
openocd: HashMap::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn from(root: PathBuf, inst: &Igloo, name_in: String,
|
|
||||||
target_make_loc: &str,
|
|
||||||
target_man_loc: &str) -> Result<IglooTarget, IglooErrType>
|
|
||||||
{
|
|
||||||
// target man first
|
|
||||||
let mut target_man = Config::new();
|
|
||||||
target_man.merge(
|
|
||||||
config::File::with_name(
|
|
||||||
IglooEnvInfo::get_env_info().esfd.join(target_man_loc)
|
|
||||||
.to_str().unwrap()))
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
// now make man
|
|
||||||
let mut makefile: HashMap<String, config::Value> = HashMap::new();
|
|
||||||
let mut make_table_head = &target_make_loc[0..target_make_loc.len()];
|
|
||||||
let mut b_quit: bool = false;
|
|
||||||
loop
|
|
||||||
{
|
|
||||||
let mut _active_table = inst.master_make_man.get_table(&make_table_head).unwrap();
|
|
||||||
for (name, val) in _active_table
|
|
||||||
{
|
|
||||||
match val.clone().into_table()
|
|
||||||
{
|
|
||||||
Err(_e) =>
|
|
||||||
{
|
|
||||||
if !makefile.contains_key(&name)
|
|
||||||
{
|
|
||||||
makefile.insert(name, val);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
let mut newval = val.clone().into_array().unwrap();
|
|
||||||
let mut newvec = makefile.get_key_value(&name).unwrap().1.clone().into_array().unwrap();
|
|
||||||
newvec.append(&mut newval);
|
|
||||||
makefile.insert(name, config::Value::from(newvec));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(_v) => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
match make_table_head.rfind('.')
|
|
||||||
{
|
|
||||||
None => b_quit = true,
|
|
||||||
Some(v) => make_table_head = &make_table_head[0..v],
|
|
||||||
}
|
|
||||||
if b_quit
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(IglooTarget
|
|
||||||
{
|
|
||||||
name: String::from(name_in),
|
|
||||||
make_manifest: makefile,
|
|
||||||
links: target_man.get_table("esf.links").unwrap(),
|
|
||||||
includes: target_man.get_table("esf.includes")
|
|
||||||
.unwrap()
|
|
||||||
.get("IGLOO_INCLUDES")
|
|
||||||
.unwrap()
|
|
||||||
.clone()
|
|
||||||
.into_array()
|
|
||||||
.unwrap(),
|
|
||||||
openocd: target_man.get_table("esf.openocd")
|
|
||||||
.unwrap(),
|
|
||||||
root: root,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
/// generate all folders needed for the target
|
|
||||||
pub fn generate(&self) -> IglooErrType
|
|
||||||
{
|
|
||||||
// Create target root directory
|
|
||||||
match std::fs::create_dir(&self.root)
|
|
||||||
{
|
|
||||||
Err(e) => println!("{:?}", e),
|
|
||||||
_ => (),
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create target scripts directory
|
|
||||||
match std::fs::create_dir(&self.root.join("scripts"))
|
|
||||||
{
|
|
||||||
Err(e) => println!("{:?}", e),
|
|
||||||
_ => (),
|
|
||||||
}
|
|
||||||
|
|
||||||
ErrNone
|
|
||||||
}
|
|
||||||
|
|
||||||
/// populates all folders needed for the target
|
|
||||||
pub fn populate(&self) -> IglooErrType
|
|
||||||
{
|
|
||||||
let mut target_scripts_dir: PathBuf = PathBuf::from(
|
|
||||||
self.root.join("scripts"));
|
|
||||||
// Read the gdb scripts directory in ESF
|
|
||||||
let esf_target_scripts_dir = std::fs::read_dir(
|
|
||||||
&(String::from(
|
|
||||||
IglooEnvInfo::get_env_info()
|
|
||||||
.esfd.to_str()
|
|
||||||
.unwrap()) + "/scripts"))
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
// Creating a vector to hold our gdb script file names
|
|
||||||
let mut gdb_scripts: std::vec::Vec<std::path::PathBuf>
|
|
||||||
= std::vec::Vec::new();
|
|
||||||
|
|
||||||
// Grab the files only
|
|
||||||
for entry in esf_target_scripts_dir
|
|
||||||
{
|
|
||||||
match &entry
|
|
||||||
{
|
|
||||||
Ok(v) => if !v.path().is_dir() {
|
|
||||||
gdb_scripts.push(v.path()) },
|
|
||||||
Err(e) => println!("{:?}", e),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Generate each GDB script
|
|
||||||
for file in gdb_scripts
|
|
||||||
{
|
|
||||||
std::os::unix::fs::symlink(
|
|
||||||
&file, &target_scripts_dir.join(&file.file_name().unwrap())).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Populate the project ESF folder with our targets relevant files
|
|
||||||
let mut prj_esf_dir = self.root
|
|
||||||
.parent().unwrap()
|
|
||||||
.parent().unwrap()
|
|
||||||
.parent().unwrap().join("ESF");
|
|
||||||
println!("PRINTING {:?}", prj_esf_dir);
|
|
||||||
for (sym_dir, loc_in_esf) in &self.links
|
|
||||||
{
|
|
||||||
let link_to_dir = IglooEnvInfo::get_env_info()
|
|
||||||
.esfd
|
|
||||||
.join(&loc_in_esf.clone().into_str().unwrap());
|
|
||||||
std::os::unix::fs::symlink(link_to_dir, prj_esf_dir.join(sym_dir)).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
ErrNone
|
|
||||||
}
|
|
||||||
|
|
||||||
/// generates the makefile for a target
|
|
||||||
/// this will be updated as the user edits their project toml
|
|
||||||
pub fn generate_makefile(&self) -> IglooErrType
|
|
||||||
{
|
|
||||||
ErrNone
|
|
||||||
}
|
|
||||||
|
|
||||||
/// generates the openocd config for a target
|
|
||||||
/// this will be updated as the user edits their project toml
|
|
||||||
pub fn generate_openocd_config(&self) -> IglooErrType
|
|
||||||
{
|
|
||||||
let mut fromPath = IglooEnvInfo::get_env_info()
|
|
||||||
.esfd.join(self.openocd.get("scripts")
|
|
||||||
.unwrap()
|
|
||||||
.clone()
|
|
||||||
.into_str()
|
|
||||||
.unwrap())
|
|
||||||
.join(&self.name).with_extension("cfg");
|
|
||||||
|
|
||||||
let mut toPath = self.root.join("scripts")
|
|
||||||
.join(&self.name).with_extension("cfg");
|
|
||||||
|
|
||||||
std::fs::copy(&fromPath, &toPath).unwrap();
|
|
||||||
ErrNone
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,156 +1,60 @@
|
|||||||
#![allow(warnings)]
|
|
||||||
extern crate clap;
|
extern crate clap;
|
||||||
extern crate config;
|
extern crate config;
|
||||||
|
|
||||||
/// Igloo Core
|
|
||||||
|
|
||||||
mod igloo_action;
|
mod igloo_action;
|
||||||
mod igloo_project;
|
mod igloo_project;
|
||||||
pub mod igloo_target;
|
mod igloo_target;
|
||||||
|
mod igloo_manifest;
|
||||||
use igloo_base::*;
|
mod igloo_cli;
|
||||||
use igloo_base::IglooInstType::*;
|
|
||||||
use igloo_base::IglooErrType::*;
|
|
||||||
use igloo_cli::*;
|
|
||||||
use igloo_manifest::*;
|
|
||||||
use igloo_project::IglooPrj;
|
|
||||||
|
|
||||||
use config::Config;
|
pub enum IglooType
|
||||||
#[cfg(test)]
|
{
|
||||||
mod tests {
|
IT_NEW = 0,
|
||||||
#[test]
|
IT_RUN,
|
||||||
fn it_works() {
|
IT_PUSH,
|
||||||
assert_eq!(2 + 2, 4);
|
IT_PULL,
|
||||||
|
IT_HELP,
|
||||||
|
IT_BUILD,
|
||||||
|
IT_NULL,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub enum IglooStatus
|
||||||
|
{
|
||||||
|
IS_GOOD = 0x00,
|
||||||
|
IS_BAD = 0x01,
|
||||||
|
IS_UNKNOWN = 0x02,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Igloo should contain a config and any important environment information.
|
|
||||||
/// Upon running igloo, an instanc is created, env information is stored, and then
|
|
||||||
/// things happen.
|
|
||||||
pub struct Igloo
|
pub struct Igloo
|
||||||
{
|
{
|
||||||
cli_conf: IglooCliConfig,
|
cli_conf: IglooCliConfig,
|
||||||
master_target_man: Config,
|
master_target_manifest: Config,
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Igloo
|
impl Igloo
|
||||||
{
|
{
|
||||||
/// The new function creates an instance of igloo. The idea is I create an igloo,
|
|
||||||
/// run start on it so I can collect environment information and process what command
|
|
||||||
/// the user would like to run, and then I run that command or deal with errors.
|
|
||||||
///
|
|
||||||
/// This function handles all cli input and stores it. It is parsed for errors in the
|
|
||||||
/// start function.
|
|
||||||
pub fn new() -> Self
|
pub fn new() -> Self
|
||||||
{
|
{
|
||||||
Igloo
|
Igloo
|
||||||
{
|
{
|
||||||
master_target_man: Config::new(),
|
master_target_manifest: Config::new(),
|
||||||
cli_conf: IglooCliConfig::new(),
|
cli_conf: IglooCliConfig::new(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The start function processes the command you want igloo to run
|
|
||||||
/// It theoretically should never return an error. It should just exit.
|
|
||||||
/// If an error was returned, It was my fault and not the users.
|
|
||||||
/// It is really only here to help me debug.
|
|
||||||
///
|
|
||||||
/// The Inst Type is only returned for usage outside of this struct.
|
|
||||||
pub fn start(&mut self) -> Result<IglooInstType, IglooErrType>
|
pub fn start(&mut self) -> Result<IglooInstType, IglooErrType>
|
||||||
{
|
{
|
||||||
let mut res: IglooInstType = Null;
|
let mut res: IglooInstType = Null;
|
||||||
match IglooManifest::get_master_target_manifest(&mut self.master_target_man)
|
|
||||||
{
|
|
||||||
ErrNone => (),
|
|
||||||
v =>
|
|
||||||
{
|
|
||||||
println!("{:?}", v);
|
|
||||||
return Err(v)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
// Assign our instance type (new, run, flash, etc..)
|
|
||||||
match igloo_subcommand(&self.cli_conf.raw)
|
|
||||||
{
|
|
||||||
Ok(v) => res = v,
|
|
||||||
Err(e) => return Err(e),
|
|
||||||
}
|
|
||||||
|
|
||||||
if res == Null
|
|
||||||
{
|
|
||||||
return Err(ErrUnknown)
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(res)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The run function processes the request from the user.
|
|
||||||
/// On success, it will give some string indicating the success of the operation.
|
|
||||||
/// On failure, it will return some error type.
|
|
||||||
pub fn run(&self, inst_type: IglooInstType) -> Result<String, IglooErrType>
|
|
||||||
{
|
|
||||||
let mut res_err = ErrNone;
|
|
||||||
let mut prj: IglooPrj;
|
|
||||||
loop { match inst_type
|
|
||||||
{
|
|
||||||
Null => res_err = ErrNone,
|
|
||||||
New =>
|
|
||||||
{
|
|
||||||
let prj_name: &str = self
|
|
||||||
.cli_conf
|
|
||||||
.raw
|
|
||||||
.subcommand()
|
|
||||||
.unwrap().1
|
|
||||||
.value_of("project_name")
|
|
||||||
.unwrap();
|
|
||||||
let target: &str = self
|
|
||||||
.cli_conf
|
|
||||||
.raw
|
|
||||||
.subcommand()
|
|
||||||
.unwrap().1
|
|
||||||
.value_of("target")
|
|
||||||
.unwrap();
|
|
||||||
let res_err = igloo_action::new(
|
|
||||||
self, prj_name, target);
|
|
||||||
if res_err != ErrNone
|
|
||||||
{
|
|
||||||
return Err(res_err)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Push =>
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
Run =>
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
Info =>
|
|
||||||
{
|
|
||||||
// list current version
|
|
||||||
println!("Igloo Version: {0}.{1}.{2}\n",
|
|
||||||
self.cli_conf.version_major,
|
|
||||||
self.cli_conf.version_minor,
|
|
||||||
self.cli_conf.version_patch);
|
|
||||||
// list esf version
|
|
||||||
// list supported mcus
|
|
||||||
|
|
||||||
// if we're in a project, list the project info
|
// Tests
|
||||||
// list targets/boards
|
#[cfg (test)]
|
||||||
println!("Info in run handler");
|
mod tests {
|
||||||
}
|
#[test]
|
||||||
Target =>
|
fn it_works() {
|
||||||
{
|
let result = 2 + 2;
|
||||||
}
|
assert_eq!(result, 4);
|
||||||
_ => println!("Unhandled case: {:?}", inst_type),
|
|
||||||
} break; }
|
|
||||||
if res_err == ErrNone
|
|
||||||
{
|
|
||||||
Ok(String::from("We won!"))
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
Err(res_err)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@ -1,12 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "igloo_manifest"
|
|
||||||
version = "0.1.0"
|
|
||||||
authors = ["Penguin <penguin@epenguin.net>"]
|
|
||||||
edition = "2018"
|
|
||||||
|
|
||||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
igloo_base = { path = "../igloo_base" }
|
|
||||||
config = "0.10"
|
|
||||||
sscanf = "0.1.2"
|
|
||||||
@ -1 +0,0 @@
|
|||||||
penguin@gpenguin.3110:1639883851
|
|
||||||
@ -1,141 +0,0 @@
|
|||||||
/// Igloo Manifest is a subproject responsible for working with manifests.
|
|
||||||
/// Manifests are anything from config files to giant lists or ... manifests.
|
|
||||||
/// For now, all functionality is going to sit in this lib.rs until I figure out
|
|
||||||
/// how I want to structure manifests
|
|
||||||
extern crate config;
|
|
||||||
extern crate sscanf;
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
#[test]
|
|
||||||
fn it_works() {
|
|
||||||
assert_eq!(2 + 2, 4);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub mod IglooManifest
|
|
||||||
{
|
|
||||||
use igloo_base::*;
|
|
||||||
use igloo_base::IglooErrType::*;
|
|
||||||
use config::Config;
|
|
||||||
|
|
||||||
/// master_mm -- Master Make Manifest
|
|
||||||
/// master_tm -- Master Target Manifest
|
|
||||||
/// name -- name of target
|
|
||||||
pub fn target_is_valid(master_tm: &Config, name: &str)
|
|
||||||
-> Result<bool, IglooErrType>
|
|
||||||
{
|
|
||||||
let mut ret: bool = true;
|
|
||||||
if name.is_empty()
|
|
||||||
{
|
|
||||||
return Err(InvalidTarget)
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut target_man_path: String = String::default();
|
|
||||||
// Confirm the target.make table exists in the master target manifest
|
|
||||||
match master_tm.get_table("target.make")
|
|
||||||
{
|
|
||||||
Ok(v) =>
|
|
||||||
{
|
|
||||||
// Confirm the target exists in the target.make table
|
|
||||||
// What this actually means is make sure we can use the target name
|
|
||||||
// to acquire the target's name in the master make manifest
|
|
||||||
match v.get(name)
|
|
||||||
{
|
|
||||||
Some(v) =>
|
|
||||||
{
|
|
||||||
// Now we've confirmed the target has an entry in the target.make table
|
|
||||||
println!("target.make entry for \"{}\" exists!", v);
|
|
||||||
// store the target's full name for use in the master make manifest later
|
|
||||||
target_man_path = v.to_string();
|
|
||||||
}
|
|
||||||
None =>
|
|
||||||
{
|
|
||||||
// if we've gotten to this point and failed, it simply means the target doesn't have
|
|
||||||
// a full name set in the target.make table. We need this for accessing it's makefile parameters
|
|
||||||
// later, so we'll need to go add that now.
|
|
||||||
println!("target.make entry for \"{}\" does not exist", name);
|
|
||||||
ret = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
Err(e) =>
|
|
||||||
{
|
|
||||||
println!("{:?}", e);
|
|
||||||
return Err(FailedToLoadMasterMakeManifest)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if !ret
|
|
||||||
{
|
|
||||||
return Ok(ret)
|
|
||||||
}
|
|
||||||
|
|
||||||
let target_table = master_tm.get_table("target.manifest");
|
|
||||||
match target_table
|
|
||||||
{
|
|
||||||
Ok(v) =>
|
|
||||||
{
|
|
||||||
match v.get(name)
|
|
||||||
{
|
|
||||||
Some(v) =>
|
|
||||||
{
|
|
||||||
println!("target.manifest entry for \"{}\" exists!", v);
|
|
||||||
}
|
|
||||||
None =>
|
|
||||||
{
|
|
||||||
ret = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Err(e) =>
|
|
||||||
{
|
|
||||||
println!("{:?}", e);
|
|
||||||
return Err(FailedToLoadMasterTargetManifest)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(ret)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Igloo Manifest -- Responsible for all lookups in manifest files
|
|
||||||
pub fn get_master_make_manifest(man: &mut Config) -> IglooErrType
|
|
||||||
{
|
|
||||||
let mut ret: IglooErrType = ErrNone;
|
|
||||||
match man.merge(
|
|
||||||
config::File::with_name(
|
|
||||||
IglooEnvInfo::get_env_info().esfd.join("manifest/make-manifest.toml")
|
|
||||||
.to_str()
|
|
||||||
.unwrap()))
|
|
||||||
{
|
|
||||||
Ok(_v) => (),
|
|
||||||
Err(e) =>
|
|
||||||
{
|
|
||||||
println!("Error: {:?}", e);
|
|
||||||
ret = FailedToLoadMasterMakeManifest;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ret
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn get_master_target_manifest(man: &mut Config) -> IglooErrType
|
|
||||||
{
|
|
||||||
let mut ret: IglooErrType = ErrNone;
|
|
||||||
match man.merge(
|
|
||||||
config::File::with_name(
|
|
||||||
IglooEnvInfo::get_env_info().esfd.join("manifest/target-manifest.toml")
|
|
||||||
.to_str()
|
|
||||||
.unwrap()))
|
|
||||||
{
|
|
||||||
Ok(_v) => (),
|
|
||||||
Err(e) =>
|
|
||||||
{
|
|
||||||
println!("Error: {:?}", e);
|
|
||||||
ret = FailedToLoadMasterTargetManifest;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ret
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Binary file not shown.
Loading…
Reference in New Issue