SDLRuby 0.1.0

data/lib/SDLRuby/renderer/drawer.rb

@@ -0,0 +1,107 @@
+module SDLRuby
+  module Renderer
+    module Drawer
+      include Fiddle, SDL
+
+      def draw_copy(texture,
+                    angle: nil, center: nil, dst_rect:nil, flip: nil, src_rect: nil)
+
+        sr = src_rect && Rect[*src_rect]
+        dr = dst_rect && Rect[*dst_rect]
+        a = angle || 0
+        pt = if center
+               SDL_Point.malloc(RUBY_FREE).tap { |pt| pt.x, pt.y = *center }
+             end
+        fl = flip || 0 #=SDL_FLIP_NONE
+
+        err = SDL.SDL_RenderCopyEx(renderer, texture, sr, dr, a, pt, fl)
+        raise SDLError if err < 0
+      end
+
+      def draw_fill(*f)
+        size = f.count
+        count = size / 4
+        raise ArgumentError if count.zero? || (size % 4).nonzero?
+        ptr = f.pack("f*")
+
+        err = SDL.SDL_RenderFillRectsF(renderer, ptr, count)
+        raise SDLError if err < 0
+      end
+
+      def draw_line(*f)
+        size = f.count
+        count = size / 2
+        raise ArgumentError if count.zero? || (size % 2).nonzero?
+        ptr = f.pack("f*")
+
+        err = SDL.SDL_RenderDrawLinesF(renderer, ptr, count)
+        raise SDLError if err < 0
+      end
+
+      def draw_point(*f)
+        size = f.count
+        count = size / 2
+        raise ArgumentError if count.zero? || (size % 2).nonzero?
+        ptr = f.pack("f*")
+
+        err = SDL.SDL_RenderDrawPointsF(renderer, ptr, count)
+        raise SDLError if err < 0
+      end
+
+      def draw_rect(*f)
+        size = f.count
+        count = size / 4
+        raise ArgumentError if count.zero? || (size % 4).nonzero?
+        ptr = f.pack("f*")
+
+        err = SDL.SDL_RenderDrawRectsF(renderer, ptr, count)
+        raise SDLError if err < 0
+      end
+
+      def render_blend_mode
+        mode = SDL.tmp_value("int")
+        err = SDL.SDL_GetRenderDrawBlendMode(renderer, mode)
+        raise SDLError if err < 0
+
+        mode.value
+      end
+
+      def render_blend_mode=(mode)
+        err = int SDL_SetRenderDrawBlendMode(renderer, mode)
+        raise SDLError if err < 0
+      end
+
+      def render_clear
+        err = SDL.SDL_RenderClear(renderer)
+        raise SDLError if err < 0
+      end
+
+      def render_clip
+        r = Rect[]
+        SDL.SDL_RenderGetClipRect(renderer, r)
+        r.to_a
+      end
+
+      def render_clip=(rect)
+        err = SDL.SDL_RenderSetClipRect(renderer, Rect[*rect])
+        raise SDLError if err < 0
+      end
+
+      def render_clipped? = SDL.SDL_RenderIsClipEnabled(renderer) != 0
+
+      def render_color
+        r, g, b, a = SDL.tmp_value("Uint8", "Uint8", "Uint8", "Uint8")
+        err = SDL.SDL_GetRenderDrawColor(renderer, r, g, b, a)
+        raise SDLError if err < 0
+
+        [r.value, g.value, b.value, a.value]
+      end
+
+      def render_color=(obj)
+        r, g, b, a = *obj, SDL_ALPHA_OPAQUE
+        err = SDL.SDL_SetRenderDrawColor(renderer, r, g, b, a)
+        raise SDLError if err < 0
+      end
+    end
+  end
+end

data/lib/SDLRuby/renderer/renderer_info.rb

