1 files changed, 84 insertions, 2 deletions

diff --git a/src/parser/clang/parsing.rs b/src/parser/clang/parsing.rs
index 1f1691f..251aefa 100644
--- a/src/parser/clang/parsing.rs
+++ b/src/parser/clang/parsing.rs
@@ -20,6 +20,7 @@ struct TopLevel {
     structs: BTreeMap<Usr, Described<Struct>>,
     functions: BTreeMap<Usr, Described<Function>>,
     typedefs: BTreeMap<Usr, Described<Typedef>>,
+    enums: BTreeMap<Usr, Described<Enum>>,
 }
 
 /*
@@ -88,6 +89,10 @@ impl TopLevel {
                 ClangEntityKind::Typedef => {
                     &mut parent.get_member_typedefs()?.get_mut(&usr)?.entity
                 }
+                ClangEntityKind::Enum => &mut parent.get_member_enums()?.get_mut(&usr)?.entity,
+                ClangEntityKind::EnumConstant => {
+                    panic!("enum variant getting");
+                }
             })
         } else {
             Some(match path.get_kind().try_into().ok()? {
@@ -96,6 +101,8 @@ impl TopLevel {
                 ClangEntityKind::Struct(_) => &mut self.structs.get_mut(&usr)?.entity,
                 ClangEntityKind::Function(_) => &mut self.functions.get_mut(&usr)?.entity,
                 ClangEntityKind::Typedef => &mut self.typedefs.get_mut(&usr)?.entity,
+                ClangEntityKind::Enum => &mut self.enums.get_mut(&usr)?.entity,
+                ClangEntityKind::EnumConstant => panic!("enum variant getting"),
             })
         }
     }
@@ -191,6 +198,12 @@ impl TopLevelManipulation<Typedef> for TopLevel {
     }
 }
 
+impl TopLevelManipulation<Enum> for TopLevel {
+    fn insert_toplevel(&mut self, usr: Usr, entity: Described<Enum>) {
+        self.enums.insert(usr, entity);
+    }
+}
+
 /*
 trait FromTopLevel: ClangEntity + Sized {
     fn from_toplevel<'a>(toplevel: &'a mut TopLevel, usr: &Usr) -> Option<&'a mut Described<Self>>;
@@ -526,7 +539,10 @@ fn add_entity(
             ClangEntityKind::Function(_) => Described::<Function>::try_from(libclang_entity)
                 .and_then(|function| toplevel.insert(libclang_entity, function)),
             ClangEntityKind::Typedef => Described::<Typedef>::try_from(libclang_entity)
-                .and_then(|function| toplevel.insert(libclang_entity, function)),
+                .and_then(|typedef| toplevel.insert(libclang_entity, typedef)),
+            ClangEntityKind::Enum => Described::<Enum>::try_from(libclang_entity)
+                .and_then(|r#enum| toplevel.insert(libclang_entity, r#enum)),
+            ClangEntityKind::EnumConstant => panic!("Enum variant encountered not within an enum"),
         };
         // TODO: check result
 
@@ -611,6 +627,7 @@ impl<'a> TryFrom<clang::Entity<'a>> for Namespace {
             member_structs: Default::default(),
             member_functions: Default::default(),
             member_typedefs: Default::default(),
+            member_enums: Default::default(),
         })
     }
 }
@@ -655,6 +672,7 @@ impl<'a> TryFrom<clang::Entity<'a>> for Struct {
         let mut member_structs = BTreeMap::new();
         let mut member_functions = BTreeMap::new();
         let mut member_typedefs = BTreeMap::new();
+        let mut member_enums = BTreeMap::new();
 
         for child in entity.get_children() {
             trace!("Struct has child: {:?}", child);
@@ -694,6 +712,12 @@ impl<'a> TryFrom<clang::Entity<'a>> for Struct {
                             .ok_or_else(|| anyhow!("no usr for: {:?}", child))?;
                         member_typedefs.insert(child_usr, Described::<Typedef>::try_from(child)?);
                     }
+                    Ok(ClangEntityKind::Enum) => {
+                        let child_usr = child
+                            .get_usr()
+                            .ok_or_else(|| anyhow!("no usr for: {:?}", child))?;
+                        member_enums.insert(child_usr, Described::<Enum>::try_from(child)?);
+                    }
                     Ok(other) => warn!("Unsupported child of struct {:?}: {:?}", other, child),
                     Err(err) => info!("Error while parsing entity {:?}: {}", child, err),
                 }
@@ -715,6 +739,7 @@ impl<'a> TryFrom<clang::Entity<'a>> for Struct {
             member_structs,
             member_variables,
             member_typedefs,
+            member_enums,
         })
     }
 }
@@ -768,7 +793,6 @@ impl<'a> TryFrom<clang::Entity<'a>> for Typedef {
         }
         debug!("Parsing typedef: {:?}", entity);
 
-        // TODO: unwrap (and unwrap in other similar places too)
         let referee = entity
             .get_typedef_underlying_type()
             .ok_or_else(|| anyhow!("No underlying type"))?
@@ -778,6 +802,64 @@ impl<'a> TryFrom<clang::Entity<'a>> for Typedef {
     }
 }
 
+impl<'a> TryFrom<clang::Entity<'a>> for Enum {
+    type Error = Error;
+
+    fn try_from(entity: clang::Entity) -> Result<Self, Error> {
+        match entity.get_kind().try_into() {
+            Ok(ClangEntityKind::Enum) => {}
+            _ => panic!("Trying to parse a non-enum into a enum"),
+        }
+        debug!("Parsing enum: {:?}", entity);
+
+        let underlying_type = entity
+            .get_enum_underlying_type()
+            .ok_or_else(|| anyhow!("No enum underlying type"))?
+            .get_display_name();
+
+        let mut constants = BTreeMap::new();
+        for child in entity.get_children() {
+            trace!("Enum has child: {:?}", child);
+            match child.get_kind().try_into() {
+                Ok(ClangEntityKind::EnumConstant) => {
+                    let child_usr = child
+                        .get_usr()
+                        .ok_or_else(|| anyhow!("no usr for: {:?}", child))?;
+                    constants.insert(child_usr, Described::<EnumConstant>::try_from(child)?);
+                }
+                Ok(other) => warn!("Unsupported child of enum {:?}: {:?}", other, child),
+                Err(err) => info!("Error while parsing entity {:?}: {}", child, err),
+            }
+        }
+
+        Ok(Enum {
+            underlying_type,
+            constants,
+        })
+    }
+}
+
+impl<'a> TryFrom<clang::Entity<'a>> for EnumConstant {
+    type Error = Error;
+
+    fn try_from(entity: clang::Entity) -> Result<Self, Error> {
+        match entity.get_kind().try_into() {
+            Ok(ClangEntityKind::EnumConstant) => {}
+            _ => panic!("Trying to parse a non-enum constant into a enum constant"),
+        }
+        debug!("Parsing enum: {:?}", entity);
+
+        let value = entity
+            .get_enum_constant_value()
+            .ok_or_else(|| anyhow!("No enum constant value"))?;
+        dbg!(value);
+
+        Ok(EnumConstant {
+            value: String::from(""),
+        })
+    }
+}
+
 fn get_description(entity: clang::Entity) -> Result<Description> {
     let name = entity
         .get_display_name()