first commit

src/ir/mod.rs

@@ -0,0 +1,79 @@
+//use nanoid::nanoid;
+use std::borrow::Cow;
+
+/* Any format will be parsed into an intermediate, json-like object.
+ Where possible, zero-copying should be done (???!);
+
+ Each object consists of an ordered list of fields:
+ - Immediate fields, which can be accessed immediately
+ - Dependant fields, that depend on possibly another field.
+
+ Each field has:
+ - A UUID to uniquely identify the field
+ - A type and a length, which includes endianess information.
+
+ We might have a partial deserialization. In this case
+ the concrete value of a field will be unknown and what info
+ is needed to retrive it must be shown.
+
+ We might have different options in deserializing.
+ In this case we must return all possilbe valid results.
+*/
+
+/// Tag to uniquely represent a particular field
+type FieldTag = &'static str;
+
+/// Primitive value types
+#[derive(PartialEq, Debug)]
+pub(crate) enum Atom<'a> {
+    /// Bottom
+    Unknown {
+        depends_on: FieldTag,
+    },
+    Bool(bool),
+    // unsigned numbers
+    U8(u8),
+    U16(u16),
+    U32(u32),
+    U64(u64),
+    U128(u128),
+    UX(usize, Cow<'a, [u8]>),
+    // signed numbers
+    I8(i8),
+    I16(i16),
+    I32(i32),
+    I64(i64),
+    I128(i128),
+    IX(usize, Cow<'a, [u8]>),
+    // float
+    F32(f32),
+    F64(f64),
+    // strings
+    Utf8(Cow<'a, str>),
+}
+
+pub type OwnedAtom = Atom<'static>;
+
+impl<'a> Atom<'a> {
+    fn to_static(self) -> OwnedAtom {
+        match self {
+            Atom::Unknown { depends_on } => todo!(),
+            Atom::Utf8(cow) => Atom::Utf8(cow.into_owned().into()),
+            Atom::UX(v, cow) => Atom::UX(v, cow.into_owned().into()),
+            Atom::IX(v, cow) => Atom::IX(v, cow.into_owned().into()),
+            Atom::Bool(b) => Atom::Bool(b),
+            Atom::U8(v) => Atom::U8(v),
+            Atom::U16(v) => Atom::U16(v),
+            Atom::U32(v) => Atom::U32(v),
+            Atom::U64(v) => Atom::U64(v),
+            Atom::U128(v) => Atom::U128(v),
+            Atom::I8(v) => Atom::I8(v),
+            Atom::I16(v) => Atom::I16(v),
+            Atom::I32(v) => Atom::I32(v),
+            Atom::I64(v) => Atom::I64(v),
+            Atom::I128(v) => Atom::I128(v),
+            Atom::F32(v) => Atom::F32(v),
+            Atom::F64(v) => Atom::F64(v),
+        }
+    }
+}