@@ -0,0 +1,27 @@
+module SDLRuby
+  module Renderer
+    class RendererInfo
+      include SDL
+      extend Forwardable
+
+      def initialize
+        @st = SDL_RendererInfo.malloc(Fiddle::RUBY_FREE)
+      end
+
+      def_delegators :@st,
+                     :flags, :to_ptr, :max_texture_height, :max_texture_width
+
+      def accelerated? = flags & SDL_RENDERER_ACCELERATED != 0
+
+      def renderer_formats = @st.texture_formats[0, @st.num_texture_formats]
+
+      def renderer_name = @st.name.to_s
+
+      def software_renderer? = flags & SDL_RENDERER_SOFTWARE != 0
+
+      def max_texture_size = [@st.max_texture_height, @st.max_texture_width]
+
+      def vsync? = flags & SDL_RENDERER_PRESENTVSYNC != 0
+    end
+  end
+end

data/lib/SDLRuby/renderer.rb

@@ -0,0 +1,101 @@
+require_relative 'renderer/accessor'
+require_relative 'renderer/drawer'
+require_relative 'renderer/renderer_info'
+
+module SDLRuby
+  module Renderer
+    include Accessor, Drawer, SDL
+    extend Forwardable
+
+    class << self
+      def drivers
+        num = SDL.SDL_GetNumRenderDrivers
+        raise SDLError if num < 0
+
+        num.times.map do |idx|
+          st = RendererInfo.new
+          err = SDL.SDL_GetRenderDriverInfo(idx, st)
+          raise SDLError if err < 0
+
+          st.renderer_name
+        end
+      end
+
+      def driver_info(name)
+        idx = drivers.index(name)
+        return unless idx
+
+        st = RendererInfo.new
+        err = SDL.SDL_GetRenderDriverInfo(idx, st)
+        raise SDLError if err < 0
+
+        st
+      end
+    end
+
+    private def renderer_info
+      st = RendererInfo.new
+      err = SDL.SDL_GetRendererInfo(renderer, st)
+      raise SDLError if err < 0
+
+      @renderer_info ||= st
+    end
+
+    def_delegators :renderer_info,
+                   :renderer_name, :software_renderer?, :max_texture_size
+
+    def create_texture(w, h, format, access: nil)
+      ac = access || SDL_TEXTUREACCESS_TARGET
+      ptr = SDL.SDL_CreateTexture(renderer, format, ac, w, h)
+      raise SDLError if ptr.null?
+      Texture.new(ptr)
+    end
+
+    def import_texture(surface)
+      ptr = SDL.SDL_CreateTextureFromSurface(renderer, surface)
+      raise SDLError if ptr.null?
+      Texture.new(ptr)
+    end
+
+    def load_texture(file, type: nil)
+      if String === file
+        rw = SDL.SDL_RWFromFile(file, "rb")
+        free = 1
+      elsif file.respond_to?(:to_path)
+        rw = SDL.SDL_RWFromFile(file.to_path, "rb")
+        free = 1
+      else
+        rw = RWOps[file]
+        free = 0
+      end
+
+      ptr = Image.IMG_LoadTextureTyped_RW(renderer, rw, free, type)
+      raise SDLError if ptr.null?
+      Texture.new(ptr)
+    end
+
+    def present = SDL.SDL_RenderPresent(renderer)
+
+    def default_texture? = SDL.SDL_GetRenderTarget(renderer).null?
+
+    # 値がnilの時はデフォルトのレンダーターゲット
+    #
+    def target_texture=(texture)
+      err = SDL.SDL_SetRenderTarget(renderer, texture)
+      raise SDLError if err < 0
+    end
+
+    def vsync?
+      st = RendererInfo.new
+      err = SDL.SDL_GetRendererInfo(renderer, st)
+      raise SDLError if err < 0
+
+      st.vsync?
+    end
+
+    def vsync=(b)
+      err = SDL.SDL_RenderSetVSync(renderer, b ? 1 : 0)
+      raise SDLError if err != 0
+    end
+  end
+end

data/lib/SDLRuby/rw_ops/rw_object.rb

