ffi 1.1.5 → 1.15.5

data/ext/ffi_c/rbffi.h

@@ -1,21 +1,30 @@
 /*
  * Copyright (c) 2008, 2009, Wayne Meissner
  *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * This code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef RBFFI_RBFFI_H
@@ -35,13 +44,12 @@ extern void rbffi_Type_Init(VALUE ffiModule);
 extern void rbffi_Buffer_Init(VALUE ffiModule);
 extern void rbffi_Invoker_Init(VALUE ffiModule);
 extern void rbffi_Variadic_Init(VALUE ffiModule);
-extern void rbffi_DataConverter_Init(VALUE ffiModule);
 extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
 extern int rbffi_type_size(VALUE type);
+extern void rbffi_Thread_Init(VALUE moduleFFI);
 
 #ifdef	__cplusplus
 }
 #endif
 
 #endif	/* RBFFI_RBFFI_H */
-

data/ext/ffi_c/rbffi_endian.h

@@ -7,8 +7,17 @@
 
 #include <sys/types.h>
 
-#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__)
-#  include <endian.h>
+#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__) || defined(__HAIKU__)
+# include <endian.h>
+# if !defined(LITTLE_ENDIAN) && defined(__LITTLE_ENDIAN)
+#  define LITTLE_ENDIAN __LITTLE_ENDIAN
+# endif
+# if !defined(BIG_ENDIAN) && defined(__BIG_ENDIAN)
+#  define BIG_ENDIAN __BIG_ENDIAN
+# endif
+# if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
+#  define BYTE_ORDER __BYTE_ORDER
+# endif
 #endif
 
 #ifdef __sun

data/ffi.gemspec

