Project

General

Profile

Download (9.37 KB)

Feature #5992 ยป dl-intrinsic-types.diff

nobu (Nobuyoshi Nakada), 02/10/2012 01:50 AM

View differences:

w/ext/dl/dl.c
ID rbdl_id_cdecl;
ID rbdl_id_stdcall;
#ifndef DLTYPE_SSIZE_T
# if SIZEOF_SIZE_T == SIZEOF_INT
# define DLTYPE_SSIZE_T DLTYPE_INT
# elif SIZEOF_SIZE_T == SIZEOF_LONG
# define DLTYPE_SSIZE_T DLTYPE_LONG
# elif defined HAVE_LONG_LONG && SIZEOF_SIZE_T == SIZEOF_LONG_LONG
# define DLTYPE_SSIZE_T DLTYPE_LONG_LONG
# endif
#endif
#define DLTYPE_SIZE_T (SIGNEDNESS_OF_SIZE_T*DLTYPE_SSIZE_T)
#ifndef DLTYPE_PTRDIFF_T
# if SIZEOF_PTRDIFF_T == SIZEOF_INT
# define DLTYPE_PTRDIFF_T DLTYPE_INT
# elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
# define DLTYPE_PTRDIFF_T DLTYPE_LONG
# elif defined HAVE_LONG_LONG && SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
# define DLTYPE_PTRDIFF_T DLTYPE_LONG_LONG
# endif
#endif
#ifndef DLTYPE_INTPTR_T
# if SIZEOF_INTPTR_T == SIZEOF_INT
# define DLTYPE_INTPTR_T DLTYPE_INT
# elif SIZEOF_INTPTR_T == SIZEOF_LONG
# define DLTYPE_INTPTR_T DLTYPE_LONG
# elif defined HAVE_LONG_LONG && SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
# define DLTYPE_INTPTR_T DLTYPE_LONG_LONG
# endif
#endif
#define DLTYPE_UINTPTR_T (-DLTYPE_INTPTR_T)
VALUE
rb_dl_dlopen(int argc, VALUE argv[], VALUE self)
{
......
*/
rb_define_const(rb_mDL, "TYPE_DOUBLE", INT2NUM(DLTYPE_DOUBLE));
/* Document-const: TYPE_SIZE_T
*
* DL::CFunc type - size_t
*/
rb_define_const(rb_mDL, "TYPE_SIZE_T", INT2NUM(DLTYPE_SIZE_T));
/* Document-const: TYPE_SSIZE_T
*
* DL::CFunc type - ssize_t
*/
rb_define_const(rb_mDL, "TYPE_SSIZE_T", INT2NUM(DLTYPE_SSIZE_T));
/* Document-const: TYPE_PTRDIFF_T
*
* DL::CFunc type - ptrdiff_t
*/
rb_define_const(rb_mDL, "TYPE_PTRDIFF_T", INT2NUM(DLTYPE_PTRDIFF_T));
/* Document-const: TYPE_INTPTR_T
*
* DL::CFunc type - intptr_t
*/
rb_define_const(rb_mDL, "TYPE_INTPTR_T", INT2NUM(DLTYPE_INTPTR_T));
/* Document-const: TYPE_UINTPTR_T
*
* DL::CFunc type - uintptr_t
*/
rb_define_const(rb_mDL, "TYPE_UINTPTR_T", INT2NUM(DLTYPE_UINTPTR_T));
/* Document-const: ALIGN_VOIDP
*
* The alignment size of a void*
......
*/
rb_define_const(rb_mDL, "ALIGN_DOUBLE",INT2NUM(ALIGN_DOUBLE));
/* Document-const: ALIGN_SIZE_T
*
* The alignment size of a size_t
*/
rb_define_const(rb_mDL, "ALIGN_SIZE_T", INT2NUM(ALIGN_OF(size_t)));
/* Document-const: ALIGN_SSIZE_T
*
* The alignment size of a ssize_t
*/
rb_define_const(rb_mDL, "ALIGN_SSIZE_T", INT2NUM(ALIGN_OF(size_t))); /* same as size_t */
/* Document-const: ALIGN_PTRDIFF_T
*
* The alignment size of a ptrdiff_t
*/
rb_define_const(rb_mDL, "ALIGN_PTRDIFF_T", INT2NUM(ALIGN_OF(ptrdiff_t)));
/* Document-const: ALIGN_INTPTR_T
*
* The alignment size of a intptr_t
*/
rb_define_const(rb_mDL, "ALIGN_INTPTR_T", INT2NUM(ALIGN_OF(intptr_t)));
/* Document-const: ALIGN_UINTPTR_T
*
* The alignment size of a uintptr_t
*/
rb_define_const(rb_mDL, "ALIGN_UINTPTR_T", INT2NUM(ALIGN_OF(uintptr_t)));
/* Document-const: SIZEOF_VOIDP
*
* size of a void*
......
*/
rb_define_const(rb_mDL, "SIZEOF_DOUBLE",INT2NUM(sizeof(double)));
/* Document-const: SIZEOF_SIZE_T
*
* size of a size_t
*/
rb_define_const(rb_mDL, "SIZEOF_SIZE_T", INT2NUM(sizeof(size_t)));
/* Document-const: SIZEOF_SSIZE_T
*
* size of a ssize_t
*/
rb_define_const(rb_mDL, "SIZEOF_SSIZE_T", INT2NUM(sizeof(size_t))); /* same as size_t */
/* Document-const: SIZEOF_PTRDIFF_T
*
* size of a ptrdiff_t
*/
rb_define_const(rb_mDL, "SIZEOF_PTRDIFF_T", INT2NUM(sizeof(ptrdiff_t)));
/* Document-const: SIZEOF_INTPTR_T
*
* size of a intptr_t
*/
rb_define_const(rb_mDL, "SIZEOF_INTPTR_T", INT2NUM(sizeof(intptr_t)));
/* Document-const: SIZEOF_UINTPTR_T
*
* size of a intptr_t
*/
rb_define_const(rb_mDL, "SIZEOF_UINTPTR_T", INT2NUM(sizeof(uintptr_t)));
rb_define_module_function(rb_mDL, "dlwrap", rb_dl_value2ptr, 1);
rb_define_module_function(rb_mDL, "dlunwrap", rb_dl_ptr2value, 1);
w/ext/dl/extconf.rb
end
if check
config = File.read(RbConfig.expand(File.join($arch_hdrdir, "ruby/config.h")))
types = {"SIZE_T"=>"SSIZE_T", "PTRDIFF_T"=>nil, "INTPTR_T"=>nil}
types.each do |type, signed|
if /^\#define\s+SIZEOF_#{type}\s+(SIZEOF_(.+)|\d+)/ =~ config
if size = $2 and size != 'VOIDP'
size = types.fetch(size) {size}
$defs << format("-DDLTYPE_%s=DLTYPE_%s", signed||type, size)
end
if signed
check_signedness(type.downcase, "stddef.h")
end
end
end
$defs << %[-DRUBY_VERSION=\\"#{RUBY_VERSION}\\"]
create_makefile("dl")
end
w/ext/dl/lib/dl/cparser.rb
return TYPE_FLOAT
when "double"
return TYPE_DOUBLE
when "size_t"
return TYPE_SIZE_T
when "ssize_t"
return TYPE_SSIZE_T
when "ptrdiff_t"
return TYPE_PTRDIFF_T
when "intptr_t"
return TYPE_INTPTR_T
when "uintptr_t"
return TYPE_UINTPTR_T
when /\*/, /\[\s*\]/
return TYPE_VOIDP
else
w/ext/dl/lib/dl/types.rb
typealias "UINT", "unsigned int"
typealias "ULONG", "unsigned long"
typealias "UCHAR", "unsigned char"
if [nil].pack('p').bytesize == 8
typealias "HANDLE", "unsigned long long"
else
typealias "HANDLE", "unsigned long"
end
typealias "HANDLE", "uintptr_t"
typealias "PHANDLE", "void*"
typealias "PVOID", "void*"
typealias "LPCSTR", "char*"
w/ext/fiddle/extconf.rb
have_header 'sys/mman.h'
config = File.read(RbConfig.expand(File.join($arch_hdrdir, "ruby/config.h")))
types = {"SIZE_T"=>"SSIZE_T", "PTRDIFF_T"=>nil, "INTPTR_T"=>nil}
types.each do |type, signed|
if /^\#define\s+SIZEOF_#{type}\s+(SIZEOF_(.+)|\d+)/ =~ config
if size = $2 and size != 'VOIDP'
size = types.fetch(size) {size}
$defs << format("-TYPE_%s=TYPE_%s", signed||type, size)
end
if signed
check_signedness(type.downcase, "stddef.h")
end
end
end
create_makefile 'fiddle'
# :startdoc:
w/ext/fiddle/fiddle.c
VALUE mFiddle;
#ifndef TYPE_SSIZE_T
# if SIZEOF_SIZE_T == SIZEOF_INT
# define TYPE_SSIZE_T TYPE_INT
# elif SIZEOF_SIZE_T == SIZEOF_LONG
# define TYPE_SSIZE_T TYPE_LONG
# elif defined HAVE_LONG_LONG && SIZEOF_SIZE_T == SIZEOF_LONG_LONG
# define TYPE_SSIZE_T TYPE_LONG_LONG
# endif
#endif
#define TYPE_SIZE_T (SIGNEDNESS_OF_SIZE_T*TYPE_SSIZE_T)
#ifndef TYPE_PTRDIFF_T
# if SIZEOF_PTRDIFF_T == SIZEOF_INT
# define TYPE_PTRDIFF_T TYPE_INT
# elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
# define TYPE_PTRDIFF_T TYPE_LONG
# elif defined HAVE_LONG_LONG && SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
# define TYPE_PTRDIFF_T TYPE_LONG_LONG
# endif
#endif
#ifndef TYPE_INTPTR_T
# if SIZEOF_INTPTR_T == SIZEOF_INT
# define TYPE_INTPTR_T TYPE_INT
# elif SIZEOF_INTPTR_T == SIZEOF_LONG
# define TYPE_INTPTR_T TYPE_LONG
# elif defined HAVE_LONG_LONG && SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
# define TYPE_INTPTR_T TYPE_LONG_LONG
# endif
#endif
#define TYPE_UINTPTR_T (-TYPE_INTPTR_T)
void
Init_fiddle(void)
{
......
*/
rb_define_const(mFiddle, "TYPE_DOUBLE", INT2NUM(TYPE_DOUBLE));
/* Document-const: TYPE_SSIZE_T
*
* C type - ssize_t
*/
rb_define_const(mFiddle, "TYPE_SSIZE_T", INT2NUM(TYPE_SSIZE_T));
/* Document-const: TYPE_PTRDIFF_T
*
* C type - ptrdiff_t
*/
rb_define_const(mFiddle, "TYPE_PTRDIFF_T", INT2NUM(TYPE_PTRDIFF_T));
/* Document-const: TYPE_INTPTR_T
*
* C type - intptr_t
*/
rb_define_const(mFiddle, "TYPE_INTPTR_T", INT2NUM(TYPE_INTPTR_T));
/* Document-const: WINDOWS
*
* Returns a boolean regarding whether the host is WIN32
w/test/ruby/memory_status.rb
extend DL::Importer
dlload "kernel32.dll", "psapi.dll"
include DL::Win32Types
if [nil].pack('p').bytesize == 8
typealias "SIZE_T", "DWORD64"
else
typealias "SIZE_T", "DWORD32"
end
typealias "SIZE_T", "size_t"
PROCESS_MEMORY_COUNTERS = struct [
"DWORD cb",
    (1-1/1)