AbleOS
/
ableos_userland
2
0
Fork 1
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Remove EXI in favor of XML

pull/1/head
Able 2023-04-01 07:52:15 -05:00
parent b3a3378019
commit d8da4f3434
9 changed files with 241 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Cargo.lock generated
View File

@ -107,10 +107,6 @@ dependencies = [
name = "derelict_microarchitecture"
version = "0.1.0"
[[package]]
name = "exi"
version = "0.1.0"
[[package]]
name = "fnv"
version = "1.0.7"
@ -330,12 +326,6 @@ dependencies = [
"versioning",
]
[[package]]
name = "simple_xml_serialize"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f8896c3696f051907ae5e59f0c2d9fb9f7521c29d636e4a1ea4ff0e4e5aac15"
[[package]]
name = "std"
version = "0.1.0"
@ -486,15 +476,12 @@ dependencies = [
]
[[package]]
name = "xml-builder"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "efc4f1a86af7800dfc4056c7833648ea4515ae21502060b5c98114d828f5333b"
name = "xml"
version = "0.1.0"
[[package]]
name = "xml_tests"
version = "0.1.0"
dependencies = [
"simple_xml_serialize",
"xml-builder",
"xml",
]

2
Cargo.toml
View File

@ -18,7 +18,7 @@ members = [
"libraries/audio_interface",
"libraries/clparse",
"libraries/cryptography",
"libraries/exi",
"libraries/xml",
"libraries/locale-maxima",
"libraries/messaging",
"libraries/process",

87
libraries/exi/src/lib.rs
View File

@ -1,87 +0,0 @@
use types::NBitUnsignedInteger;
pub mod types;
pub const EXI_HEADER_START: &str = "$EXI";
pub struct ExiOptions {
// NOTE: Go back to the EXI spec and fix this
pub alignment: u8,
pub compression: bool,
pub strict: bool,
pub fragment: bool,
// https://www.w3.org/TR/exi/#key-preserveOption
pub preserve: bool,
// https://www.w3.org/TR/exi/#key-selfContained
pub self_contained: bool,
// https://www.w3.org/TR/exi/#key-schemaIdOption
pub schema_id: String,
// https://www.w3.org/TR/exi/#key-datatypeRepresentationOption
// NOTE: What possible usecase could you have for changing the representation of data types.
// Touching this will be UB. Cry about it.
pub datatype_representation_map: bool,
// https://www.w3.org/TR/exi/#key-blockSizeOption
pub block_size: NBitUnsignedInteger,
// https://www.w3.org/TR/exi/#key-valueMaxLengthOption
pub value_max_length: NBitUnsignedInteger,
// https://www.w3.org/TR/exi/#key-valuePartitionCapacityOption
pub value_partition_capacity: NBitUnsignedInteger,
// https://www.w3.org/TR/exi/#key-userMetaData
pub user_defined_meta_data: String,
}
pub enum ExiFormatVersion {
PreviewVersion1 = 1_0000,
// The ableOS standard
FinalVersion1 = 0_0000,
FinalVersion15 = 0_1110,
FinalVersion16 = 0_1111_0000,
FinalVersion17 = 0_1111_0001,
}
pub struct ExiHeader {
exi_format: ExiFormatVersion,
exi_options: ExiOptions,
}
pub struct ExiDocument {}
impl ExiDocument {
pub fn new_from_xml(xml_string: String) -> Self {
println!("{}", xml_string);
Self {}
}
}
#[cfg(unix)]
mod unix {
use std::{
fs::{self, File},
io::Read,
path::Path,
};
use crate::ExiDocument;
fn parse_exi_from_file(path: &Path) -> ExiDocument {
let file_contents = fs::read_to_string(path).unwrap();
ExiDocument::new_from_xml(file_contents)
// ExiDocument {}
}
#[test]
fn test_xml_to_exi() {
parse_exi_from_file(Path::new(
"/home/able/Projects/ableos_userland/libraries/exi/assets/sample.xml",
));
}
}

107
libraries/exi/src/types.rs
View File

@ -1,107 +0,0 @@
pub struct List {
pub length: usize,
pub values: Vec<EXITypes>,
}
// https://www.w3.org/TR/exi/#encodingUnsignedInteger
pub struct NBitUnsignedInteger {
pub length: Option<Integer>,
pub bits: Vec<bool>,
}
impl NBitUnsignedInteger {
pub fn new(length: Integer) -> Self {
let c = if length.bits == vec![0] {
None
} else {
Some(length)
};
Self {
length: c,
bits: Vec::new(),
}
}
}
pub struct BinaryBlob {
pub length: Integer,
pub bytes: Vec<u8>,
}
pub struct Decimal {
pub lhs: UnsignedInteger,
pub rhs: UnsignedInteger,
}
pub enum EXITypes {
Binary(BinaryBlob),
Boolean(bool),
Decimal(Decimal),
Float(f64),
Integer(Integer),
UnsignedInteger(UnsignedInteger),
QName(String),
DateTime(DateTime),
NBitUnsignedInteger(NBitUnsignedInteger),
String(String),
List(List),
}
pub struct DateTime {
pub year: Integer,
pub month_day: NBitUnsignedInteger,
pub time: NBitUnsignedInteger,
pub fractional_secs: NBitUnsignedInteger,
pub timezone: NBitUnsignedInteger,
pub presence: bool,
}
impl DateTime {
pub fn new() -> Self {
Self {
year: Integer::new(),
month_day: NBitUnsignedInteger::new(9.into()),
time: NBitUnsignedInteger::new(17.into()),
fractional_secs: NBitUnsignedInteger::new(9.into()),
timezone: NBitUnsignedInteger::new(11.into()),
presence: false,
}
}
}
pub struct Integer {
pub negative: bool,
pub bits: Vec<u8>,
}
impl Integer {
pub fn new() -> Self {
Self {
negative: false,
bits: vec![0],
}
}
}
impl From<i8> for Integer {
fn from(value: i8) -> Self {
Self {
negative: value.is_negative(),
bits: value.abs().to_le_bytes().to_vec(),
}
}
}
pub struct UnsignedInteger {
pub bits: Vec<u8>,
}
impl UnsignedInteger {
pub fn new() -> Self {
Self { bits: vec![0] }
}
}
impl From<i8> for UnsignedInteger {
fn from(value: i8) -> Self {
Self {
bits: value.abs().to_le_bytes().to_vec(),
}
}
}

2
libraries/exi/Cargo.toml → libraries/xml/Cargo.toml
View File

@ -1,5 +1,5 @@
[package]
name = "exi"
name = "xml"
version = "0.1.0"
edition = "2021"

0
libraries/exi/assets/sample.xml → libraries/xml/assets/sample.xml
View File

232
libraries/xml/src/lib.rs Normal file
View File

@ -0,0 +1,232 @@
use core::fmt::{Debug, Display};
#[derive(PartialEq, Clone)]
pub struct Attribute {
name: String,
value: String,
}
impl Attribute {
fn to_string(&self) -> String {
format!("{:?}={:?}", self.name, self.value)
}
}
#[derive(Clone)]
// TODO Add an autotype attribute that defaults to true
pub struct XMLElement {
pub name: String,
pub text: String,
pub attributes: Vec<Attribute>,
pub children: Vec<XMLElement>,
}
impl XMLElement {
pub fn new<T: Display + Debug>(name: T) -> Self {
Self {
name: name.to_string(),
text: String::new(),
attributes: vec![],
children: vec![],
}
}
pub fn to_string(self) -> String {
self.into()
}
pub fn set_child(&mut self, child: XMLElement) {
// TODO: handle replacing preexisting children
if child.name == "".to_string() {
panic!("empty element name")
}
self.children.push(child);
}
pub fn set_attribute<T1: Display + Debug, T2: Display + Debug>(&mut self, name: T1, value: T2) {
let new_attr = Attribute {
name: name.to_string(),
value: value.to_string(),
};
let mut duplicate_attribute = (false, 0);
for (index, attr) in self.attributes.clone().into_iter().enumerate() {
if attr.name == name.to_string() {
duplicate_attribute = (true, index);
break;
}
}
match duplicate_attribute {
(false, _) => {
self.attributes.push(new_attr.clone());
}
(true, index) => {
self.attributes[index] = new_attr.clone();
}
}
}
}
impl Into<String> for XMLElement {
fn into(self) -> String {
let mut string = "".to_string();
let element_open: String = format!("<{}", self.name);
string.push_str(&element_open);
if self.attributes.len() > 0 {
string.push(' ');
}
let mut attr_count = 0;
for attr in &self.attributes {
string.push_str(&attr.to_string());
attr_count += 1;
if &attr_count != &self.attributes.len() {
string.push(' ');
}
}
string.push('>');
string.push_str(&self.text);
for children in &self.children.clone() {
let chl: String = (*children).clone().into();
string.push_str(&chl);
}
let element_close: String = format!("</{}>", self.name);
string.push_str(&element_close);
string
}
}
#[test]
fn element_to_string_test() {
let mut xml_ele = XMLElement::new("mouse");
xml_ele.set_attribute("x", 0);
xml_ele.set_attribute("x", 1);
xml_ele.set_child(XMLElement::new("last_update"));
let xml_str: String = xml_ele.into();
let rhs = r##"<mouse "x"="1"><last_update></last_update></mouse>"##;
assert_eq!(xml_str, rhs.to_string());
}
#[repr(C)]
#[derive(Debug)]
pub enum Types {
// Used to represent an empty attribute
None,
Integer(Int),
UnsignedInteger(UInt),
Fixed(FixedPoint),
Float(FloatingPoint),
String(String),
}
#[derive(Debug)]
pub enum FixedPoint {
Fixed16(bool, u8, u8),
Fixed32(bool, u16, u16),
Fixed64(bool, u32, u32),
Fixed128(bool, u64, u64),
Fixed256(bool, u128, u128),
}
#[derive(Debug)]
pub enum FloatingPoint {
Float32(f32),
Float64(f64),
}
#[derive(Debug)]
pub enum Int {
I8(i8),
I16(i16),
I32(i32),
I64(i64),
I128(i128),
}
#[derive(Debug)]
pub enum UInt {
U8(u8),
U16(u16),
U32(u32),
U64(u64),
U128(u128),
}
impl From<u64> for UInt {
fn from(value: u64) -> Self {
Self::U64(value)
}
}
#[test]
pub fn test_string_to_num() {
println!("{:?}", string_to_num(256));
}
pub fn string_to_num<T: Debug + Display>(string: T) -> Result<Types, XMLError> {
// let string = "-27".to_string(); // `parse()` works with `&str` and `String`!
let string: String = string.to_string();
use FloatingPoint::*;
use Int::*;
use Types::{Fixed, Float, Integer, UnsignedInteger};
use UInt::*;
match string.parse::<u8>() {
Ok(num) => return Ok(UnsignedInteger(U8(num))),
Err(_) => {}
}
match string.parse::<u16>() {
Ok(num) => return Ok(UnsignedInteger(U16(num))),
Err(_) => {}
}
match string.parse::<u32>() {
Ok(num) => return Ok(UnsignedInteger(U32(num))),
Err(_) => {}
}
match string.parse::<u64>() {
Ok(num) => return Ok(UnsignedInteger(U64(num))),
Err(_) => {}
}
match string.parse::<u128>() {
Ok(num) => return Ok(UnsignedInteger(U128(num))),
Err(_) => {}
}
match string.parse::<i8>() {
Ok(num) => return Ok(Integer(I8(num))),
Err(_) => {}
}
match string.parse::<i16>() {
Ok(num) => return Ok(Integer(I16(num))),
Err(_) => {}
}
match string.parse::<i32>() {
Ok(num) => return Ok(Integer(I32(num))),
Err(_) => {}
}
match string.parse::<i64>() {
Ok(num) => return Ok(Integer(I64(num))),
Err(_) => {}
}
match string.parse::<i128>() {
Ok(num) => return Ok(Integer(I128(num))),
Err(_) => {}
}
match string.parse::<f32>() {
Ok(num) => return Ok(Float(Float32(num))),
Err(_) => {}
}
match string.parse::<f64>() {
Ok(num) => return Ok(Float(Float64(num))),
Err(_) => {}
}
// TODO: Decimal handler
{}
Err(XMLError::TypeNotANumber)
}
#[derive(Debug)]
pub enum XMLError {
TypeNotANumber,
}

3
programs/xml_tests/Cargo.toml
View File

@ -6,5 +6,4 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
simple_xml_serialize = "*"
xml-builder = "0.5.2"
xml = { path = "../../libraries/xml" }

27
programs/xml_tests/src/main.rs
View File

@ -1,28 +1,7 @@
// use simple_xml_serialize::XMLElement;
// fn main() {
// let mut ele = XMLElement::new("mouse");
// println!("{}", ele);
// }
use xml_builder::{XMLBuilder, XMLElement, XMLVersion};
use xml;
fn main() {
let mut xml = XMLBuilder::new()
.version(XMLVersion::XML1_1)
.encoding("UTF-8".into())
.build();
let root = xml::XMLElement::new("name");
let mut mouse = XMLElement::new("mouse");
mouse.add_attribute("x", "8");
mouse.add_attribute("y", "0");
mouse.add_attribute("y_change", "-1");
mouse.add_attribute("x_change", "1");
xml.set_root_element(mouse);
let mut writer: Vec<u8> = Vec::new();
xml.generate(&mut writer).unwrap();
println!("{}", String::from_utf8_lossy(&writer));
println!("{}", root.to_string())
}