Support for customizable endian (big/little/native)

impl/src/bitfield/analyse.rs

@@ -12,7 +12,7 @@ use super::{
 use crate::errors::CombineError;
 use core::convert::TryFrom;
 use quote::quote;
-use std::collections::HashMap;
+use std::{collections::HashMap, convert::TryInto};
 use syn::{
     self,
     parse::Result,
@@ -201,7 +201,24 @@ impl BitfieldStruct {
                         ))
                     }
                 }
-            } else if attr.path.is_ident("skip") {
+            } else if attr.path.is_ident("endian") {
+                let path = &attr.path;
+                let args = &attr.tokens;
+                let name_value: syn::MetaNameValue =
+                    syn::parse2::<_>(quote! { #path #args })?;
+                let span = name_value.span();
+                match name_value.lit {
+                    syn::Lit::Str(lit_str) => {
+                        config.endian(lit_str.value().try_into()?, span)?;
+                    }
+                    _ => {
+                        return Err(format_err!(
+                            span,
+                            "encountered invalid value type for #[endian = Endian]"
+                        ))
+                    }
+                }
+            }else if attr.path.is_ident("skip") {
                 let path = &attr.path;
                 let args = &attr.tokens;
                 let meta: syn::Meta = syn::parse2::<_>(quote! { #path #args })?;

impl/src/bitfield/config.rs

@@ -4,9 +4,12 @@ use super::field_config::FieldConfig;
 use crate::errors::CombineError;
 use core::any::TypeId;
 use proc_macro2::Span;
-use std::collections::{
-    hash_map::Entry,
-    HashMap,
+use std::{
+    collections::{
+        hash_map::Entry,
+        HashMap,
+    },
+    convert::TryFrom, fmt,
 };
 use syn::parse::Result;
 
@@ -16,6 +19,7 @@ pub struct Config {
     pub bytes: Option<ConfigValue<usize>>,
     pub bits: Option<ConfigValue<usize>>,
     pub filled: Option<ConfigValue<bool>>,
+    pub endian: Option<ConfigValue<Endian>>,
     pub repr: Option<ConfigValue<ReprKind>>,
     pub derive_debug: Option<ConfigValue<()>>,
     pub derive_specifier: Option<ConfigValue<()>>,
@@ -57,6 +61,42 @@ impl core::fmt::Debug for ReprKind {
     }
 }
 
+/// Types of endiannes for a `#[bitfield]` struct.
+#[derive(Debug, Copy, Clone)]
+pub enum Endian {
+    Little,
+    Big,
+    Native,
+}
+
+impl TryFrom<String> for Endian {
+    type Error = ::syn::Error;
+
+    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
+        match value.as_str() {
+            "big" => Ok(Endian::Big),
+            "little" => Ok(Endian::Little),
+            "native" => Ok(Endian::Native),
+            invalid => {
+                Err(format_err!(
+                invalid,
+                "encountered invalid value argument for #[bitfield] `endian` parameter",
+                ))
+            }
+        }
+    }
+}
+
+impl fmt::Display for Endian {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", match self {
+            Endian::Big => "big",
+            Endian::Little => "little",
+            Endian::Native => "native"
+        })
+    }
+}
+
 /// A configuration value and its originating span.
 #[derive(Clone)]
 pub struct ConfigValue<T> {
@@ -234,6 +274,21 @@ impl Config {
         Ok(())
     }
 
+    /// Sets the `endian: str` #[bitfield] parameter to the given value.
+    ///
+    /// # Errors
+    ///
+    /// If the specifier has already been set.
+    pub fn endian(&mut self, value: Endian, span: Span) -> Result<()> {
+        match &self.endian {
+            Some(previous) => {
+                return Err(Self::raise_duplicate_error("endian", span, previous))
+            }
+            None => self.endian = Some(ConfigValue::new(value, span)),
+        }
+        Ok(())
+    }
+
     /// Registers the `#[repr(uN)]` attribute for the #[bitfield] macro.
     ///
     /// # Errors