@@ -0,0 +1,42 @@
+require File.expand_path("../lib/#{File.basename(__FILE__, '.gemspec')}/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'ffi'
+  s.version = FFI::VERSION
+  s.author = 'Wayne Meissner'
+  s.email = 'wmeissner@gmail.com'
+  s.homepage = 'https://github.com/ffi/ffi/wiki'
+  s.summary = 'Ruby FFI'
+  s.description = 'Ruby FFI library'
+  if s.respond_to?(:metadata)
+    s.metadata['bug_tracker_uri'] = 'https://github.com/ffi/ffi/issues'
+    s.metadata['changelog_uri'] = 'https://github.com/ffi/ffi/blob/master/CHANGELOG.md'
+    s.metadata['documentation_uri'] = 'https://github.com/ffi/ffi/wiki'
+    s.metadata['wiki_uri'] = 'https://github.com/ffi/ffi/wiki'
+    s.metadata['source_code_uri'] = 'https://github.com/ffi/ffi/'
+    s.metadata['mailing_list_uri'] = 'http://groups.google.com/group/ruby-ffi'
+  end
+  s.files = `git ls-files -z`.split("\x0").reject do |f|
+    f =~ /^(\.|bench|gen|libtest|nbproject|spec)/
+  end
+
+  # Add libffi git files
+  lfs = `git --git-dir ext/ffi_c/libffi/.git ls-files -z`.split("\x0")
+  # Add autoconf generated files of libffi
+  lfs += %w[ configure config.guess config.sub install-sh ltmain.sh missing fficonfig.h.in ]
+  # Add automake generated files of libffi
+  lfs += `git --git-dir ext/ffi_c/libffi/.git ls-files -z *.am */*.am`.gsub(".am\0", ".in\0").split("\x0")
+  s.files += lfs.map do |f|
+    File.join("ext/ffi_c/libffi", f)
+  end
+
+  s.extensions << 'ext/ffi_c/extconf.rb'
+  s.rdoc_options = %w[--exclude=ext/ffi_c/.*\.o$ --exclude=ffi_c\.(bundle|so)$]
+  s.license = 'BSD-3-Clause'
+  s.require_paths << 'ext/ffi_c'
+  s.required_ruby_version = '>= 2.3'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'rake-compiler', '~> 1.0'
+  s.add_development_dependency 'rake-compiler-dock', '~> 1.0'
+  s.add_development_dependency 'rspec', '~> 2.14.1'
+end

data/lib/ffi/abstract_memory.rb

@@ -0,0 +1,44 @@
+#
+# Copyright (C) 2020 Lars Kanis
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
+
+
+module FFI
+  class AbstractMemory
+    LONG_MAX = FFI::Pointer.new(1).size
+    private_constant :LONG_MAX
+
+    # Return +true+ if +self+ has a size limit.
+    #
+    # @return [Boolean]
+    def size_limit?
+      size != LONG_MAX
+    end
+  end
+end

data/lib/ffi/autopointer.rb

@@ -2,49 +2,61 @@
 # Copyright (C) 2008-2010 Wayne Meissner
 # Copyright (C) 2008 Mike Dalessio
 #
-# All rights reserved.
-#
 # This file is part of ruby-ffi.
 #
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
+# All rights reserved.
 #
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
 #
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
 #
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 module FFI
   class AutoPointer < Pointer
     extend DataConverter
 
     # @overload initialize(pointer, method)
-    #  @param [Pointer] pointer
-    #  @param [Method] method
-    #  @return [self]
-    #  The passed Method will be invoked at GC time.
+    #   @param pointer [Pointer]
+    #   @param method [Method]
+    #   @return [self]
+    #   The passed Method will be invoked at GC time.
     # @overload initialize(pointer, proc)
-    #  @param [Pointer] pointer
-    #  @return [self]
-    #  The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
-    #  @note WARNING: passing a proc _may_ cause your pointer to never be GC'd, unless you're 
-    #   careful to avoid trapping a reference to the pointer in the proc. See the test 
-    #   specs for examples.
+    #   @param pointer [Pointer]
+    #   @return [self]
+    #   The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
+    #   @note WARNING: passing a proc _may_ cause your pointer to never be
+    #     GC'd, unless you're careful to avoid trapping a reference to the
+    #     pointer in the proc. See the test specs for examples.
     # @overload initialize(pointer) { |p| ... }
-    #  @param [Pointer] pointer
-    #  @yieldparam [Pointer] p +pointer+ passed to the block
-    #  @return [self]
-    #  The passed block will be invoked at GC time.
-    #  @note WARNING: passing a block will cause your pointer to never be GC'd. This is bad.
+    #   @param pointer [Pointer]
+    #   @yieldparam [Pointer] p +pointer+ passed to the block
+    #   @return [self]
+    #   The passed block will be invoked at GC time.
+    #   @note
+    #     WARNING: passing a block will cause your pointer to never be GC'd.
+    #     This is bad.
     # @overload initialize(pointer)
-    #  @param [Pointer] pointer
-    #  @return [self]
-    #  The pointer's release() class method will be invoked at GC time.
+    #   @param pointer [Pointer]
+    #   @return [self]
+    #   The pointer's release() class method will be invoked at GC time.
     #
     # @note The safest, and therefore preferred, calling
     #  idiom is to pass a Method as the second parameter. Example usage:
@@ -64,16 +76,20 @@ module FFI
     #  going to be useful if you subclass {AutoPointer}, and override
     #  #release, which by default does nothing.
     def initialize(ptr, proc=nil, &block)
-      super(ptr)
+      super(ptr.type_size, ptr)
       raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
         || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
 
       @releaser = if proc
-                    raise RuntimeError.new("proc must be callable") unless proc.respond_to?(:call)
+                    if not proc.respond_to?(:call)
+                      raise RuntimeError.new("proc must be callable")
+                    end
                     CallableReleaser.new(ptr, proc)
 
                   else
-                    raise RuntimeError.new("no release method defined") unless self.class.respond_to?(:release)
+                    if not self.class.respond_to?(:release)
+                      raise RuntimeError.new("no release method defined")
+                    end
                     DefaultReleaser.new(ptr, self.class)
                   end
 
@@ -94,11 +110,19 @@ module FFI
       @releaser.autorelease=(autorelease)
     end
 
+    # @return [Boolean] +autorelease+
+    # Get +autorelease+ property. See {Pointer Autorelease section at Pointer}.
+    def autorelease?
+      @releaser.autorelease
+    end
+
     # @abstract Base class for {AutoPointer}'s releasers.
-    #  
+    #
     #  All subclasses of Releaser should define a +#release(ptr)+ method.
     # A releaser is an object in charge of release an {AutoPointer}.
     class Releaser
+      attr_accessor :autorelease
+
       # @param [Pointer] ptr
       # @param [#call] proc
       # @return [nil]
@@ -119,29 +143,21 @@ module FFI
           @proc = nil
         end
       end
-      
-      # @param [Boolean] autorelease
-      # @return [Boolean] autorelease
-      # Set +autorelease+ attribute for pointer managed by Releaser.
-      def autorelease=(autorelease)
-        @autorelease = autorelease if @ptr
-      end
-      
+
       # @param args
       # Release pointer if +autorelease+ is set.
       def call(*args)
         release(@ptr) if @autorelease && @ptr
       end
-      
     end
 
-    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined without Proc
-    # or Method. In this case, the pointer to release must be of a class derived from 
-    # AutoPointer with a +#release+ class method.
+    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined
+    # without Proc or Method. In this case, the pointer to release must be of
+    # a class derived from AutoPointer with a {release} class method.
     class DefaultReleaser < Releaser
       # @param [Pointer] ptr
       # @return [nil]
-      # Release +ptr+ by using his #release class method.
+      # Release +ptr+ using the {release} class method of its class.
       def release(ptr)
         @proc.release(ptr)
       end
@@ -150,9 +166,11 @@ module FFI
     # CallableReleaser is a {Releaser} used when an {AutoPointer} is defined with a
     # Proc or a Method.
     class CallableReleaser < Releaser
+      # Release +ptr+ by using Proc or Method defined at +ptr+
+      # {AutoPointer#initialize initialization}.
+      #
       # @param [Pointer] ptr
       # @return [nil]
-      # Release +ptr+ by using Proc or Method defined at +ptr+ {AutoPointer#initialize initialization}.
       def release(ptr)
         @proc.call(ptr)
       end
@@ -164,7 +182,9 @@ module FFI
     # @return [Type::POINTER]
     # @raise {RuntimeError} if class does not implement a +#release+ method
     def self.native_type
-      raise RuntimeError.new("no release method defined for #{self.inspect}") unless self.respond_to?(:release)
+      if not self.respond_to?(:release)
+        raise RuntimeError.new("no release method defined for #{self.inspect}")
+      end
       Type::POINTER
     end
 
@@ -172,8 +192,8 @@ module FFI
     #
     # Override {DataConverter#from_native}.
     # @overload self.from_native(ptr, ctx)
-    # @param [Pointer] ptr 
-    # @param ctx not used. Please set +nil+.
+    #   @param [Pointer] ptr
+    #   @param ctx not used. Please set +nil+.
     # @return [AutoPointer]
     def self.from_native(val, ctx)
       self.new(val)

data/lib/ffi/data_converter.rb

@@ -0,0 +1,67 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
+
+module FFI
+  # This module is used to extend somes classes and give then a common API.
+  #
+  # Most of methods defined here must be overriden.
+  module DataConverter
+    # Get native type.
+    #
+    # @overload native_type(type)
+    #  @param [String, Symbol, Type] type
+    #  @return [Type]
+    #  Get native type from +type+.
+    #
+    # @overload native_type
+    #  @raise {NotImplementedError} This method must be overriden.
+    def native_type(type = nil)
+      if type
+        @native_type = FFI.find_type(type)
+      else
+        native_type = @native_type
+        unless native_type
+          raise NotImplementedError, 'native_type method not overridden and no native_type set'
+        end
+        native_type
+      end
+    end
+
+    # Convert to a native type.
+    def to_native(value, ctx)
+      value
+    end
+
+    # Convert from a native type.
+    def from_native(value, ctx)
+      value
+    end
+  end
+end

data/lib/ffi/enum.rb

@@ -2,21 +2,32 @@
 # Copyright (C) 2009, 2010 Wayne Meissner
 # Copyright (C) 2009 Luc Heinrich
 #
-# All rights reserved.
-#
 # This file is part of ruby-ffi.
 #
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
 #
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
 #
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
 module FFI
@@ -74,11 +85,18 @@ module FFI
     include DataConverter
 
     attr_reader :tag
+    attr_reader :native_type
 
-    # @param [nil, Enumerable] info
-    # @param tag enum tag
-    def initialize(info, tag=nil)
-      @tag = tag
+    # @overload initialize(info, tag=nil)
+    #   @param [nil, Enumerable] info
+    #   @param [nil, Symbol] tag enum tag
+    # @overload initialize(native_type, info, tag=nil)
+    #   @param [FFI::Type] native_type Native type for new Enum
+    #   @param [nil, Enumerable] info symbols and values for new Enum
+    #   @param [nil, Symbol] tag name of new Enum
+    def initialize(*args)
+      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      info, @tag = *args
       @kv_map = Hash.new
       unless info.nil?
         last_cst = nil
@@ -86,6 +104,7 @@ module FFI
         info.each do |i|
           case i
           when Symbol
+            raise ArgumentError, "duplicate enum key" if @kv_map.has_key?(i)
             @kv_map[i] = value
             last_cst = i
             value += 1
@@ -95,7 +114,7 @@ module FFI
           end
         end
       end
-      @vk_map = Hash[@kv_map.map{|k,v| [v,k]}]
+      @vk_map = @kv_map.invert
     end
 
     # @return [Array] enum symbol names
@@ -127,16 +146,10 @@ module FFI
     def symbol_map
       @kv_map
     end
-    
+
     alias to_h symbol_map
     alias to_hash symbol_map
 
-    # Get native type of Enum
-    # @return [Type::INT]
-    def native_type
-      Type::INT
-    end
-
     # @param [Symbol, Integer, #to_int] val
     # @param ctx unused
     # @return [Integer] value of a enum symbol
@@ -155,7 +168,129 @@ module FFI
     def from_native(val, ctx)
       @vk_map[val] || val
     end
-
   end
 
+  # Represents a C enum whose values are power of 2
+  #
+  # @example
+  #  enum {
+  #    red = (1<<0),
+  #    green = (1<<1),
+  #    blue = (1<<2)
+  #  }
+  #
+  # Contrary to classical enums, bitmask values are usually combined
+  # when used.
+  class Bitmask < Enum
+
+    # @overload initialize(info, tag=nil)
+    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
+    #   @param [nil, Symbol] tag name of new Bitmask
+    # @overload initialize(native_type, info, tag=nil)
+    #   @param [FFI::Type] native_type Native type for new Bitmask
+    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
+    #   @param [nil, Symbol] tag name of new Bitmask
+    def initialize(*args)
+      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      info, @tag = *args
+      @kv_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            raise ArgumentError, "duplicate bitmask key" if @kv_map.has_key?(i)
+            @kv_map[i] = 1 << value
+            last_cst = i
+            value += 1
+          when Integer
+            raise ArgumentError, "bitmask index should be positive" if i<0
+            @kv_map[last_cst] = 1 << i
+            value = i+1
+          end
+        end
+      end
+      @vk_map = @kv_map.invert
+    end
+
+    # Get a symbol list or a value from the bitmask
+    # @overload [](*query)
+    #  Get bitmask value from symbol list
+    #  @param [Symbol] query
+    #  @return [Integer]
+    # @overload [](query)
+    #  Get bitmaks value from symbol array
+    #  @param [Array<Symbol>] query
+    #  @return [Integer]
+    # @overload [](*query)
+    #  Get a list of bitmask symbols corresponding to
+    #  the or reduction of a list of integer
+    #  @param [Integer] query
+    #  @return [Array<Symbol>]
+    # @overload [](query)
+    #  Get a list of bitmask symbols corresponding to
+    #  the or reduction of a list of integer
+    #  @param [Array<Integer>] query
+    #  @return [Array<Symbol>]
+    def [](*query)
+      flat_query = query.flatten
+      raise ArgumentError, "query should be homogeneous, #{query.inspect}" unless flat_query.all? { |o| o.is_a?(Symbol) } || flat_query.all? { |o| o.is_a?(Integer) || o.respond_to?(:to_int) }
+      case flat_query[0]
+      when Symbol
+        flat_query.inject(0) do |val, o|
+          v = @kv_map[o]
+          if v then val |= v else val end
+        end
+      when Integer, ->(o) { o.respond_to?(:to_int) }
+        val = flat_query.inject(0) { |mask, o| mask |= o.to_int }
+        @kv_map.select { |_, v| v & val != 0 }.keys
+      end
+    end
+
+    # Get the native value of a bitmask
+    # @overload to_native(query, ctx)
+    #  @param [Symbol, Integer, #to_int] query
+    #  @param ctx unused
+    #  @return [Integer] value of a bitmask
+    # @overload to_native(query, ctx)
+    #  @param [Array<Symbol, Integer, #to_int>] query
+    #  @param ctx unused
+    #  @return [Integer] value of a bitmask
+    def to_native(query, ctx)
+      return 0 if query.nil?
+      flat_query = [query].flatten
+      flat_query.inject(0) do |val, o|
+        case o
+        when Symbol
+          v = @kv_map[o]
+          raise ArgumentError, "invalid bitmask value, #{o.inspect}" unless v
+          val |= v
+        when Integer
+          val |= o
+        when ->(obj) { obj.respond_to?(:to_int) }
+          val |= o.to_int
+        else
+          raise ArgumentError, "invalid bitmask value, #{o.inspect}"
+        end
+      end
+    end
+
+    # @param [Integer] val
+    # @param ctx unused
+    # @return [Array<Symbol, Integer>] list of symbol names corresponding to val, plus an optional remainder if some bits don't match any constant
+    def from_native(val, ctx)
+      list = @kv_map.select { |_, v| v & val != 0 }.keys
+      # If there are unmatch flags,
+      # return them in an integer,
+      # else information can be lost.
+      # Similar to Enum behavior.
+      remainder = val ^ list.inject(0) do |tmp, o|
+        v = @kv_map[o]
+        if v then tmp |= v else tmp end
+      end
+      list.push remainder unless remainder == 0
+      return list
+    end
+  end
 end