@@ -0,0 +1,128 @@
+module SDLRuby
+  class RWOps
+    class RWObject
+      include Fiddle, SDL
+
+      # size_t (*read) (SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
+      #
+      class ReadClosure < Fiddle::Closure
+        include Fiddle
+
+        def initialize(obj)
+          super(TYPE_SIZE_T, [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T])
+          @obj = obj
+        end
+
+        def call(_, ptr, size, maxnum)
+          len = size * maxnum
+          return 0 if len.zero?
+
+          s = @obj.read(len)
+          return 0 if s.nil? || s.empty? # EOF
+
+          ptr[0, s.size] = s
+          s.size / size
+        rescue => e
+          SDL.last_error_message = e.full_message
+          0
+        end
+      end
+
+      # Sint64 (*seek) (SDL_RWops *context, Sint64 offset, int whence)
+      #
+      class SeekClosure < Fiddle::Closure
+        include Fiddle
+
+        def initialize(obj)
+          super(TYPE_INT64_T, [TYPE_VOIDP, TYPE_INT64_T, TYPE_INT])
+          @obj = obj
+        end
+
+        def call(_, offset, whence)
+          @obj.seek(offset, whence)
+          @obj.tell
+        rescue => e
+          SDL.last_error_message = e.full_message
+          -1
+        end
+      end
+
+      # Sint64 (*size) (SDL_RWops *context)
+      #
+      class SizeClosure < Fiddle::Closure
+        include Fiddle
+
+        def initialize(obj)
+          super(TYPE_INT64_T, [TYPE_VOIDP])
+          @obj = obj
+        end
+
+        def call(_)
+          @obj.size
+        rescue => e
+          raise e if $DEBUG
+          SDL.last_error_message = e.full_message
+          -1
+        end
+      end
+
+      # size_t (*write) (SDL_RWops *context, const void *ptr, size_t size, size_t num)
+      #
+      class WriteClosure < Fiddle::Closure
+        include Fiddle
+
+        def initialize(obj)
+          super(TYPE_SIZE_T, [TYPE_VOIDP, TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T])
+          @obj = obj
+        end
+
+        def call(_, ptr, size, num)
+          @obj.write(ptr.to_str(size * num)) / size
+        rescue => e
+          SDL.last_error_message = e.full_message
+          0
+        end
+      end
+
+      # closeにはC関数を設定する必要がある。
+      # クロージャ―を設定するとGCによる回収の際に
+      # 該当のクロージャ―が既に回収されているためコアダンプする。
+      # また、NULLに設定するとSDL_RWclose関数の呼び出し時にコアダンプする。
+      # SDLをハックしてmem_close関数を割り当てた。
+      # この関数は内部でSDL_FreeRW関数を呼び出すだけである。
+      #
+      # int (*close) (SDL_RWops *context)
+      #
+      MEM_CLOSE = module_eval do
+        _ptr = Pointer.malloc(1, RUBY_FREE)
+        rw = SDL.SDL_RWFromMem(_ptr, _ptr.size)
+        raise SDLError if rw.null?
+        st = SDL_RWops.new(rw)
+
+        st.close.freeze
+      end
+
+      # 引数 obj に与えたオブジェクトは SDL から close を呼び出されてもクローズしない。
+      # このインスタンスを単独で扱う場合は使い終わったらclose関数を呼び出す必要がある。
+      # そうしなければポインターは開放されずメモリーリークする。
+      #
+      def initialize(obj)
+        ptr = SDL.SDL_AllocRW
+        raise SDLError if ptr.null?
+
+        # SDLではSDL_RWopsポインターの開放はclose関数から行うように実装されている。
+        # これと同じ仕様とするため、このインスタンスではfreeの設定を行わない。
+        #
+        @st = SDL_RWops.new(ptr)
+
+        @st.close = MEM_CLOSE
+        @st.read = @read = ReadClosure.new(obj)
+        @st.seek = @seek = SeekClosure.new(obj)
+        @st.size = @size = SizeClosure.new(obj)
+        @st.write = @write = WriteClosure.new(obj)
+      end
+
+      def to_ptr = @st.to_ptr
+    end
+  end
+end

data/lib/SDLRuby/rw_ops.rb

