Fixed up some of the code for c_enums and c_flags. Also added examples.

examples/enums.rs

@@ -0,0 +1,47 @@
+#[macro_use]
+extern crate binding;
+
+
+
+c_enum!
+{
+   /// Test enum is a simple enum testing the
+   /// capabilities of creating a C enum.
+   enum TestEnum : i32
+   {
+      /// This is the first item.
+      variant One = 1,
+
+      /// This is the second item.
+      variant Two = -2,
+
+      /// This is the third item.
+      variant Three = 3
+   }
+}
+
+
+
+pub fn main()
+{
+   let cenum: TestEnum;
+
+   cenum = TestEnum::One;
+   println!("Enum value is:  {}", cenum);
+
+   if TestEnum::is_valid_value(-2) == true
+   {
+      match TestEnum::from_value(-2)
+      {
+         Some(variant) =>
+         {
+            println!("Enum value is:  {}", variant.to_value());
+         }
+
+         None =>
+         {
+            panic!("Should not happen since we checked ahead of time.");
+         }
+      }
+   }
+}

examples/flags.rs

@@ -0,0 +1,34 @@
+#[macro_use]
+extern crate binding;
+
+
+
+c_flags!
+{
+   /// A sample of flags useful for the EvDev library.
+   flags ReadFlags: u32
+   {
+      /// Process data in sync mode.
+      const SYNC = 0b000000000000000000000001,
+
+      /// Process data in normal mode.
+      const NORMAL = 0b000000000000000000000010,
+
+      /// Pretend the next event is a SYN_DROPPED and require
+      /// the caller to sync.
+      const FORCE_SYNC = 0b000000000000000000000100,
+
+      /// The fd is not in O_NONBLOCK and a read may block.
+      const BLOCKING = 0b000000000000000000001000
+   }
+}
+
+
+pub fn main()
+{
+   let flag: ReadFlags;
+
+   flag = SYNC | NORMAL;
+   println!("Flag: {:#010b}", flag.get_bits());
+   println!("Flag: {}", flag);
+}

src/c_enum.rs

@@ -22,6 +22,8 @@ macro_rules! c_enum
          $($(#[$variantAttribute])* $variant = $value,)*
       }
 
+
+
       impl $name
       {
          /// Generate a variant of the enum from a given value.
@@ -30,22 +32,12 @@ macro_rules! c_enum
          /// to not use this in a high performance loop.
          pub fn from_value(val: $fieldType) -> Option<$name>
          {
-            // This would be better as a match statement, but
-            // unfortunately, it needs to be a giant set of if
-            // statements since we only have the expression type
-            // to work with, not a pattern type.
-            /*
             match val
             {
-               $($value => {Some($name::$variant)})*
+               $($value => { Some($name::$variant) })*
 
-               _ => {None}
+               _ => { None }
             }
-            */
-            $(if val == $value {return Some($name::$variant);})*
-
-            // No variant was found.
-            None
          }
 
          /// 'true', if the given value matches a variant
@@ -54,15 +46,9 @@ macro_rules! c_enum
          {
             match $name::from_value(val)
             {
-               Some(_) =>
-               {
-                  true
-               }
+               Some(_) => { true }
 
-               None =>
-               {
-                  false
-               }
+               None => { false }
             }
          }
 
@@ -89,7 +75,7 @@ macro_rules! c_enum
       {
          fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result
          {
-            write!(f, "{}", self.to_str())
+            ::std::fmt::Display::fmt(self, f)
          }
       }
 

src/c_flags.rs

@@ -45,7 +45,7 @@ macro_rules! c_flags
             }
             else
             {
-               Some($name {bits: bits})
+               Some($name { bits: bits })
             }
          }
 
@@ -53,13 +53,13 @@ macro_rules! c_flags
          #[inline]
          pub fn empty() -> $name
          {
-            $name {bits: 0}
+            $name { bits: 0 }
          }
 
          /// Returns the set containing all flags.
          pub fn all() -> $name
          {
-            $name {bits: $($flag.bits)|+}
+            $name { bits: $($flag.bits)|+ }
          }
 
          /// Returns `true` if no flags are currently stored;
@@ -122,7 +122,7 @@ macro_rules! c_flags
          /// Returns the union of the two sets of flags.
          fn bitor(self, other: $name) -> $name
          {
-            $name {bits: self.bits | other.bits}
+            $name { bits: self.bits | other.bits }
          }
       }
 
@@ -133,7 +133,7 @@ macro_rules! c_flags
          /// Returns the left flags, but with all the right flags toggled.
          fn bitxor(self, other: $name) -> $name
          {
-            $name {bits: self.bits ^ other.bits}
+            $name { bits: self.bits ^ other.bits }
          }
       }
 
@@ -144,7 +144,7 @@ macro_rules! c_flags
          /// Returns the intersection between the two sets of flags.
          fn bitand(self, other: $name) -> $name
          {
-            $name {bits: self.bits & other.bits}
+            $name { bits: self.bits & other.bits }
          }
       }
 
@@ -155,7 +155,7 @@ macro_rules! c_flags
          /// Returns the set difference of the two sets of flags.
          fn sub(self, other: $name) -> $name
          {
-            $name {bits: self.bits & !other.bits}
+            $name { bits: self.bits & !other.bits }
          }
       }
 
@@ -166,7 +166,7 @@ macro_rules! c_flags
          /// Returns the complement of this set of flags.
          fn not(self) -> $name
          {
-            $name {bits: !self.bits} & $name::all()
+            $name { bits: !self.bits } & $name::all()
          }
       }