Added a way to exclude certain passes from being run over declarations.

src/Bridge/Declaration.cs

@@ -132,15 +132,19 @@ namespace Cxxi
         // Tracks the original declaration definition order.
         public uint DefinitionOrder;
 
+        // Passes that should not be run on this declaration.
+        public ISet<System.Type> ExcludeFromPasses;
+
         protected Declaration()
         {
             IgnoreFlags = IgnoreFlags.None;
+            ExcludeFromPasses = new HashSet<System.Type>();
         }
 
         protected Declaration(string name)
+            : this()
         {
             Name = name;
-            IgnoreFlags = IgnoreFlags.None;
         }
 
         public override string ToString()

src/Bridge/Library.cs

@@ -161,8 +161,6 @@ namespace Cxxi
                 else if (module.FindFunction(name) as T != null)
                     yield return module.FindFunction(name) as T;
             }
-
-            yield return null;
         }
 
         public void SetEnumAsFlags(string name)
@@ -171,5 +169,13 @@ namespace Cxxi
             foreach(var @enum in enums)
                 @enum.SetFlags();
         }
+
+        public void ExcludeFromPass(string name, System.Type type)
+        {
+            var decls = FindDecl<Declaration>(name);
+
+            foreach (var decl in decls)
+                decl.ExcludeFromPasses.Add(type);
+        }
     }
 }

src/Generator/Transforms/Transform.cs

@@ -64,8 +64,11 @@ namespace Cxxi.Passes
         void TransformDeclaration(Declaration decl)
         {
             foreach (var pass in Passes.Passes)
+            {
+                if (IsPassExcluded(decl, pass)) continue;
                 pass.ProcessDeclaration(decl);
             }
+        }
 
         void TransformTypedef(TypedefDecl typedef)
         {
@@ -78,20 +81,29 @@ namespace Cxxi.Passes
         void TransformClass(Class @class)
         {
             foreach (var pass in Passes.Passes)
+            {
+                if (IsPassExcluded(@class, pass)) continue;
                 pass.ProcessClass(@class);
+            }
 
             TransformDeclaration(@class);
 
             foreach (var method in @class.Methods)
             {
                 foreach (var pass in Passes.Passes)
+                {
+                    if (IsPassExcluded(method, pass)) continue;
                     pass.ProcessMethod(method);
                 }
+            }
 
             foreach (var field in @class.Fields)
             {
                 foreach (var pass in Passes.Passes)
+                {
+                    if (IsPassExcluded(field, pass)) continue;
                     pass.ProcessField(field);
+                }
 
                 TransformDeclaration(field);
             }
@@ -100,7 +112,10 @@ namespace Cxxi.Passes
         void TransformFunction(Function function)
         {
             foreach (var pass in Passes.Passes)
+            {
+                if (IsPassExcluded(function, pass)) continue;
                 pass.ProcessFunction(function);
+            }
 
             TransformDeclaration(function);
 
@@ -118,5 +133,11 @@ namespace Cxxi.Passes
                     pass.ProcessEnumItem(item);
             }
         }
+
+        static bool IsPassExcluded(Declaration decl, TranslationUnitPass pass)
+        {
+            var type = pass.GetType();
+            return decl.ExcludeFromPasses.Contains(type);
+        }
     }
 }