@@ -0,0 +1,216 @@
+require_relative 'rw_ops/rw_object'
+
+module SDLRuby
+  class RWOps
+    include Fiddle, SDL
+
+    class << self
+      def [](src, autoclose: nil, readonly: nil)
+        case src
+        when RWOps
+          return src
+        when String
+          size = src.bytesize
+          ptr = if readonly
+                  SDL.SDL_RWFromConstMem(src, size)
+                else
+                  SDL.SDL_RWFromMem(src, size)
+                end
+          raise SDLError if ptr.null?
+        when Fiddle::Pointer
+          size = src.size
+          ptr = if readonly
+                  SDL.SDL_RWFromConstMem(src, size)
+                else
+                  SDL.SDL_RWFromMem(src, size)
+                end
+          raise SDLError if ptr.null?
+        else
+          src = RWObject.new(src)
+          ptr = src.to_ptr
+        end
+
+        obj = allocate
+        obj.__send__(:initialize, ptr, src)
+        obj
+      end
+
+      def new(file, mode = "rb")
+        ptr = SDL.SDL_RWFromFile(file, mode)
+        raise SDLError if ptr.null?
+
+        rw = super(ptr)
+
+        if block_given?
+          obj = yield(rw)
+          rw.close
+          obj
+        else
+          rw
+        end
+      end
+
+      alias open new
+    end
+
+    def initialize(ptr, obj = nil)
+      @st = SDL_RWops.new(ptr)
+      @obj = obj
+
+      # ポインターへC実装のfree関数を与えるため、終了時のGC処理でコアダンプしない。
+      #
+      @st.to_ptr.free = @st.close
+
+      # close関数の差し替えをすることで、SDLがcloseを行ってもRuby側に伝達できる。
+      # int (*close) (SDL_RWops *context)
+      #
+      st = @st
+      @st.close = @close = Closure::BlockCaller.new(
+        TYPE_INT, [TYPE_VOIDP]
+      ) do |context|
+        # call_free はclose関数の戻り値が渡されないためcloseの失敗は分からない。
+        st.to_ptr.call_free
+
+        if $DEBUG
+          warn "SDL_RWops(0x#{st.to_i.to_s(16)}) closed."
+        end
+
+        0
+      end
+    end
+
+    def close
+      unless closed?
+        err = SDL.SDL_RWclose(self)
+
+        raise SDLError if err != 0
+      end
+    end
+
+    def closed? = @st.to_ptr.freed?
+
+    def eof?
+      raise IOError, "closed" if closed?
+
+      s = SDL.SDL_RWsize(self)
+      raise SDLError if s < 0
+
+      t = SDL.SDL_RWtell(self)
+      raise SDLError if t < 0
+
+      s == t
+    end
+
+    def read(length = nil, buffer = nil)
+      raise IOError, "closed" if closed?
+
+      len = if length.nil?
+              size - tell
+            else
+              length.to_i
+            end
+
+      if len < 0
+        raise ArgumentError, "length"
+      elsif len > 0 && eof?
+        return nil
+      end
+
+      case buffer
+      when nil
+        return "" if len == 0
+
+        buffer = "\x00" * len
+        buf_size = len
+      when String
+        return buffer.clear if len == 0
+
+        buffer = buffer
+        buf_size = buffer.bytesize
+      when Fiddle::Pointer
+        if len == 0
+          buffer.size = 0
+          return buffer
+        end
+
+        buffer = buffer
+        buf_size = buffer.size
+      else
+        raise TypeError, "buffer"
+      end
+
+      if len > buf_size
+        raise ArgumentError, "length is greater than buffer size."
+      end
+
+      n = SDL.SDL_RWread(self, buffer, 1, len)
+      raise SDLError if n == 0
+
+      if String === buffer
+        buffer.slice!(n, buffer.bytesize)
+      else
+        buffer.size = n
+      end
+
+      buffer
+    end
+
+    def seek(offset, whence = IO::SEEK_SET)
+      raise IOError, "closed" if closed?
+
+      n = SDL.SDL_RWseek(self, offset, whence)
+      raise SDLError if n < 0
+      n
+    end
+
+    alias pos= seek
+
+    def size
+      raise IOError, "closed" if closed?
+
+      n = SDL.SDL_RWsize(self)
+      raise SDLError if n < 0
+      n
+    end
+
+    def tell
+      raise IOError, "closed" if closed?
+
+      n = SDL.SDL_RWtell(self)
+      raise SDLError if n < 0
+      n
+    end
+
+    alias pos tell
+
+    def to_ptr
+      raise SDLError, "released" if closed?
+      @st.to_ptr
+    end
+
+    def type
+      raise SDLError, "released" if closed?
+      @st.type
+    end
+
+    def write(obj)
+      raise IOError, "closed" if closed?
+
+      case obj
+      when String
+        ptr = obj
+        len = obj.bytesize
+      when Fiddle::Pointer
+        ptr = obj
+        len = obj.size
+      else
+        ptr = obj.to_s
+        len = ptr.bytesize
+      end
+
+      n = SDL.SDL_RWwrite(self, ptr, 1, len)
+      raise SDLError if n < len
+      n
+    end
+  end
+end

data/lib/SDLRuby/sdl/include/SDL.h.rb

@@ -0,0 +1,33 @@
+module SDLRuby::SDL
+  require_relative 'SDL_main.h.rb'
+  require_relative 'SDL_stdinc.h.rb'
+  require_relative 'SDL_audio.h.rb'
+  require_relative 'SDL_clipboard.h.rb'
+  require_relative 'SDL_cpuinfo.h.rb'
+  require_relative 'SDL_endian.h.rb'
+  require_relative 'SDL_error.h.rb'
+  require_relative 'SDL_events.h.rb'
+  require_relative 'SDL_filesystem.h.rb'
+  require_relative 'SDL_gamecontroller.h.rb'
+  require_relative 'SDL_guid.h.rb'
+  require_relative 'SDL_hints.h.rb'
+  require_relative 'SDL_joystick.h.rb'
+  require_relative 'SDL_messagebox.h.rb'
+  require_relative 'SDL_power.h.rb'
+  require_relative 'SDL_render.h.rb'
+  require_relative 'SDL_rwops.h.rb'
+  require_relative 'SDL_sensor.h.rb'
+  require_relative 'SDL_shape.h.rb'
+  require_relative 'SDL_system.h.rb'
+  require_relative 'SDL_timer.h.rb'
+  require_relative 'SDL_version.h.rb'
+  require_relative 'SDL_video.h.rb'
+  require_relative 'SDL_locale.h.rb'
+  require_relative 'SDL_misc.h.rb'
+
+  extern "int SDL_Init(Uint32 flags)"
+  extern "int SDL_InitSubSystem(Uint32 flags)"
+  extern "void SDL_QuitSubSystem(Uint32 flags)"
+  extern "Uint32 SDL_WasInit(Uint32 flags)"
+  extern "void SDL_Quit(void)"
+end

data/lib/SDLRuby/sdl/include/SDL_audio.h.rb

@@ -0,0 +1,49 @@
+module SDLRuby::SDL
+  require_relative 'SDL_stdinc.h.rb'
+  require_relative 'SDL_error.h.rb'
+  require_relative 'SDL_endian.h.rb'
+  require_relative 'SDL_rwops.h.rb'
+
+  typealias "SDL_AudioFormat", "Uint16"
+  typealias "SDL_AudioDeviceID", "Uint32"
+  typealias "SDL_AudioStream", "struct _SDL_AudioStream"
+  typealias "SDL_AudioStatus", "int"
+  extern "int SDL_GetNumAudioDrivers(void)"
+  extern "const char * SDL_GetAudioDriver(int index)"
+  extern "int SDL_AudioInit(const char *driver_name)"
+  extern "void SDL_AudioQuit(void)"
+  extern "const char * SDL_GetCurrentAudioDriver(void)"
+  extern "int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained)"
+  extern "int SDL_GetNumAudioDevices(int iscapture)"
+  extern "const char * SDL_GetAudioDeviceName(int index, int iscapture)"
+  extern "int SDL_GetAudioDeviceSpec(int index, int iscapture, SDL_AudioSpec *spec)"
+  extern "int SDL_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int iscapture)"
+  extern "SDL_AudioDeviceID SDL_OpenAudioDevice( const char *device, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes)"
+  extern "SDL_AudioStatus SDL_GetAudioStatus(void)"
+  extern "SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev)"
+  extern "void SDL_PauseAudio(int pause_on)"
+  extern "void SDL_PauseAudioDevice(SDL_AudioDeviceID dev, int pause_on)"
+  extern "SDL_AudioSpec * SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)"
+  extern "void SDL_FreeWAV(Uint8 *audio_buf)"
+  extern "int SDL_BuildAudioCVT(SDL_AudioCVT *cvt, SDL_AudioFormat src_format, Uint8 src_channels, int src_rate, SDL_AudioFormat dst_format, Uint8 dst_channels, int dst_rate)"
+  extern "int SDL_ConvertAudio(SDL_AudioCVT *cvt)"
+  extern "SDL_AudioStream * SDL_NewAudioStream(const SDL_AudioFormat src_format, const Uint8 src_channels, const int src_rate, const SDL_AudioFormat dst_format, const Uint8 dst_channels, const int dst_rate)"
+  extern "int SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len)"
+  extern "int SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, int len)"
+  extern "int SDL_AudioStreamAvailable(SDL_AudioStream *stream)"
+  extern "int SDL_AudioStreamFlush(SDL_AudioStream *stream)"
+  extern "void SDL_AudioStreamClear(SDL_AudioStream *stream)"
+  extern "void SDL_FreeAudioStream(SDL_AudioStream *stream)"
+  extern "void SDL_MixAudio(Uint8 *dst, const Uint8 *src, Uint32 len, int volume)"
+  extern "void SDL_MixAudioFormat(Uint8 *dst, const Uint8 *src, SDL_AudioFormat format, Uint32 len, int volume)"
+  extern "int SDL_QueueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len)"
+  extern "Uint32 SDL_DequeueAudio(SDL_AudioDeviceID dev, void *data, Uint32 len)"
+  extern "Uint32 SDL_GetQueuedAudioSize(SDL_AudioDeviceID dev)"
+  extern "void SDL_ClearQueuedAudio(SDL_AudioDeviceID dev)"
+  extern "void SDL_LockAudio(void)"
+  extern "void SDL_LockAudioDevice(SDL_AudioDeviceID dev)"
+  extern "void SDL_UnlockAudio(void)"
+  extern "void SDL_UnlockAudioDevice(SDL_AudioDeviceID dev)"
+  extern "void SDL_CloseAudio(void)"
+  extern "void SDL_CloseAudioDevice(SDL_AudioDeviceID dev)"
+end

data/lib/SDLRuby/sdl/include/SDL_blendmode.h.rb

@@ -0,0 +1,6 @@
+module SDLRuby::SDL
+  typealias "SDL_BlendMode", "int"
+  typealias "SDL_BlendOperation", "int"
+  typealias "SDL_BlendFactor", "int"
+  extern "SDL_BlendMode SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor, SDL_BlendOperation colorOperation, SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor, SDL_BlendOperation alphaOperation)"
+end

data/lib/SDLRuby/sdl/include/SDL_clipboard.h.rb

@@ -0,0 +1,10 @@
+module SDLRuby::SDL
+  require_relative 'SDL_stdinc.h.rb'
+
+  extern "int SDL_SetClipboardText(const char *text)"
+  extern "char * SDL_GetClipboardText(void)"
+  extern "SDL_bool SDL_HasClipboardText(void)"
+  extern "int SDL_SetPrimarySelectionText(const char *text)"
+  extern "char * SDL_GetPrimarySelectionText(void)"
+  extern "SDL_bool SDL_HasPrimarySelectionText(void)"
+end

data/lib/SDLRuby/sdl/include/SDL_config.h.rb

@@ -0,0 +1,13 @@
+module SDLRuby::SDL
+  require_relative 'SDL_platform.h.rb'
+  typealias "int8_t", "signed __int8"
+  typealias "uint8_t", "unsigned __int8"
+  typealias "int16_t", "signed __int16"
+  typealias "uint16_t", "unsigned __int16"
+  typealias "int32_t", "signed __int32"
+  typealias "uint32_t", "unsigned __int32"
+  typealias "int64_t", "signed __int64"
+  typealias "uint64_t", "unsigned __int64"
+  typealias "uintptr_t", "unsigned __int64"
+  typealias "uintptr_t", "unsigned int"
+end