OSDN Git Service

configured for android
authorKazuki Sakamoto <sakamoto@splhack.org>
Sun, 18 Jan 2009 13:29:25 +0000 (22:29 +0900)
committerKazuki Sakamoto <sakamoto@splhack.org>
Sun, 18 Jan 2009 13:29:25 +0000 (22:29 +0900)
79 files changed:
lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/jacobian.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/ludcmp.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/math.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/newton.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/util.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/digest.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/digest/hmac.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/digest/sha2.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/callback.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/cparser.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/func.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/import.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/pack.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/stack.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/struct.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/types.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/dl/value.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/expect.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/io/nonblock.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/add/core.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/add/rails.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/common.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/editor.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/ext.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/pure.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/pure/generator.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/pure/parser.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/json/version.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/kconv.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl/bn.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl/buffering.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl/cipher.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl/digest.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl/ssl.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/openssl/x509.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/ripper.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/ripper/core.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/ripper/filter.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/ripper/lexer.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/common/ripper/sexp.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/include/arm-linux/ruby/config.h [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/include/ruby/digest.h [new file with mode: 0644]
lib/ruby-1.9.1-rc1/.ext/include/ruby/dl.h [new file with mode: 0644]
lib/ruby-1.9.1-rc1/Makefile.in
lib/ruby-1.9.1-rc1/common.mk
lib/ruby-1.9.1-rc1/config.sh [new file with mode: 0755]
lib/ruby-1.9.1-rc1/configure
lib/ruby-1.9.1-rc1/ext/Setup
lib/ruby-1.9.1-rc1/ext/dl/callback-0.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-1.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-2.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-3.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-4.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-5.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-6.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-7.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback-8.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/dl/callback.h [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/extinit.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/json/ext/generator/json_generator_unicode.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/json/ext/parser/json_parser_unicode.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/mathn/complex/mathn_complex.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/mathn/rational/mathn_rational.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/nkf/nkf-utf8/nkf.h
lib/ruby-1.9.1-rc1/ext/openssl/bn_depr.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/openssl/rsa_depr.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ext/ripper/ripper.c
lib/ruby-1.9.1-rc1/ext/socket/constants.h [new file with mode: 0644]
lib/ruby-1.9.1-rc1/fake.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/io.c
lib/ruby-1.9.1-rc1/main.c
lib/ruby-1.9.1-rc1/missing/dup2.c
lib/ruby-1.9.1-rc1/prelude.c [new file with mode: 0644]
lib/ruby-1.9.1-rc1/rbconfig.rb [new file with mode: 0644]
lib/ruby-1.9.1-rc1/ruby.c
lib/ruby-1.9.1-rc1/rubyextconf.h [new file with mode: 0644]
lib/ruby-1.9.1-rc1/signal.c

diff --git a/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/jacobian.rb b/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/jacobian.rb
new file mode 100644 (file)
index 0000000..8c36ad1
--- /dev/null
@@ -0,0 +1,85 @@
+#
+# require 'bigdecimal/jacobian'
+#
+# Provides methods to compute the Jacobian matrix of a set of equations at a
+# point x. In the methods below:
+#
+# f is an Object which is used to compute the Jacobian matrix of the equations.
+# It must provide the following methods:
+#
+# f.values(x):: returns the values of all functions at x
+#
+# f.zero:: returns 0.0
+# f.one:: returns 1.0
+# f.two:: returns 1.0
+# f.ten:: returns 10.0
+#
+# f.eps:: returns the convergence criterion (epsilon value) used to determine whether two values are considered equal. If |a-b| < epsilon, the two values are considered equal.
+#
+# x is the point at which to compute the Jacobian.
+#
+# fx is f.values(x).
+#
+module Jacobian
+  #--
+  def isEqual(a,b,zero=0.0,e=1.0e-8)
+    aa = a.abs
+    bb = b.abs
+    if aa == zero &&  bb == zero then
+          true
+    else
+          if ((a-b)/(aa+bb)).abs < e then
+             true
+          else
+             false
+          end
+    end
+  end
+  #++
+
+  # Computes the derivative of f[i] at x[i].
+  # fx is the value of f at x.
+  def dfdxi(f,fx,x,i)
+    nRetry = 0
+    n = x.size
+    xSave = x[i]
+    ok = 0
+    ratio = f.ten*f.ten*f.ten
+    dx = x[i].abs/ratio
+    dx = fx[i].abs/ratio if isEqual(dx,f.zero,f.zero,f.eps)
+    dx = f.one/f.ten     if isEqual(dx,f.zero,f.zero,f.eps)
+    until ok>0 do
+      s = f.zero
+      deriv = []
+      if(nRetry>100) then
+         raise "Singular Jacobian matrix. No change at x[" + i.to_s + "]"
+      end
+      dx = dx*f.two
+      x[i] += dx
+      fxNew = f.values(x)
+      for j in 0...n do
+        if !isEqual(fxNew[j],fx[j],f.zero,f.eps) then
+           ok += 1
+           deriv <<= (fxNew[j]-fx[j])/dx
+        else
+           deriv <<= f.zero
+        end
+      end
+      x[i] = xSave
+    end
+    deriv
+  end
+
+  # Computes the Jacobian of f at x. fx is the value of f at x.
+  def jacobian(f,fx,x)
+    n = x.size
+    dfdx = Array::new(n*n)
+    for i in 0...n do
+      df = dfdxi(f,fx,x,i)
+      for j in 0...n do
+         dfdx[j*n+i] = df[j]
+      end
+    end
+    dfdx
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/ludcmp.rb b/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/ludcmp.rb
new file mode 100644 (file)
index 0000000..8f48887
--- /dev/null
@@ -0,0 +1,84 @@
+#
+# Solves a*x = b for x, using LU decomposition.
+#
+module LUSolve
+  # Performs LU decomposition of the n by n matrix a.
+  def ludecomp(a,n,zero=0,one=1)
+    prec = BigDecimal.limit(nil)
+    ps     = []
+    scales = []
+    for i in 0...n do  # pick up largest(abs. val.) element in each row.
+      ps <<= i
+      nrmrow  = zero
+      ixn = i*n
+      for j in 0...n do
+         biggst = a[ixn+j].abs
+         nrmrow = biggst if biggst>nrmrow
+      end
+      if nrmrow>zero then
+         scales <<= one.div(nrmrow,prec)
+      else 
+         raise "Singular matrix"
+      end
+    end
+    n1          = n - 1
+    for k in 0...n1 do # Gaussian elimination with partial pivoting.
+      biggst  = zero;
+      for i in k...n do
+         size = a[ps[i]*n+k].abs*scales[ps[i]]
+         if size>biggst then
+            biggst = size
+            pividx  = i
+         end
+      end
+      raise "Singular matrix" if biggst<=zero
+      if pividx!=k then
+        j = ps[k]
+        ps[k] = ps[pividx]
+        ps[pividx] = j
+      end
+      pivot   = a[ps[k]*n+k]
+      for i in (k+1)...n do
+        psin = ps[i]*n
+        a[psin+k] = mult = a[psin+k].div(pivot,prec)
+        if mult!=zero then
+           pskn = ps[k]*n
+           for j in (k+1)...n do
+             a[psin+j] -= mult.mult(a[pskn+j],prec)
+           end
+        end
+      end
+    end
+    raise "Singular matrix" if a[ps[n1]*n+n1] == zero
+    ps
+  end
+
+  # Solves a*x = b for x, using LU decomposition.
+  #
+  # a is a matrix, b is a constant vector, x is the solution vector.
+  #
+  # ps is the pivot, a vector which indicates the permutation of rows performed
+  # during LU decomposition.
+  def lusolve(a,b,ps,zero=0.0)
+    prec = BigDecimal.limit(nil)
+    n = ps.size
+    x = []
+    for i in 0...n do
+      dot = zero
+      psin = ps[i]*n
+      for j in 0...i do
+        dot = a[psin+j].mult(x[j],prec) + dot
+      end
+      x <<= b[ps[i]] - dot
+    end
+    (n-1).downto(0) do |i|
+       dot = zero
+       psin = ps[i]*n
+       for j in (i+1)...n do
+         dot = a[psin+j].mult(x[j],prec) + dot
+       end
+       x[i]  = (x[i]-dot).div(a[psin+i],prec)
+    end
+    x
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/math.rb b/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/math.rb
new file mode 100644 (file)
index 0000000..f3248a3
--- /dev/null
@@ -0,0 +1,235 @@
+#
+#--
+# Contents:
+#   sqrt(x, prec)
+#   sin (x, prec)
+#   cos (x, prec)
+#   atan(x, prec)  Note: |x|<1, x=0.9999 may not converge.
+#   exp (x, prec)
+#   log (x, prec)
+#   PI  (prec)
+#   E   (prec) == exp(1.0,prec)
+#
+# where:
+#   x    ... BigDecimal number to be computed.
+#            |x| must be small enough to get convergence.
+#   prec ... Number of digits to be obtained.
+#++
+#
+# Provides mathematical functions.
+#
+# Example:
+#
+#   require "bigdecimal"
+#   require "bigdecimal/math"
+#
+#   include BigMath
+#
+#   a = BigDecimal((PI(100)/2).to_s)
+#   puts sin(a,100) # -> 0.10000000000000000000......E1
+#
+module BigMath
+
+  # Computes the square root of x to the specified number of digits of 
+  # precision.
+  #
+  # BigDecimal.new('2').sqrt(16).to_s 
+  #  -> "0.14142135623730950488016887242096975E1"
+  #
+  def sqrt(x,prec)
+    x.sqrt(prec)
+  end
+
+  # Computes the sine of x to the specified number of digits of precision.
+  #
+  # If x is infinite or NaN, returns NaN.
+  def sin(x, prec)
+    raise ArgumentError, "Zero or negative precision for sin" if prec <= 0
+    return BigDecimal("NaN") if x.infinite? || x.nan?
+    n    = prec + BigDecimal.double_fig
+    one  = BigDecimal("1")
+    two  = BigDecimal("2")
+    x1   = x
+    x2   = x.mult(x,n)
+    sign = 1
+    y    = x
+    d    = y
+    i    = one
+    z    = one
+    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      sign = -sign
+      x1  = x2.mult(x1,n)
+      i  += two
+      z  *= (i-one) * i
+      d   = sign * x1.div(z,m)
+      y  += d
+    end
+    y
+  end
+
+  # Computes the cosine of x to the specified number of digits of precision.
+  #
+  # If x is infinite or NaN, returns NaN.
+  def cos(x, prec)
+    raise ArgumentError, "Zero or negative precision for cos" if prec <= 0
+    return BigDecimal("NaN") if x.infinite? || x.nan?
+    n    = prec + BigDecimal.double_fig
+    one  = BigDecimal("1")
+    two  = BigDecimal("2")
+    x1 = one
+    x2 = x.mult(x,n)
+    sign = 1
+    y = one
+    d = y
+    i = BigDecimal("0")
+    z = one
+    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      sign = -sign
+      x1  = x2.mult(x1,n)
+      i  += two
+      z  *= (i-one) * i
+      d   = sign * x1.div(z,m)
+      y  += d
+    end
+    y
+  end
+
+  # Computes the arctangent of x to the specified number of digits of precision.
+  #
+  # If x is infinite or NaN, returns NaN.
+  # Raises an argument error if x > 1.
+  def atan(x, prec)
+    raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
+    return BigDecimal("NaN") if x.infinite? || x.nan?
+    raise ArgumentError, "x.abs must be less than 1.0" if x.abs>=1
+    n    = prec + BigDecimal.double_fig
+    y = x
+    d = y
+    t = x
+    r = BigDecimal("3")
+    x2 = x.mult(x,n)
+    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      t = -t.mult(x2,n)
+      d = t.div(r,m)
+      y += d
+      r += 2
+    end
+    y
+  end
+
+  # Computes the value of e (the base of natural logarithms) raised to the 
+  # power of x, to the specified number of digits of precision.
+  #
+  # If x is infinite or NaN, returns NaN.
+  #
+  # BigMath::exp(BigDecimal.new('1'), 10).to_s
+  # -> "0.271828182845904523536028752390026306410273E1"
+  def exp(x, prec)
+    raise ArgumentError, "Zero or negative precision for exp" if prec <= 0
+    return BigDecimal("NaN") if x.infinite? || x.nan?
+    n    = prec + BigDecimal.double_fig
+    one  = BigDecimal("1")
+    x1 = one
+    y  = one
+    d  = y
+    z  = one
+    i  = 0
+    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      x1  = x1.mult(x,n)
+      i += 1
+      z *= i
+      d  = x1.div(z,m)
+      y += d
+    end
+    y
+  end
+
+  # Computes the natural logarithm of x to the specified number of digits 
+  # of precision.
+  #
+  # Returns x if x is infinite or NaN.
+  #
+  def log(x, prec)
+    raise ArgumentError, "Zero or negative argument for log" if x <= 0 || prec <= 0
+    return x if x.infinite? || x.nan?
+    one = BigDecimal("1")
+    two = BigDecimal("2")
+    n  = prec + BigDecimal.double_fig
+    x  = (x - one).div(x + one,n)
+    x2 = x.mult(x,n)
+    y  = x
+    d  = y
+    i = one
+    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      x  = x2.mult(x,n)
+      i += two
+      d  = x.div(i,m)
+      y += d
+    end
+    y*two
+  end
+
+  # Computes the value of pi to the specified number of digits of precision.
+  def PI(prec)
+    raise ArgumentError, "Zero or negative argument for PI" if prec <= 0
+    n      = prec + BigDecimal.double_fig
+    zero   = BigDecimal("0")
+    one    = BigDecimal("1")
+    two    = BigDecimal("2")
+
+    m25    = BigDecimal("-0.04")
+    m57121 = BigDecimal("-57121")
+
+    pi     = zero
+
+    d = one
+    k = one
+    w = one
+    t = BigDecimal("-80")
+    while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      t   = t*m25
+      d   = t.div(k,m)
+      k   = k+two
+      pi  = pi + d
+    end
+
+    d = one
+    k = one
+    w = one
+    t = BigDecimal("956")
+    while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      t   = t.div(m57121,n)
+      d   = t.div(k,m)
+      pi  = pi + d
+      k   = k+two
+    end
+    pi
+  end
+
+  # Computes e (the base of natural logarithms) to the specified number of
+  # digits of precision.
+  def E(prec)
+    raise ArgumentError, "Zero or negative precision for E" if prec <= 0
+    n    = prec + BigDecimal.double_fig
+    one  = BigDecimal("1")
+    y  = one
+    d  = y
+    z  = one
+    i  = 0
+    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+      m = BigDecimal.double_fig if m < BigDecimal.double_fig
+      i += 1
+      z *= i
+      d  = one.div(z,m)
+      y += d
+    end
+    y
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/newton.rb b/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/newton.rb
new file mode 100644 (file)
index 0000000..59ac0f7
--- /dev/null
@@ -0,0 +1,77 @@
+#
+# newton.rb 
+#
+# Solves the nonlinear algebraic equation system f = 0 by Newton's method.
+# This program is not dependent on BigDecimal.
+#
+# To call:
+#    n = nlsolve(f,x)
+#  where n is the number of iterations required,
+#        x is the initial value vector
+#        f is an Object which is used to compute the values of the equations to be solved.
+# It must provide the following methods:
+#
+# f.values(x):: returns the values of all functions at x
+#
+# f.zero:: returns 0.0
+# f.one:: returns 1.0
+# f.two:: returns 1.0
+# f.ten:: returns 10.0
+#
+# f.eps:: returns the convergence criterion (epsilon value) used to determine whether two values are considered equal. If |a-b| < epsilon, the two values are considered equal.
+#
+# On exit, x is the solution vector.
+#
+require "bigdecimal/ludcmp"
+require "bigdecimal/jacobian"
+
+module Newton
+  include LUSolve
+  include Jacobian
+  
+  def norm(fv,zero=0.0)
+    s = zero
+    n = fv.size
+    for i in 0...n do
+      s += fv[i]*fv[i]
+    end
+    s
+  end
+
+  def nlsolve(f,x)
+    nRetry = 0
+    n = x.size
+
+    f0 = f.values(x)
+    zero = f.zero
+    one  = f.one
+    two  = f.two
+    p5 = one/two
+    d  = norm(f0,zero)
+    minfact = f.ten*f.ten*f.ten
+    minfact = one/minfact
+    e = f.eps
+    while d >= e do
+      nRetry += 1
+      # Not yet converged. => Compute Jacobian matrix
+      dfdx = jacobian(f,f0,x)
+      # Solve dfdx*dx = -f0 to estimate dx
+      dx = lusolve(dfdx,f0,ludecomp(dfdx,n,zero,one),zero)
+      fact = two
+      xs = x.dup
+      begin
+        fact *= p5
+        if fact < minfact then
+          raise "Failed to reduce function values."
+        end
+        for i in 0...n do
+          x[i] = xs[i] - dx[i]*fact
+        end
+        f0 = f.values(x)
+        dn = norm(f0,zero)
+      end while(dn>=d)
+      d = dn
+    end
+    nRetry
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/util.rb b/lib/ruby-1.9.1-rc1/.ext/common/bigdecimal/util.rb
new file mode 100644 (file)
index 0000000..257781f
--- /dev/null
@@ -0,0 +1,53 @@
+#
+# BigDecimal utility library.
+#
+# To use these functions, require 'bigdecimal/util'
+#
+# The following methods are provided to convert other types to BigDecimals:
+#
+#   String#to_d -> BigDecimal
+#   Float#to_d -> BigDecimal
+#   Rational#to_d -> BigDecimal
+#
+# The following method is provided to convert BigDecimals to other types:
+#
+#   BigDecimal#to_r -> Rational
+#
+# ----------------------------------------------------------------------
+#
+class Float < Numeric
+  def to_d
+    BigDecimal(self.to_s)
+  end
+end
+
+class String
+  def to_d
+    BigDecimal(self)
+  end
+end
+
+class BigDecimal < Numeric
+  # Converts a BigDecimal to a String of the form "nnnnnn.mmm".
+  # This method is deprecated; use BigDecimal#to_s("F") instead.
+  def to_digits
+     if self.nan? || self.infinite? || self.zero?
+        self.to_s
+     else
+       i       = self.to_i.to_s
+       s,f,y,z = self.frac.split
+       i + "." + ("0"*(-z)) + f
+     end
+  end
+end
+
+class Rational < Numeric
+  # Converts a Rational to a BigDecimal
+  def to_d(nFig=0)
+     num = self.numerator.to_s
+     if nFig<=0
+        nFig = BigDecimal.double_fig*2+1
+     end
+     BigDecimal.new(num).div(self.denominator,nFig)
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/digest.rb b/lib/ruby-1.9.1-rc1/.ext/common/digest.rb
new file mode 100644 (file)
index 0000000..0c4ee3c
--- /dev/null
@@ -0,0 +1,50 @@
+require 'digest.so'
+
+module Digest
+  def self.const_missing(name)
+    case name
+    when :SHA256, :SHA384, :SHA512
+      lib = 'digest/sha2.so'
+    else
+      lib = File.join('digest', name.to_s.downcase)
+    end
+
+    begin
+      require lib
+    rescue LoadError => e
+      raise LoadError, "library not found for class Digest::#{name} -- #{lib}", caller(1)
+    end
+    unless Digest.const_defined?(name)
+      raise NameError, "uninitialized constant Digest::#{name}", caller(1)
+    end
+    Digest.const_get(name)
+  end
+
+  class ::Digest::Class
+    # creates a digest object and reads a given file, _name_.
+    # 
+    #  p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+    #  # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+    def self.file(name)
+      new.file(name)
+    end
+  end
+
+  module Instance
+    # updates the digest with the contents of a given file _name_ and
+    # returns self.
+    def file(name)
+      File.open(name, "rb") {|f|
+        buf = ""
+        while f.read(16384, buf)
+          update buf
+        end
+      }
+      self
+    end
+  end
+end
+
+def Digest(name)
+  Digest.const_get(name)
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/digest/hmac.rb b/lib/ruby-1.9.1-rc1/.ext/common/digest/hmac.rb
new file mode 100644 (file)
index 0000000..e88a335
--- /dev/null
@@ -0,0 +1,274 @@
+# = digest/hmac.rb
+#
+# An implementation of HMAC keyed-hashing algorithm
+#
+# == Overview 
+# 
+# This library adds a method named hmac() to Digest classes, which
+# creates a Digest class for calculating HMAC digests.
+#
+# == Examples
+#
+#   require 'digest/hmac'
+#
+#   # one-liner example
+#   puts Digest::HMAC.hexdigest("data", "hash key", Digest::SHA1)
+#
+#   # rather longer one
+#   hmac = Digest::HMAC.new("foo", Digest::RMD160)
+#
+#   buf = ""
+#   while stream.read(16384, buf)
+#     hmac.update(buf)
+#   end
+#
+#   puts hmac.bubblebabble
+#
+# == License
+#
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# Documentation by Akinori MUSHA
+#
+# All rights reserved.  You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+#   $Id: hmac.rb 14881 2008-01-04 07:26:14Z akr $
+#
+
+require 'digest'
+
+module Digest
+  class HMAC < Digest::Class
+    def initialize(key, digester)
+      @md = digester.new
+
+      block_len = @md.block_length
+
+      if key.bytesize > block_len
+        key = @md.digest(key)
+      end
+
+      ipad = Array.new(block_len).fill(0x36)
+      opad = Array.new(block_len).fill(0x5c)
+
+      key.bytes.each_with_index { |c, i|
+        ipad[i] ^= c
+        opad[i] ^= c
+      }
+
+      @key = key.freeze
+      @ipad = ipad.inject('') { |s, c| s << c.chr }.freeze
+      @opad = opad.inject('') { |s, c| s << c.chr }.freeze
+      @md.update(@ipad)
+    end
+
+    def initialize_copy(other)
+      @md = other.instance_eval { @md.clone }
+    end
+
+    def update(text)
+      @md.update(text)
+      self
+    end
+    alias << update
+
+    def reset
+      @md.reset
+      @md.update(@ipad)
+      self
+    end
+
+    def finish
+      d = @md.digest!
+      @md.update(@opad)
+      @md.update(d)
+      @md.digest!
+    end
+    private :finish
+
+    def digest_length
+      @md.digest_length
+    end
+
+    def block_length
+      @md.block_length
+    end
+
+    def inspect
+      sprintf('#<%s: key=%s, digest=%s>', self.class.name, @key.inspect, @md.inspect.sub(/^\#<(.*)>$/) { $1 });
+    end
+  end
+end
+
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+
+require 'test/unit'
+
+module TM_HMAC
+  def test_s_hexdigest
+    cases.each { |h|
+      digesters.each { |d|
+        assert_equal(h[:hexdigest], Digest::HMAC.hexdigest(h[:data], h[:key], d))
+      }
+    }
+  end
+
+  def test_hexdigest
+    cases.each { |h|
+      digesters.each { |d|
+        hmac = Digest::HMAC.new(h[:key], d)
+
+        hmac.update(h[:data])
+
+        assert_equal(h[:hexdigest], hmac.hexdigest)
+      }
+    }
+  end
+
+  def test_reset
+    cases.each { |h|
+      digesters.each { |d|
+        hmac = Digest::HMAC.new(h[:key], d)
+        hmac.update("test")
+        hmac.reset
+        hmac.update(h[:data])
+
+        assert_equal(h[:hexdigest], hmac.hexdigest)
+      }
+    }
+  end
+end  
+
+class TC_HMAC_MD5 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::MD5, Digest::MD5.new]
+  end
+
+  # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+  def cases
+    [
+     {
+       :key            => "\x0b" * 16,
+       :data           => "Hi There",
+       :hexdigest      => "9294727a3638bb1c13f48ef8158bfc9d",
+     }, {
+       :key            => "Jefe",
+       :data           => "what do ya want for nothing?",
+       :hexdigest      => "750c783e6ab0b503eaa86e310a5db738",
+     }, {
+       :key            => "\xaa" * 16,
+       :data           => "\xdd" * 50,
+       :hexdigest      => "56be34521d144c88dbb8c733f0e8b3f6",
+     }, {
+       :key            => "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data           => "\xcd" * 50,
+       :hexdigest      => "697eaf0aca3a3aea3a75164746ffaa79",
+     }, {
+       :key            => "\x0c" * 16,
+       :data           => "Test With Truncation",
+       :hexdigest      => "56461ef2342edc00f9bab995690efd4c",
+     }, {
+       :key            => "\xaa" * 80,
+       :data           => "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest      => "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
+     }, {
+       :key            => "\xaa" * 80,
+       :data           => "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest      => "6f630fad67cda0ee1fb1f562db3aa53e",
+     }
+    ]
+  end
+end
+
+class TC_HMAC_SHA1 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::SHA1, Digest::SHA1.new]
+  end
+
+  # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+  def cases
+    [
+     {
+       :key            => "\x0b" * 20,
+       :data           => "Hi There",
+       :hexdigest      => "b617318655057264e28bc0b6fb378c8ef146be00",
+     }, {
+       :key            => "Jefe",
+       :data           => "what do ya want for nothing?",
+       :hexdigest      => "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+     }, {
+       :key            => "\xaa" * 20,
+       :data           => "\xdd" * 50,
+       :hexdigest      => "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+     }, {
+       :key            => "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data           => "\xcd" * 50,
+       :hexdigest      => "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+     }, {
+       :key            => "\x0c" * 20,
+       :data           => "Test With Truncation",
+       :hexdigest      => "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+     }, {
+       :key            => "\xaa" * 80,
+       :data           => "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest      => "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+     }, {
+       :key            => "\xaa" * 80,
+       :data           => "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest      => "e8e99d0f45237d786d6bbaa7965c7808bbff1a91",
+     }
+    ]
+  end
+end
+
+class TC_HMAC_RMD160 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::RMD160, Digest::RMD160.new]
+  end
+
+  # Taken from RFC 2286: Test Cases for HMAC-RIPEMD160 and HMAC-RIPEMD128
+  def cases
+    [
+     {
+       :key            => "\x0b" * 20,
+       :data           => "Hi There",
+       :hexdigest      => "24cb4bd67d20fc1a5d2ed7732dcc39377f0a5668",
+     }, {
+       :key            => "Jefe",
+       :data           => "what do ya want for nothing?",
+       :hexdigest      => "dda6c0213a485a9e24f4742064a7f033b43c4069",
+     }, {
+       :key            => "\xaa" * 20,
+       :data           => "\xdd" * 50,
+       :hexdigest      => "b0b105360de759960ab4f35298e116e295d8e7c1",
+     }, {
+       :key            => "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data           => "\xcd" * 50,
+       :hexdigest      => "d5ca862f4d21d5e610e18b4cf1beb97a4365ecf4",
+     }, {
+       :key            => "\x0c" * 20,
+       :data           => "Test With Truncation",
+       :hexdigest      => "7619693978f91d90539ae786500ff3d8e0518e39",
+     }, {
+       :key            => "\xaa" * 80,
+       :data           => "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest      => "6466ca07ac5eac29e1bd523e5ada7605b791fd8b",
+     }, {
+       :key            => "\xaa" * 80,
+       :data           => "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest      => "69ea60798d71616cce5fd0871e23754cd75d5a0a",
+     }
+    ]
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/digest/sha2.rb b/lib/ruby-1.9.1-rc1/.ext/common/digest/sha2.rb
new file mode 100644 (file)
index 0000000..c16305d
--- /dev/null
@@ -0,0 +1,73 @@
+#--
+# sha2.rb - defines Digest::SHA2 class which wraps up the SHA256,
+#           SHA384, and SHA512 classes.
+#++
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+#   $Id: sha2.rb 11708 2007-02-12 23:01:19Z shyouhei $
+
+require 'digest'
+
+module Digest
+  #
+  # A meta digest provider class for SHA256, SHA384 and SHA512.
+  #
+  class SHA2 < Digest::Class
+    # call-seq:
+    #     Digest::SHA2.new(bitlen = 256) -> digest_obj
+    #
+    # Creates a new SHA2 hash object with a given bit length.
+    def initialize(bitlen = 256)
+      case bitlen
+      when 256
+        @sha2 = Digest::SHA256.new
+      when 384
+        @sha2 = Digest::SHA384.new
+      when 512
+        @sha2 = Digest::SHA512.new
+      else
+        raise ArgumentError, "unsupported bit length: %s" % bitlen.inspect
+      end
+      @bitlen = bitlen
+    end
+
+    # :nodoc:
+    def reset
+      @sha2.reset
+      self
+    end
+
+    # :nodoc:
+    def update(str)
+      @sha2.update(str)
+      self
+    end
+    alias << update
+
+    def finish
+      @sha2.digest!
+    end
+    private :finish
+
+    def block_length
+      @sha2.block_length
+    end
+
+    def digest_length
+      @sha2.digest_length
+    end
+
+    # :nodoc:
+    def initialize_copy(other)
+      @sha2 = other.instance_eval { @sha2.clone }
+    end
+
+    # :nodoc:
+    def inspect
+      "#<%s:%d %s>" % [self.class.name, @bitlen, hexdigest]
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/callback.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/callback.rb
new file mode 100644 (file)
index 0000000..d0b2c7a
--- /dev/null
@@ -0,0 +1,69 @@
+require 'dl'
+require 'thread'
+
+module DL
+  SEM = Mutex.new
+
+  def set_callback_internal(proc_entry, addr_entry, argc, ty, &cbp)
+    if( argc < 0 )
+      raise(ArgumentError, "arity should not be less than 0.")
+    end
+    addr = nil
+    SEM.synchronize{
+      ary = proc_entry[ty]
+      (0...MAX_CALLBACK).each{|n|
+        idx = (n * DLSTACK_SIZE) + argc
+        if( ary[idx].nil? )
+          ary[idx] = cbp
+          addr = addr_entry[ty][idx]
+          break
+        end
+      }
+    }
+    addr
+  end
+
+  def set_cdecl_callback(ty, argc, &cbp)
+    set_callback_internal(CdeclCallbackProcs, CdeclCallbackAddrs, argc, ty, &cbp)
+  end
+
+  def set_stdcall_callback(ty, argc, &cbp)
+    set_callback_internal(StdcallCallbackProcs, StdcallCallbackAddrs, argc, ty, &cbp)
+  end
+
+  def remove_callback_internal(proc_entry, addr_entry, addr, ctype = nil)
+    index = nil
+    if( ctype )
+      addr_entry[ctype].each_with_index{|xaddr, idx|
+        if( xaddr == addr )
+          index = idx
+        end
+      }
+    else
+      addr_entry.each{|ty,entry|
+        entry.each_with_index{|xaddr, idx|
+          if( xaddr == addr )
+            index = idx
+          end
+        }
+      }
+    end
+    if( proc_entry[ctype][index] )
+      proc_entry[ctype][index] = nil
+      return true
+    else
+      return false
+    end
+  end
+
+  def remove_cdecl_callback(addr, ctype = nil)
+    remove_callback_internal(CdeclCallbackProcs, CdeclCallbackAddrs, addr, ctype)
+  end
+
+  def remove_stdcall_callback(addr, ctype = nil)
+    remove_callback_internal(StdcallCallbackProcs, StdcallCallbackAddrs, addr, ctype)
+  end
+
+  alias set_callback set_cdecl_callback
+  alias remove_callback remove_cdecl_callback
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/cparser.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/cparser.rb
new file mode 100644 (file)
index 0000000..c897d1b
--- /dev/null
@@ -0,0 +1,109 @@
+module DL
+  module CParser
+    def parse_struct_signature(signature, tymap=nil)
+      if( signature.is_a?(String) )
+        signature = signature.split("\s*,\s*")
+      end
+      mems = []
+      tys  = []
+      signature.each{|msig|
+        tks = msig.split(/\s+(\*)?/)
+        ty = tks[0..-2].join(" ")
+        member = tks[-1]
+
+        case ty
+        when /\[(\d+)\]/
+          n = $1.to_i
+          ty.gsub!(/\s*\[\d+\]/,"")
+          ty = [ty, n]
+        when /\[\]/
+          ty.gsub!(/\s*\[\]/, "*")
+        end
+
+        case member
+        when /\[(\d+)\]/
+          ty = [ty, $1.to_i]
+          member.gsub!(/\s*\[\d+\]/,"")
+        when /\[\]/
+          ty = ty + "*"
+          member.gsub!(/\s*\[\]/, "")
+        end
+
+        mems.push(member)
+        tys.push(parse_ctype(ty,tymap))
+      }
+      return tys, mems
+    end
+
+    def parse_signature(signature, tymap=nil)
+      tymap ||= {}
+      signature = signature.gsub(/\s+/, " ").strip
+      case signature
+      when /^([\d\w@\*_\s]+)\(([\d\w\*_\s\,\[\]]*)\)$/
+        ret = $1
+        args = $2
+        ret = ret.split(/\s+/)
+        args = args.split(/\s*,\s*/)
+        func = ret.pop
+        if( func =~ /^\*/ )
+          func.gsub!(/^\*+/,"")
+          ret.push("*")
+        end
+        ret  = ret.join(" ")
+        return [func, parse_ctype(ret, tymap), args.collect{|arg| parse_ctype(arg, tymap)}]
+      else
+        raise(RuntimeError,"can't parse the function prototype: #{proto}")
+      end
+    end
+
+    def parse_ctype(ty, tymap=nil)
+      tymap ||= {}
+      case ty
+      when Array
+        return [parse_ctype(ty[0], tymap), ty[1]]
+      when "void"
+        return TYPE_VOID
+      when "char"
+        return TYPE_CHAR
+      when "unsigned char"
+        return  -TYPE_CHAR
+      when "short"
+        return TYPE_SHORT
+      when "unsigned short"
+        return -TYPE_SHORT
+      when "int"
+        return TYPE_INT
+      when "unsigned int"
+        return -TYPE_INT
+      when "long"
+        return TYPE_LONG
+      when "unsigned long"
+        return -TYPE_LONG
+      when "long long"
+        if( defined?(TYPE_LONG_LONG) )
+          return TYPE_LONG_LONG
+        else
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+      when "unsigned long long"
+        if( defined?(TYPE_LONG_LONG) )
+          return -TYPE_LONG_LONG
+        else
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+      when "float"
+        return TYPE_FLOAT
+      when "double"
+        return TYPE_DOUBLE
+      when /\*/, /\[\s*\]/
+        return TYPE_VOIDP
+      else
+        if( tymap[ty] )
+          return parse_ctype(tymap[ty], tymap)
+        else
+          raise(DLError, "unknown type: #{ty}")
+        end
+      end
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/func.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/func.rb
new file mode 100644 (file)
index 0000000..b29aebc
--- /dev/null
@@ -0,0 +1,141 @@
+require 'dl'
+require 'dl/callback'
+require 'dl/stack'
+require 'dl/value'
+require 'thread'
+
+module DL
+  class Function
+    include DL
+    include ValueUtil
+
+    def initialize(cfunc, argtypes, &proc)
+      @cfunc = cfunc
+      @stack = Stack.new(argtypes.collect{|ty| ty.abs})
+      if( @cfunc.ctype < 0 )
+        @cfunc.ctype = @cfunc.ctype.abs
+        @unsigned = true
+      end
+      if( proc )
+        bind(&proc)
+      end
+    end
+
+    def to_i()
+      @cfunc.to_i
+    end
+
+    def call(*args, &block)
+      funcs = []
+      args = wrap_args(args, @stack.types, funcs, &block)
+      r = @cfunc.call(@stack.pack(args))
+      funcs.each{|f| f.unbind_at_call()}
+      return wrap_result(r)
+    end
+
+    def wrap_result(r)
+      case @cfunc.ctype
+      when TYPE_VOIDP
+        r = CPtr.new(r)
+      else
+        if( @unsigned )
+          r = unsigned_value(r, @cfunc.ctype)
+        end
+      end
+      r
+    end
+
+    def bind(&block)
+      if( !block )
+        raise(RuntimeError, "block must be given.")
+      end
+      if( @cfunc.ptr == 0 )
+        cb = Proc.new{|*args|
+          ary = @stack.unpack(args)
+          @stack.types.each_with_index{|ty, idx|
+            case ty
+            when TYPE_VOIDP
+              ary[idx] = CPtr.new(ary[idx])
+            end
+          }
+          r = block.call(*ary)
+          wrap_arg(r, @cfunc.ctype, [])
+        }
+        case @cfunc.calltype
+        when :cdecl
+          @cfunc.ptr = set_cdecl_callback(@cfunc.ctype, @stack.size, &cb)
+        when :stdcall
+          @cfunc.ptr = set_stdcall_callback(@cfunc.ctype, @stack.size, &cb)
+        else
+          raise(RuntimeError, "unsupported calltype: #{@cfunc.calltype}")
+        end
+        if( @cfunc.ptr == 0 )
+          raise(RuntimeException, "can't bind C function.")
+        end
+      end
+    end
+
+    def unbind()
+      if( @cfunc.ptr != 0 )
+        case @cfunc.calltype
+        when :cdecl
+          remove_cdecl_callback(@cfunc.ptr, @cfunc.ctype)
+        when :stdcall
+          remove_stdcall_callback(@cfunc.ptr, @cfunc.ctype)
+        else
+          raise(RuntimeError, "unsupported calltype: #{@cfunc.calltype}")
+        end
+        @cfunc.ptr = 0
+      end
+    end
+
+    def bind_at_call(&block)
+      bind(&block)
+    end
+
+    def unbind_at_call()
+    end
+  end
+
+  class TempFunction < Function
+    def bind_at_call(&block)
+      bind(&block)
+    end
+
+    def unbind_at_call()
+      unbind()
+    end
+  end
+
+  class CarriedFunction < Function
+    def initialize(cfunc, argtypes, n)
+      super(cfunc, argtypes)
+      @carrier = []
+      @index = n
+      @mutex = Mutex.new
+    end
+
+    def create_carrier(data)
+      ary = []
+      userdata = [ary, data]
+      @mutex.lock()
+      @carrier.push(userdata)
+      return dlwrap(userdata)
+    end
+
+    def bind_at_call(&block)
+      userdata = @carrier[-1]
+      userdata[0].push(block)
+      bind{|*args|
+        ptr = args[@index]
+        if( !ptr )
+          raise(RuntimeError, "The index of userdata should be lower than #{args.size}.")
+        end
+        userdata = dlunwrap(Integer(ptr))
+        args[@index] = userdata[1]
+        userdata[0][0].call(*args)
+      }
+      @mutex.unlock()
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/import.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/import.rb
new file mode 100644 (file)
index 0000000..4f93468
--- /dev/null
@@ -0,0 +1,215 @@
+require 'dl'
+require 'dl/func.rb'
+require 'dl/struct.rb'
+require 'dl/cparser.rb'
+
+module DL
+  class CompositeHandler
+    def initialize(handlers)
+      @handlers = handlers
+    end
+
+    def handlers()
+      @handlers
+    end
+
+    def sym(symbol)
+      @handlers.each{|handle|
+        if( handle )
+          begin
+            addr = handle.sym(symbol)
+            return addr
+          rescue DLError
+          end
+        end
+      }
+      return nil
+    end
+
+    def [](symbol)
+      sym(symbol)
+    end
+  end
+
+  module Importer
+    include DL
+    include CParser
+    extend Importer
+
+    def dlload(*libs)
+      handles = libs.collect{|lib|
+        case lib
+        when nil
+          nil
+        when Handle
+          lib
+        when Importer
+          lib.handlers
+        else
+          begin
+            DL.dlopen(lib)
+          rescue DLError
+            raise(DLError, "can't load #{lib}")
+          end
+        end
+      }.flatten()
+      @handler = CompositeHandler.new(handles)
+      @func_map = {}
+      @type_alias = {}
+    end
+
+    def typealias(alias_type, orig_type)
+      @type_alias[alias_type] = orig_type
+    end
+
+    def sizeof(ty)
+      case ty
+      when String
+        ty = parse_ctype(ty, @type_alias).abs()
+        case ty
+        when TYPE_CHAR
+          return SIZEOF_CHAR
+        when TYPE_SHORT
+          return SIZEOF_SHORT
+        when TYPE_INT
+          return SIZEOF_INT
+        when TYPE_LONG
+          return SIZEOF_LONG
+        when TYPE_LONG_LONG
+          return SIZEOF_LONG_LON
+        when TYPE_FLOAT
+          return SIZEOF_FLOAT
+        when TYPE_DOUBLE
+          return SIZEOF_DOUBLE
+        when TYPE_VOIDP
+          return SIZEOF_VOIDP
+        else
+          raise(DLError, "unknown type: #{ty}")
+        end
+      when Class
+        if( ty.instance_methods().include?(:to_ptr) )
+          return ty.size()
+        end
+      end
+      return CPtr[ty].size()
+    end
+
+    def parse_bind_options(opts)
+      h = {}
+      prekey = nil
+      while( opt = opts.shift() )
+        case opt
+        when :stdcall, :cdecl
+          h[:call_type] = opt
+        when :carried, :temp, :temporal, :bind
+          h[:callback_type] = opt
+          h[:carrier] = opts.shift()
+        else
+          h[opt] = true
+        end
+      end
+      h
+    end
+    private :parse_bind_options
+
+    def extern(signature, *opts)
+      symname, ctype, argtype = parse_signature(signature, @type_alias)
+      opt = parse_bind_options(opts)
+      f = import_function(symname, ctype, argtype, opt[:call_type])
+      name = symname.gsub(/@.+/,'')
+      @func_map[name] = f
+      # define_method(name){|*args,&block| f.call(*args,&block)}
+      module_eval(<<-EOS)
+        def #{name}(*args, &block)
+          @func_map['#{name}'].call(*args,&block)
+        end
+      EOS
+      module_function(name)
+      f
+    end
+
+    def bind(signature, *opts, &blk)
+      name, ctype, argtype = parse_signature(signature, @type_alias)
+      h = parse_bind_options(opts)
+      case h[:callback_type]
+      when :bind, nil
+        f = bind_function(name, ctype, argtype, h[:call_type], &blk)
+      when :temp, :temporal
+        f = create_temp_function(name, ctype, argtype, h[:call_type])
+      when :carried
+        f = create_carried_function(name, ctype, argtype, h[:call_type], h[:carrier])
+      else
+        raise(RuntimeError, "unknown callback type: #{h[:callback_type]}")
+      end
+      @func_map[name] = f
+      #define_method(name){|*args,&block| f.call(*args,&block)}
+      module_eval(<<-EOS)
+        def #{name}(*args,&block)
+          @func_map['#{name}'].call(*args,&block)
+        end
+      EOS
+      module_function(name)
+      f
+    end
+
+    def struct(signature)
+      tys, mems = parse_struct_signature(signature, @type_alias)
+      DL::CStructBuilder.create(CStruct, tys, mems)
+    end
+
+    def union(signature)
+      tys, mems = parse_struct_signature(signature, @type_alias)
+      DL::CStructBuilder.create(CUnion, tys, mems)
+    end
+
+    def [](name)
+      @func_map[name]
+    end
+
+    def create_value(ty, val=nil)
+      s = struct([ty + " value"])
+      ptr = s.malloc()
+      if( val )
+        ptr.value = val
+      end
+      return ptr
+    end
+    alias value create_value
+
+    def import_value(ty, addr)
+      s = struct([ty + " value"])
+      ptr = s.new(addr)
+      return ptr
+    end
+
+    def import_symbol(name)
+      addr = @handler.sym(name)
+      if( !addr )
+        raise(DLError, "cannot find the symbol: #{name}")
+      end
+      CPtr.new(addr)
+    end
+
+    def import_function(name, ctype, argtype, call_type = nil)
+      addr = @handler.sym(name)
+      if( !addr )
+        raise(DLError, "cannot find the function: #{name}()")
+      end
+      Function.new(CFunc.new(addr, ctype, name, call_type || :cdecl), argtype)
+    end
+
+    def bind_function(name, ctype, argtype, call_type = nil, &block)
+      f = Function.new(CFunc.new(0, ctype, name, call_type || :cdecl), argtype)
+      f.bind(&block)
+      f
+    end
+
+    def create_temp_function(name, ctype, argtype, call_type = nil)
+      TempFunction.new(CFunc.new(0, ctype, name, call_type || :cdecl), argtype)
+    end
+
+    def create_carried_function(name, ctype, argtype, call_type = nil, n = 0)
+      CarriedFunction.new(CFunc.new(0, ctype, name, call_type || :cdecl), argtype, n)
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/pack.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/pack.rb
new file mode 100644 (file)
index 0000000..ad91833
--- /dev/null
@@ -0,0 +1,173 @@
+require 'dl'
+
+module DL
+  module PackInfo
+    if( defined?(TYPE_LONG_LONG) )
+    ALIGN_MAP = {
+      TYPE_VOIDP => ALIGN_VOIDP,
+      TYPE_CHAR  => ALIGN_CHAR,
+      TYPE_SHORT => ALIGN_SHORT,
+      TYPE_INT   => ALIGN_INT,
+      TYPE_LONG  => ALIGN_LONG,
+      TYPE_LONG_LONG => ALIGN_LONG_LONG,
+      TYPE_FLOAT => ALIGN_FLOAT,
+      TYPE_DOUBLE => ALIGN_DOUBLE,
+      -TYPE_CHAR  => ALIGN_CHAR,
+      -TYPE_SHORT => ALIGN_SHORT,
+      -TYPE_INT   => ALIGN_INT,
+      -TYPE_LONG  => ALIGN_LONG,
+      -TYPE_LONG_LONG => ALIGN_LONG_LONG,
+    }
+
+    PACK_MAP = {
+      TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG) ? "q" : "l!"),
+      TYPE_CHAR  => "c",
+      TYPE_SHORT => "s!",
+      TYPE_INT   => "i!",
+      TYPE_LONG  => "l!",
+      TYPE_LONG_LONG => "q",
+      TYPE_FLOAT => "f",
+      TYPE_DOUBLE => "d",
+      -TYPE_CHAR  => "c",
+      -TYPE_SHORT => "s!",
+      -TYPE_INT   => "i!",
+      -TYPE_LONG  => "l!",
+      -TYPE_LONG_LONG => "q",
+    }
+
+    SIZE_MAP = {
+      TYPE_VOIDP => SIZEOF_VOIDP,
+      TYPE_CHAR  => SIZEOF_CHAR,
+      TYPE_SHORT => SIZEOF_SHORT,
+      TYPE_INT   => SIZEOF_INT,
+      TYPE_LONG  => SIZEOF_LONG,
+      TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+      TYPE_FLOAT => SIZEOF_FLOAT,
+      TYPE_DOUBLE => SIZEOF_DOUBLE,
+      -TYPE_CHAR  => SIZEOF_CHAR,
+      -TYPE_SHORT => SIZEOF_SHORT,
+      -TYPE_INT   => SIZEOF_INT,
+      -TYPE_LONG  => SIZEOF_LONG,
+      -TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+    }
+    else
+    ALIGN_MAP = {
+      TYPE_VOIDP => ALIGN_VOIDP,
+      TYPE_CHAR  => ALIGN_CHAR,
+      TYPE_SHORT => ALIGN_SHORT,
+      TYPE_INT   => ALIGN_INT,
+      TYPE_LONG  => ALIGN_LONG,
+      TYPE_FLOAT => ALIGN_FLOAT,
+      TYPE_DOUBLE => ALIGN_DOUBLE,
+      -TYPE_CHAR  => ALIGN_CHAR,
+      -TYPE_SHORT => ALIGN_SHORT,
+      -TYPE_INT   => ALIGN_INT,
+      -TYPE_LONG  => ALIGN_LONG,
+    }
+
+    PACK_MAP = {
+      TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG) ? "q" : "l!"),
+      TYPE_CHAR  => "c",
+      TYPE_SHORT => "s!",
+      TYPE_INT   => "i!",
+      TYPE_LONG  => "l!",
+      TYPE_FLOAT => "f",
+      TYPE_DOUBLE => "d",
+      -TYPE_CHAR  => "c",
+      -TYPE_SHORT => "s!",
+      -TYPE_INT   => "i!",
+      -TYPE_LONG  => "l!",
+    }
+
+    SIZE_MAP = {
+      TYPE_VOIDP => SIZEOF_VOIDP,
+      TYPE_CHAR  => SIZEOF_CHAR,
+      TYPE_SHORT => SIZEOF_SHORT,
+      TYPE_INT   => SIZEOF_INT,
+      TYPE_LONG  => SIZEOF_LONG,
+      TYPE_FLOAT => SIZEOF_FLOAT,
+      TYPE_DOUBLE => SIZEOF_DOUBLE,
+      -TYPE_CHAR  => SIZEOF_CHAR,
+      -TYPE_SHORT => SIZEOF_SHORT,
+      -TYPE_INT   => SIZEOF_INT,
+      -TYPE_LONG  => SIZEOF_LONG,
+    }
+    end
+
+    def align(addr, align)
+      d = addr % align
+      if( d == 0 )
+        addr
+      else
+        addr + (align - d)
+      end
+    end
+    module_function :align
+  end
+
+  class Packer
+    include PackInfo
+
+    def Packer.[](*types)
+      Packer.new(types)
+    end
+
+    def initialize(types)
+      parse_types(types)
+    end
+
+    def size()
+      @size
+    end
+    
+    def pack(ary)
+      case SIZEOF_VOIDP
+      when SIZEOF_LONG
+        ary.pack(@template)
+      when SIZEOF_LONG
+        ary.pack(@template)
+      else
+        raise(RuntimeError, "sizeof(void*)?")
+      end
+    end
+
+    def unpack(ary)
+      case SIZEOF_VOIDP
+      when SIZEOF_LONG
+        ary.join().unpack(@template)
+      when SIZEOF_LONG_LONG
+        ary.join().unpack(@template)
+      else
+        raise(RuntimeError, "sizeof(void*)?")
+      end
+    end
+    
+    private
+    
+    def parse_types(types)
+      @template = ""
+      addr     = 0
+      types.each{|t|
+        orig_addr = addr
+        if( t.is_a?(Array) )
+          addr = align(orig_addr, ALIGN_MAP[TYPE_VOIDP])
+        else
+          addr = align(orig_addr, ALIGN_MAP[t])
+        end
+        d = addr - orig_addr
+        if( d > 0 )
+          @template << "x#{d}"
+        end
+        if( t.is_a?(Array) )
+          @template << (PACK_MAP[t[0]] * t[1])
+          addr += (SIZE_MAP[t[0]] * t[1])
+        else
+          @template << PACK_MAP[t]
+          addr += SIZE_MAP[t]
+        end
+      }
+      addr = align(addr, ALIGN_MAP[TYPE_VOIDP])
+      @size = addr
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/stack.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/stack.rb
new file mode 100644 (file)
index 0000000..99a24bc
--- /dev/null
@@ -0,0 +1,146 @@
+require 'dl'
+
+module DL
+  class Stack
+    def Stack.[](*types)
+      Stack.new(types)
+    end
+
+    def initialize(types)
+      parse_types(types)
+    end
+
+    def size()
+      @size
+    end
+
+    def types()
+      @types
+    end
+
+    def pack(ary)
+      case SIZEOF_VOIDP
+      when SIZEOF_LONG
+        ary.pack(@template).unpack('l!*')
+      when SIZEOF_LONG_LONG
+        ary.pack(@template).unpack('q*')
+      else
+        raise(RuntimeError, "sizeof(void*)?")
+      end
+    end
+
+    def unpack(ary)
+      case SIZEOF_VOIDP
+      when SIZEOF_LONG
+        ary.pack('l!*').unpack(@template)
+      when SIZEOF_LONG_LONG
+        ary.pack('q*').unpack(@template)
+      else
+        raise(RuntimeError, "sizeof(void*)?")
+      end
+    end
+    
+    private
+    
+    def align(addr, align)
+      d = addr % align
+      if( d == 0 )
+        addr
+      else
+        addr + (align - d)
+      end
+    end
+
+if( defined?(TYPE_LONG_LONG) )
+    ALIGN_MAP = {
+      TYPE_VOIDP => ALIGN_VOIDP,
+      TYPE_CHAR  => ALIGN_VOIDP,
+      TYPE_SHORT => ALIGN_VOIDP,
+      TYPE_INT   => ALIGN_VOIDP,
+      TYPE_LONG  => ALIGN_VOIDP,
+      TYPE_LONG_LONG => ALIGN_LONG_LONG,
+      TYPE_FLOAT => ALIGN_FLOAT,
+      TYPE_DOUBLE => ALIGN_DOUBLE,
+    }
+
+    PACK_MAP = {
+      TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG)? "q" : "l!"),
+      TYPE_CHAR  => "c",
+      TYPE_SHORT => "s!",
+      TYPE_INT   => "i!",
+      TYPE_LONG  => "l!",
+      TYPE_LONG_LONG => "q",
+      TYPE_FLOAT => "f",
+      TYPE_DOUBLE => "d",
+    }
+
+    SIZE_MAP = {
+      TYPE_VOIDP => SIZEOF_VOIDP,
+      TYPE_CHAR  => SIZEOF_CHAR,
+      TYPE_SHORT => SIZEOF_SHORT,
+      TYPE_INT   => SIZEOF_INT,
+      TYPE_LONG  => SIZEOF_LONG,
+      TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+      TYPE_FLOAT => SIZEOF_FLOAT,
+      TYPE_DOUBLE => SIZEOF_DOUBLE,
+    }
+else
+    ALIGN_MAP = {
+      TYPE_VOIDP => ALIGN_VOIDP,
+      TYPE_CHAR  => ALIGN_VOIDP,
+      TYPE_SHORT => ALIGN_VOIDP,
+      TYPE_INT   => ALIGN_VOIDP,
+      TYPE_LONG  => ALIGN_VOIDP,
+      TYPE_FLOAT => ALIGN_FLOAT,
+      TYPE_DOUBLE => ALIGN_DOUBLE,
+    }
+
+    PACK_MAP = {
+      TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG)? "q" : "l!"),
+      TYPE_CHAR  => "c",
+      TYPE_SHORT => "s!",
+      TYPE_INT   => "i!",
+      TYPE_LONG  => "l!",
+      TYPE_FLOAT => "f",
+      TYPE_DOUBLE => "d",
+    }
+
+    SIZE_MAP = {
+      TYPE_VOIDP => SIZEOF_VOIDP,
+      TYPE_CHAR  => SIZEOF_CHAR,
+      TYPE_SHORT => SIZEOF_SHORT,
+      TYPE_INT   => SIZEOF_INT,
+      TYPE_LONG  => SIZEOF_LONG,
+      TYPE_FLOAT => SIZEOF_FLOAT,
+      TYPE_DOUBLE => SIZEOF_DOUBLE,
+    }
+end
+
+    def parse_types(types)
+      @types = types
+      @template = ""
+      addr      = 0
+      types.each{|t|
+        addr = add_padding(addr, ALIGN_MAP[t])
+        @template << PACK_MAP[t]
+        addr += SIZE_MAP[t]
+      }
+      addr = add_padding(addr, ALIGN_MAP[SIZEOF_VOIDP])
+      if( addr % SIZEOF_VOIDP == 0 )
+        @size = addr / SIZEOF_VOIDP
+      else
+        @size = (addr / SIZEOF_VOIDP) + 1
+      end
+    end
+
+    def add_padding(addr, align)
+      orig_addr = addr
+      addr = align(orig_addr, align)
+      d = addr - orig_addr
+      if( d > 0 )
+        @template << "x#{d}"
+      end
+      addr
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/struct.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/struct.rb
new file mode 100644 (file)
index 0000000..4272b39
--- /dev/null
@@ -0,0 +1,213 @@
+require 'dl'
+require 'dl/pack.rb'
+
+module DL
+  class CStruct
+    def CStruct.entity_class()
+      CStructEntity
+    end
+  end
+
+  class CUnion
+    def CUnion.entity_class()
+      CUnionEntity
+    end
+  end
+
+  module CStructBuilder
+    def create(klass, types, members)
+      new_class = Class.new(klass){
+        define_method(:initialize){|addr|
+          @entity = klass.entity_class.new(addr, types)
+          @entity.assign_names(members)
+        }
+        define_method(:to_ptr){ @entity }
+        define_method(:to_i){ @entity.to_i }
+        members.each{|name|
+          define_method(name){ @entity[name] }
+          define_method(name + "="){|val| @entity[name] = val }
+        }
+      }
+      size = klass.entity_class.size(types)
+      new_class.module_eval(<<-EOS)
+        def new_class.size()
+          #{size}
+        end
+        def new_class.malloc()
+          addr = DL.malloc(#{size})
+          new(addr)
+        end
+      EOS
+      return new_class
+    end
+    module_function :create
+  end
+
+  class CStructEntity < CPtr
+    include PackInfo
+    include ValueUtil
+
+    def CStructEntity.malloc(types, func = nil)
+      addr = DL.malloc(CStructEntity.size(types))
+      CStructEntity.new(addr, types, func)
+    end
+
+    def CStructEntity.size(types)
+      offset = 0
+      max_align = 0
+      types.each_with_index{|t,i|
+        orig_offset = offset
+        if( t.is_a?(Array) )
+          align = PackInfo::ALIGN_MAP[t[0]]
+          offset = PackInfo.align(orig_offset, align)
+          size = offset - orig_offset
+          offset += (PackInfo::SIZE_MAP[t[0]] * t[1])
+        else
+          align = PackInfo::ALIGN_MAP[t]
+          offset = PackInfo.align(orig_offset, align)
+          size = offset - orig_offset
+          offset += PackInfo::SIZE_MAP[t]
+        end
+        if (max_align < align)
+          max_align = align
+        end
+      }
+      offset = PackInfo.align(offset, max_align)
+      offset
+    end
+
+    def initialize(addr, types, func = nil)
+      set_ctypes(types)
+      super(addr, @size, func)
+    end
+
+    def assign_names(members)
+      @members = members
+    end
+
+    def set_ctypes(types)
+      @ctypes = types
+      @offset = []
+      offset = 0
+      max_align = 0
+      types.each_with_index{|t,i|
+        orig_offset = offset
+        if( t.is_a?(Array) )
+          align = ALIGN_MAP[t[0]]
+        else
+          align = ALIGN_MAP[t]
+        end
+        offset = PackInfo.align(orig_offset, align)
+        size = offset - orig_offset
+        @offset[i] = offset
+        if( t.is_a?(Array) )
+          offset += (SIZE_MAP[t[0]] * t[1])
+        else
+          offset += SIZE_MAP[t]
+        end
+        if (max_align < align)
+          max_align = align
+        end
+      }
+      offset = PackInfo.align(offset, max_align)
+      @size = offset
+    end
+
+    def [](name)
+      idx = @members.index(name)
+      if( idx.nil? )
+        raise(ArgumentError, "no such member: #{name}")
+      end
+      ty = @ctypes[idx]
+      if( ty.is_a?(Array) )
+        r = super(@offset[idx], SIZE_MAP[ty[0]] * ty[1])
+      else
+        r = super(@offset[idx], SIZE_MAP[ty.abs])
+      end
+      packer = Packer.new([ty])
+      val = packer.unpack([r])
+      case ty
+      when Array
+        case ty[0]
+        when TYPE_VOIDP
+          val = val.collect{|v| CPtr.new(v)}
+        end
+      when TYPE_VOIDP
+        val = CPtr.new(val[0])
+      else
+        val = val[0]
+      end
+      if( ty.is_a?(Integer) && (ty < 0) )
+        return unsigned_value(val, ty)
+      elsif( ty.is_a?(Array) && (ty[0] < 0) )
+        return val.collect{|v| unsigned_value(v,ty[0])}
+      else
+        return val
+      end
+    end
+
+    def []=(name, val)
+      idx = @members.index(name)
+      if( idx.nil? )
+        raise(ArgumentError, "no such member: #{name}")
+      end
+      ty  = @ctypes[idx]
+      packer = Packer.new([ty])
+      val = wrap_arg(val, ty, [])
+      buff = packer.pack([val].flatten())
+      super(@offset[idx], buff.size, buff)
+      if( ty.is_a?(Integer) && (ty < 0) )
+        return unsigned_value(val, ty)
+      elsif( ty.is_a?(Array) && (ty[0] < 0) )
+        return val.collect{|v| unsigned_value(v,ty[0])}
+      else
+        return val
+      end
+    end
+
+    def to_s()
+      super(@size)
+    end
+  end
+
+  class CUnionEntity < CStructEntity
+    include PackInfo
+
+    def CUnionEntity.malloc(types, func=nil)
+      addr = DL.malloc(CUnionEntity.size(types))
+      CUnionEntity.new(addr, types, func)
+    end
+
+    def CUnionEntity.size(types)
+      size   = 0
+      types.each_with_index{|t,i|
+        if( t.is_a?(Array) )
+          tsize = PackInfo::SIZE_MAP[t[0]] * t[1]
+        else
+          tsize = PackInfo::SIZE_MAP[t]
+        end
+        if( tsize > size )
+          size = tsize
+        end
+      }
+    end
+
+    def set_ctypes(types)
+      @ctypes = types
+      @offset = []
+      @size   = 0
+      types.each_with_index{|t,i|
+        @offset[i] = 0
+        if( t.is_a?(Array) )
+          size = SIZE_MAP[t[0]] * t[1]
+        else
+          size = SIZE_MAP[t]
+        end
+        if( size > @size )
+          @size = size
+        end
+      }
+    end
+  end
+end
+
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/types.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/types.rb
new file mode 100644 (file)
index 0000000..b85ac89
--- /dev/null
@@ -0,0 +1,40 @@
+module DL
+  module Win32Types
+    def included(m)
+      m.module_eval{
+        typealias "DWORD", "unsigned long"
+        typealias "PDWORD", "unsigned long *"
+        typealias "WORD", "unsigned short"
+        typealias "PWORD", "unsigned short *"
+        typealias "BOOL", "int"
+        typealias "ATOM", "int"
+        typealias "BYTE", "unsigned char"
+        typealias "PBYTE", "unsigned char *"
+        typealias "UINT", "unsigned int"
+        typealias "ULONG", "unsigned long"
+        typealias "UCHAR", "unsigned char"
+        typealias "HANDLE", "unsigned long"
+        typealias "PHANDLE", "void*"
+        typealias "PVOID", "void*"
+        typealias "LPCSTR", "char*"
+        typealias "LPSTR", "char*"
+        typealias "HINSTANCE", "unsigned int"
+        typealias "HDC", "unsigned int"
+        typealias "HWND", "unsigned int"
+      }
+    end
+    module_function :included
+  end
+
+  module BasicTypes
+    def included(m)
+      m.module_eval{
+        typealias "uint", "unsigned int"
+        typealias "u_int", "unsigned int"
+        typealias "ulong", "unsigned long"
+        typealias "u_long", "unsigned long"
+      }
+    end
+    module_function :included
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/dl/value.rb b/lib/ruby-1.9.1-rc1/.ext/common/dl/value.rb
new file mode 100644 (file)
index 0000000..aa7e0dd
--- /dev/null
@@ -0,0 +1,108 @@
+require 'dl'
+
+module DL
+  module ValueUtil
+    def unsigned_value(val, ty)
+      case ty.abs
+      when TYPE_CHAR
+        [val].pack("c").unpack("C")[0]
+      when TYPE_SHORT
+        [val].pack("s!").unpack("S!")[0]
+      when TYPE_INT
+        [val].pack("i!").unpack("I!")[0]
+      when TYPE_LONG
+        [val].pack("l!").unpack("L!")[0]
+      when TYPE_LONG_LONG
+        [val].pack("q!").unpack("Q!")[0]
+      else
+        val
+      end
+    end
+
+    def signed_value(val, ty)
+      case ty.abs
+      when TYPE_CHAR
+        [val].pack("C").unpack("c")[0]
+      when TYPE_SHORT
+        [val].pack("S!").unpack("s!")[0]
+      when TYPE_INT
+        [val].pack("I!").unpack("i!")[0]
+      when TYPE_LONG
+        [val].pack("L!").unpack("l!")[0]
+      when TYPE_LONG_LONG
+        [val].pack("Q!").unpack("q!")[0]
+      else
+        val
+      end
+    end
+
+    def wrap_args(args, tys, funcs, &block)
+      result = []
+      tys ||= []
+      args.each_with_index{|arg, idx|
+        result.push(wrap_arg(arg, tys[idx], funcs, &block))
+      }
+      result
+    end
+
+    def wrap_arg(arg, ty, funcs, &block)
+        funcs ||= []
+        case arg
+        when CPtr
+          return arg.to_i
+        when IO
+          case ty
+          when TYPE_VOIDP
+            return CPtr[arg].to_i
+          else
+            return arg.to_i
+          end
+        when Function
+          if( block )
+            arg.bind_at_call(&block)
+            funcs.push(arg)
+          end
+          return arg.to_i
+        when String
+          if( ty.is_a?(Array) )
+            return arg.unpack('C*')
+          else
+            case SIZEOF_VOIDP
+            when SIZEOF_LONG
+              return [arg].pack("p").unpack("l!")[0]
+            when SIZEOF_LONG_LONG
+              return [arg].pack("p").unpack("q")[0]
+            else
+              raise(RuntimeError, "sizeof(void*)?")
+            end
+          end
+        when Float, Integer
+          return arg
+        when Array
+          if( ty.is_a?(Array) ) # used only by struct
+            case ty[0]
+            when TYPE_VOIDP
+              return arg.collect{|v| Integer(v)}
+            when TYPE_CHAR
+              if( arg.is_a?(String) )
+                return val.unpack('C*')
+              end
+            end
+            return arg
+          else
+            return arg
+          end
+        else
+          if( arg.respond_to?(:to_ptr) )
+            return arg.to_ptr.to_i
+          else
+            begin
+              return Integer(arg)
+            rescue
+              raise(ArgumentError, "unknown argument type: #{arg.class}")
+            end
+          end
+        end
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/expect.rb b/lib/ruby-1.9.1-rc1/.ext/common/expect.rb
new file mode 100644 (file)
index 0000000..08191b0
--- /dev/null
@@ -0,0 +1,36 @@
+$expect_verbose = false
+
+class IO
+  def expect(pat,timeout=9999999)
+    buf = ''
+    case pat
+    when String
+      e_pat = Regexp.new(Regexp.quote(pat))
+    when Regexp
+      e_pat = pat
+    end
+    while true
+      if !IO.select([self],nil,nil,timeout) or eof? then
+        result = nil
+        break
+      end
+      c = getc.chr
+      buf << c
+      if $expect_verbose
+        STDOUT.print c
+        STDOUT.flush
+      end
+      if mat=e_pat.match(buf) then
+        result = [buf,*mat.to_a[1..-1]]
+        break
+      end
+    end
+    if block_given? then
+      yield result
+    else
+      return result
+    end
+    nil
+  end
+end
+
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/io/nonblock.rb b/lib/ruby-1.9.1-rc1/.ext/common/io/nonblock.rb
new file mode 100644 (file)
index 0000000..2103fdf
--- /dev/null
@@ -0,0 +1,23 @@
+require "fcntl"
+class IO
+  def nonblock?
+    (fcntl(Fcntl::F_GETFL) & File::NONBLOCK) != 0
+  end
+
+  def nonblock=(nb)
+    f = fcntl(Fcntl::F_GETFL)
+    if nb
+      f |= File::NONBLOCK
+    else
+      f &= ~File::NONBLOCK
+    end
+    fcntl(Fcntl::F_SETFL, f)
+  end
+
+  def nonblock(nb = true)
+    nb, self.nonblock = nonblock?, nb
+    yield
+  ensure
+    self.nonblock = nb
+  end
+end if defined?(Fcntl::F_GETFL)
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json.rb b/lib/ruby-1.9.1-rc1/.ext/common/json.rb
new file mode 100644 (file)
index 0000000..3b0b711
--- /dev/null
@@ -0,0 +1,235 @@
+require 'json/common'
+# = json - JSON for Ruby
+#
+# == Description
+#
+# This is a implementation of the JSON specification according to RFC 4627
+# (http://www.ietf.org/rfc/rfc4627.txt). Starting from version 1.0.0 on there
+# will be two variants available:
+#
+# * A pure ruby variant, that relies on the iconv and the stringscan
+#   extensions, which are both part of the ruby standard library.
+# * The quite a bit faster C extension variant, which is in parts implemented
+#   in C and comes with its own unicode conversion functions and a parser
+#   generated by the ragel state machine compiler
+#   (http://www.cs.queensu.ca/~thurston/ragel).
+#
+# Both variants of the JSON generator escape all non-ASCII an control
+# characters with \uXXXX escape sequences, and support UTF-16 surrogate pairs
+# in order to be able to generate the whole range of unicode code points. This
+# means that generated JSON text is encoded as UTF-8 (because ASCII is a subset
+# of UTF-8) and at the same time avoids decoding problems for receiving
+# endpoints, that don't expect UTF-8 encoded texts. On the negative side this
+# may lead to a bit longer strings than necessarry.
+#
+# All strings, that are to be encoded as JSON strings, should be UTF-8 byte
+# sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
+# encoded, please use the to_json_raw_object method of String (which produces
+# an object, that contains a byte array) and decode the result on the receiving
+# endpoint.
+#
+# == Author
+#
+# Florian Frank <mailto:flori@ping.de>
+#
+# == License
+#
+# This software is distributed under the same license as Ruby itself, see
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+# == Download
+#
+# The latest version of this library can be downloaded at
+#
+# * http://rubyforge.org/frs?group_id=953
+#
+# Online Documentation should be located at
+#
+# * http://json.rubyforge.org
+#
+# == Usage
+# 
+# To use JSON you can
+#   require 'json'
+# to load the installed variant (either the extension 'json' or the pure
+# variant 'json_pure'). If you have installed the extension variant, you can
+# pick either the extension variant or the pure variant by typing
+#   require 'json/ext'
+# or
+#   require 'json/pure'
+#
+# You can choose to load a set of common additions to ruby core's objects if
+# you
+#   require 'json/add/core'
+#
+# After requiring this you can, e. g., serialise/deserialise Ruby ranges:
+#
+#   JSON JSON(1..10) # => 1..10
+#
+# To find out how to add JSON support to other or your own classes, read the
+# Examples section below.
+#
+# To get the best compatibility to rails' JSON implementation, you can
+#   require 'json/add/rails'
+#
+# Both of the additions attempt to require 'json' (like above) first, if it has
+# not been required yet.
+#
+# == Speed Comparisons
+#
+# I have created some benchmark results (see the benchmarks subdir of the
+# package) for the JSON-Parser to estimate the speed up in the C extension:
+#
+# JSON::Pure::Parser::  28.90  calls/second
+# JSON::Ext::Parser::  505.50 calls/second
+#
+# This is ca. <b>17.5</b> times the speed of the pure Ruby implementation.
+#
+# I have benchmarked the JSON-Generator as well. This generates a few more
+# values, because there are different modes, that also influence the achieved
+# speed:
+#
+# * JSON::Pure::Generator:
+#   generate::        35.06 calls/second
+#   pretty_generate:: 34.00 calls/second
+#   fast_generate::   41.06 calls/second
+#
+# * JSON::Ext::Generator:
+#   generate::        492.11 calls/second
+#   pretty_generate:: 348.85 calls/second
+#   fast_generate::   541.60 calls/second
+#
+# * Speedup Ext/Pure:
+#   generate safe::   14.0 times
+#   generate pretty:: 10.3 times
+#   generate fast::   13.2 times
+#
+# The rails framework includes a generator as well, also it seems to be rather
+# slow: I measured only 23.87 calls/second which is slower than any of my pure
+# generator results. Here a comparison of the different speedups with the Rails
+# measurement as the divisor:
+#
+# * Speedup Pure/Rails:
+#   generate safe::   1.5 times
+#   generate pretty:: 1.4 times
+#   generate fast::   1.7 times
+#
+# * Speedup Ext/Rails:
+#   generate safe::   20.6 times
+#   generate pretty:: 14.6 times
+#   generate fast::   22.7 times
+#
+# To achieve the fastest JSON text output, you can use the
+# fast_generate/fast_unparse methods. Beware, that this will disable the
+# checking for circular Ruby data structures, which may cause JSON to go into
+# an infinite loop.
+#
+# == Examples
+#
+# To create a JSON text from a ruby data structure, you
+# can call JSON.generate (or JSON.unparse) like that:
+#
+#  json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#  # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
+#
+# To create a valid JSON text you have to make sure, that the output is
+# embedded in either a JSON array [] or a JSON object {}. The easiest way to do
+# this, is by putting your values in a Ruby Array or Hash instance.
+#
+# To get back a ruby data structure from a JSON text, you have to call
+# JSON.parse on it:
+#
+#  JSON.parse json
+#  # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
+# 
+# Note, that the range from the original data structure is a simple
+# string now. The reason for this is, that JSON doesn't support ranges
+# or arbitrary classes. In this case the json library falls back to call
+# Object#to_json, which is the same as #to_s.to_json.
+#
+# It's possible to add JSON support serialization to arbitrary classes by
+# simply implementing a more specialized version of the #to_json method, that
+# should return a JSON object (a hash converted to JSON with #to_json) like
+# this (don't forget the *a for all the arguments):
+#
+#  class Range
+#    def to_json(*a)
+#      {
+#        'json_class'   => self.class.name, # = 'Range'
+#        'data'         => [ first, last, exclude_end? ]
+#      }.to_json(*a)
+#    end
+#  end
+#
+# The hash key 'json_class' is the class, that will be asked to deserialise the
+# JSON representation later. In this case it's 'Range', but any namespace of
+# the form 'A::B' or '::A::B' will do. All other keys are arbitrary and can be
+# used to store the necessary data to configure the object to be deserialised.
+#
+# If a the key 'json_class' is found in a JSON object, the JSON parser checks
+# if the given class responds to the json_create class method. If so, it is
+# called with the JSON object converted to a Ruby hash. So a range can
+# be deserialised by implementing Range.json_create like this:
+# 
+#  class Range
+#    def self.json_create(o)
+#      new(*o['data'])
+#    end
+#  end
+#
+# Now it possible to serialise/deserialise ranges as well:
+#
+#  json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#  # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
+#  JSON.parse json
+#  # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#
+# JSON.generate always creates the shortest possible string representation of a
+# ruby data structure in one line. This good for data storage or network
+# protocols, but not so good for humans to read. Fortunately there's also
+# JSON.pretty_generate (or JSON.pretty_generate) that creates a more
+# readable output:
+#
+#  puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
+#  [
+#    1,
+#    2,
+#    {
+#      "a": 3.141
+#    },
+#    false,
+#    true,
+#    null,
+#    {
+#      "json_class": "Range",
+#      "data": [
+#        4,
+#        10,
+#        false
+#      ]
+#    }
+#  ]
+#
+# There are also the methods Kernel#j for unparse, and Kernel#jj for
+# pretty_unparse output to the console, that work analogous to Core Ruby's p
+# and the pp library's pp methods.
+#
+# The script tools/server.rb contains a small example if you want to test, how
+# receiving a JSON object from a webrick server in your browser with the
+# javasript prototype library (http://www.prototypejs.org) works.
+#
+module JSON
+  require 'json/version'
+
+  if VARIANT_BINARY
+    require 'json/ext'
+  else
+    begin
+      require 'json/ext'
+    rescue LoadError
+      require 'json/pure'
+    end
+  end
+
+  JSON_LOADED = true
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/add/core.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/add/core.rb
new file mode 100644 (file)
index 0000000..7121a77
--- /dev/null
@@ -0,0 +1,135 @@
+# This file contains implementations of ruby core's custom objects for
+# serialisation/deserialisation.
+
+unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
+  ::JSON::JSON_LOADED
+  require 'json'
+end
+require 'date'
+
+class Time
+  def self.json_create(object)
+    if usec = object.delete('u') # used to be tv_usec -> tv_nsec
+      object['n'] = usec * 1000
+    end
+    if respond_to?(:tv_nsec)
+      at(*object.values_at('s', 'n'))
+    else
+      at(object['s'], object['n'] / 1000)
+    end
+  end
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      's' => tv_sec,
+      'n' => respond_to?(:tv_nsec) ? tv_nsec : tv_usec * 1000
+    }.to_json(*args)
+  end
+end
+
+class Date
+  def self.json_create(object)
+    civil(*object.values_at('y', 'm', 'd', 'sg'))
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'sg' => start,
+    }.to_json(*args)
+  end
+end
+
+class DateTime
+  def self.json_create(object)
+    args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
+    of_a, of_b = object['of'].split('/')
+    if of_b and of_b != '0'
+      args << Rational(of_a.to_i, of_b.to_i)
+    else
+      args << of_a
+    end
+    args << object['sg']
+    civil(*args)
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'H' => hour,
+      'M' => min,
+      'S' => sec,
+      'of' => offset.to_s,
+      'sg' => start,
+    }.to_json(*args)
+  end
+end
+
+class Range
+  def self.json_create(object)
+    new(*object['a'])
+  end
+
+  def to_json(*args)
+    {
+      'json_class'   => self.class.name,
+      'a'         => [ first, last, exclude_end? ]
+    }.to_json(*args)
+  end
+end
+
+class Struct
+  def self.json_create(object)
+    new(*object['v'])
+  end
+
+  def to_json(*args)
+    klass = self.class.name
+    klass.nil? and raise JSON::JSONError, "Only named structs are supported!"
+    {
+      'json_class' => klass,
+      'v'     => values,
+    }.to_json(*args)
+  end
+end
+
+class Exception
+  def self.json_create(object)
+    result = new(object['m'])
+    result.set_backtrace object['b']
+    result
+  end
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      'm'   => message,
+      'b' => backtrace,
+    }.to_json(*args)
+  end
+end
+
+class Regexp
+  def self.json_create(object)
+    new(object['s'], object['o'])
+  end
+
+  def to_json(*)
+    {
+      'json_class' => self.class.name,
+      'o' => options,
+      's' => source,
+    }.to_json
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/add/rails.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/add/rails.rb
new file mode 100644 (file)
index 0000000..e86ed1a
--- /dev/null
@@ -0,0 +1,58 @@
+# This file contains implementations of rails custom objects for
+# serialisation/deserialisation.
+
+unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
+  ::JSON::JSON_LOADED
+  require 'json'
+end
+
+class Object
+  def self.json_create(object)
+    obj = new
+    for key, value in object
+      next if key == 'json_class'
+      instance_variable_set "@#{key}", value
+    end
+    obj
+  end
+
+  def to_json(*a)
+    result = {
+      'json_class' => self.class.name
+    }
+    instance_variables.inject(result) do |r, name|
+      r[name[1..-1]] = instance_variable_get name
+      r
+    end
+    result.to_json(*a)
+  end
+end
+
+class Symbol
+  def to_json(*a)
+    to_s.to_json(*a)
+  end
+end
+
+module Enumerable
+  def to_json(*a)
+    to_a.to_json(*a)
+  end
+end
+
+# class Regexp
+#   def to_json(*)
+#     inspect
+#   end
+# end
+#
+# The above rails definition has some problems:
+#
+# 1. { 'foo' => /bar/ }.to_json # => "{foo: /bar/}"
+#    This isn't valid JSON, because the regular expression syntax is not
+#    defined in RFC 4627. (And unquoted strings are disallowed there, too.)
+#    Though it is valid Javascript.
+#
+# 2. { 'foo' => /bar/mix }.to_json # => "{foo: /bar/mix}"
+#    This isn't even valid Javascript.
+
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/common.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/common.rb
new file mode 100644 (file)
index 0000000..499fcc0
--- /dev/null
@@ -0,0 +1,354 @@
+require 'json/version'
+
+module JSON
+  class << self
+    # If _object_ is string-like parse the string and return the parsed result
+    # as a Ruby data structure. Otherwise generate a JSON text from the Ruby
+    # data structure object and return it.
+    #
+    # The _opts_ argument is passed through to generate/parse respectively, see
+    # generate and parse for their documentation.
+    def [](object, opts = {})
+      if object.respond_to? :to_str
+        JSON.parse(object.to_str, opts => {})
+      else
+        JSON.generate(object, opts => {})
+      end
+    end
+
+    # Returns the JSON parser class, that is used by JSON. This might be either
+    # JSON::Ext::Parser or JSON::Pure::Parser.
+    attr_reader :parser
+
+    # Set the JSON parser class _parser_ to be used by JSON.
+    def parser=(parser) # :nodoc:
+      @parser = parser
+      remove_const :Parser if const_defined? :Parser
+      const_set :Parser, parser
+    end
+
+    # Return the constant located at _path_. The format of _path_ has to be
+    # either ::A::B::C or A::B::C. In any case A has to be located at the top
+    # level (absolute namespace path?). If there doesn't exist a constant at
+    # the given path, an ArgumentError is raised.
+    def deep_const_get(path) # :nodoc:
+      path = path.to_s
+      path.split(/::/).inject(Object) do |p, c|
+        case
+        when c.empty?             then p
+        when p.const_defined?(c)  then p.const_get(c)
+        else                      raise ArgumentError, "can't find const #{path}"
+        end
+      end
+    end
+
+    # Set the module _generator_ to be used by JSON.
+    def generator=(generator) # :nodoc:
+      @generator = generator
+      generator_methods = generator::GeneratorMethods
+      for const in generator_methods.constants
+        klass = deep_const_get(const)
+        modul = generator_methods.const_get(const)
+        klass.class_eval do
+          instance_methods(false).each do |m|
+            m.to_s == 'to_json' and remove_method m
+          end
+          include modul
+        end
+      end
+      self.state = generator::State
+      const_set :State, self.state
+    end
+
+    # Returns the JSON generator modul, that is used by JSON. This might be
+    # either JSON::Ext::Generator or JSON::Pure::Generator.
+    attr_reader :generator
+
+    # Returns the JSON generator state class, that is used by JSON. This might
+    # be either JSON::Ext::Generator::State or JSON::Pure::Generator::State.
+    attr_accessor :state
+
+    # This is create identifier, that is used to decide, if the _json_create_
+    # hook of a class should be called. It defaults to 'json_class'.
+    attr_accessor :create_id
+  end
+  self.create_id = 'json_class'
+
+  NaN           = (-1.0) ** 0.5
+
+  Infinity      = 1.0/0
+
+  MinusInfinity = -Infinity
+
+  # The base exception for JSON errors.
+  class JSONError < StandardError; end
+
+  # This exception is raised, if a parser error occurs.
+  class ParserError < JSONError; end
+
+  # This exception is raised, if the nesting of parsed datastructures is too
+  # deep.
+  class NestingError < ParserError; end
+
+  # This exception is raised, if a generator or unparser error occurs.
+  class GeneratorError < JSONError; end
+  # For backwards compatibility
+  UnparserError = GeneratorError
+
+  # If a circular data structure is encountered while unparsing
+  # this exception is raised.
+  class CircularDatastructure < GeneratorError; end
+
+  # This exception is raised, if the required unicode support is missing on the
+  # system. Usually this means, that the iconv library is not installed.
+  class MissingUnicodeSupport < JSONError; end
+
+  module_function
+
+  # Parse the JSON string _source_ into a Ruby data structure and return it.
+  #
+  # _opts_ can have the following
+  # keys:
+  # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+  #   structures. Disable depth checking with :max_nesting => false, it defaults
+  #   to 19.
+  # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+  #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+  #   to false.
+  # * *create_additions*: If set to false, the Parser doesn't create
+  #   additions even if a matchin class and create_id was found. This option
+  #   defaults to true.
+  def parse(source, opts = {})
+    JSON.parser.new(source, opts).parse
+  end
+
+  # Parse the JSON string _source_ into a Ruby data structure and return it.
+  # The bang version of the parse method, defaults to the more dangerous values
+  # for the _opts_ hash, so be sure only to parse trusted _source_ strings.
+  #
+  # _opts_ can have the following keys:
+  # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+  #   structures. Enable depth checking with :max_nesting => anInteger. The parse!
+  #   methods defaults to not doing max depth checking: This can be dangerous,
+  #   if someone wants to fill up your stack.
+  # * *allow_nan*: If set to true, allow NaN, Infinity, and -Infinity in
+  #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+  #   to true.
+  # * *create_additions*: If set to false, the Parser doesn't create
+  #   additions even if a matchin class and create_id was found. This option
+  #   defaults to true.
+  def parse!(source, opts = {})
+    opts = {
+      :max_nesting => false,
+      :allow_nan => true
+    }.update(opts)
+    JSON.parser.new(source, opts).parse
+  end
+
+  # Unparse the Ruby data structure _obj_ into a single line JSON string and
+  # return it. _state_ is
+  # * a JSON::State object,
+  # * or a Hash like object (responding to to_hash),
+  # * an object convertible into a hash by a to_h method,
+  # that is used as or to configure a State object.
+  #
+  # It defaults to a state object, that creates the shortest possible JSON text
+  # in one line, checks for circular data structures and doesn't allow NaN,
+  # Infinity, and -Infinity.
+  #
+  # A _state_ hash can have the following keys:
+  # * *indent*: a string used to indent levels (default: ''),
+  # * *space*: a string that is put after, a : or , delimiter (default: ''),
+  # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+  # * *object_nl*: a string that is put at the end of a JSON object (default: ''), 
+  # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+  # * *check_circular*: true if checking for circular data structures
+  #   should be done (the default), false otherwise.
+  # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+  #   generated, otherwise an exception is thrown, if these values are
+  #   encountered. This options defaults to false.
+  # * *max_nesting*: The maximum depth of nesting allowed in the data
+  #   structures from which JSON is to be generated. Disable depth checking
+  #   with :max_nesting => false, it defaults to 19.
+  #
+  # See also the fast_generate for the fastest creation method with the least
+  # amount of sanity checks, and the pretty_generate method for some
+  # defaults for a pretty output.
+  def generate(obj, state = nil)
+    if state
+      state = State.from_state(state)
+    else
+      state = State.new
+    end
+    obj.to_json(state)
+  end
+
+  # :stopdoc:
+  # I want to deprecate these later, so I'll first be silent about them, and
+  # later delete them.
+  alias unparse generate
+  module_function :unparse
+  # :startdoc:
+
+  # Unparse the Ruby data structure _obj_ into a single line JSON string and
+  # return it. This method disables the checks for circles in Ruby objects, and
+  # also generates NaN, Infinity, and, -Infinity float values.
+  #
+  # *WARNING*: Be careful not to pass any Ruby data structures with circles as
+  # _obj_ argument, because this will cause JSON to go into an infinite loop.
+  def fast_generate(obj)
+    obj.to_json(nil)
+  end
+
+  # :stopdoc:
+  # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+  alias fast_unparse fast_generate
+  module_function :fast_unparse
+  # :startdoc:
+
+  # Unparse the Ruby data structure _obj_ into a JSON string and return it. The
+  # returned string is a prettier form of the string returned by #unparse.
+  #
+  # The _opts_ argument can be used to configure the generator, see the
+  # generate method for a more detailed explanation.
+  def pretty_generate(obj, opts = nil)
+    state = JSON.state.new(
+      :indent     => '  ',
+      :space      => ' ',
+      :object_nl  => "\n",
+      :array_nl   => "\n",
+      :check_circular => true
+    )
+    if opts
+      if opts.respond_to? :to_hash
+        opts = opts.to_hash
+      elsif opts.respond_to? :to_h
+        opts = opts.to_h
+      else
+        raise TypeError, "can't convert #{opts.class} into Hash"
+      end
+      state.configure(opts)
+    end
+    obj.to_json(state)
+  end
+
+  # :stopdoc:
+  # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+  alias pretty_unparse pretty_generate
+  module_function :pretty_unparse
+  # :startdoc:
+
+  # Load a ruby data structure from a JSON _source_ and return it. A source can
+  # either be a string-like object, an IO like object, or an object responding
+  # to the read method. If _proc_ was given, it will be called with any nested
+  # Ruby object as an argument recursively in depth first order.
+  #
+  # This method is part of the implementation of the load/dump interface of
+  # Marshal and YAML.
+  def load(source, proc = nil)
+    if source.respond_to? :to_str
+      source = source.to_str
+    elsif source.respond_to? :to_io
+      source = source.to_io.read
+    else
+      source = source.read
+    end
+    result = parse(source, :max_nesting => false, :allow_nan => true)
+    recurse_proc(result, &proc) if proc
+    result
+  end
+
+  def recurse_proc(result, &proc)
+    case result
+    when Array
+      result.each { |x| recurse_proc x, &proc }
+      proc.call result
+    when Hash
+      result.each { |x, y| recurse_proc x, &proc; recurse_proc y, &proc }
+      proc.call result
+    else
+      proc.call result
+    end
+  end
+  private :recurse_proc
+  module_function :recurse_proc
+
+  alias restore load
+  module_function :restore
+
+  # Dumps _obj_ as a JSON string, i.e. calls generate on the object and returns
+  # the result.
+  #
+  # If anIO (an IO like object or an object that responds to the write method)
+  # was given, the resulting JSON is written to it.
+  #
+  # If the number of nested arrays or objects exceeds _limit_ an ArgumentError
+  # exception is raised. This argument is similar (but not exactly the
+  # same!) to the _limit_ argument in Marshal.dump.
+  #
+  # This method is part of the implementation of the load/dump interface of
+  # Marshal and YAML.
+  def dump(obj, anIO = nil, limit = nil)
+    if anIO and limit.nil?
+      anIO = anIO.to_io if anIO.respond_to?(:to_io)
+      unless anIO.respond_to?(:write)
+        limit = anIO
+        anIO = nil
+      end
+    end
+    limit ||= 0
+    result = generate(obj, :allow_nan => true, :max_nesting => limit)
+    if anIO
+      anIO.write result
+      anIO
+    else
+      result
+    end
+  rescue JSON::NestingError
+    raise ArgumentError, "exceed depth limit"
+  end
+end
+
+module ::Kernel
+  # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
+  # one line.
+  def j(*objs)
+    objs.each do |obj|
+      puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
+    end
+    nil
+  end
+
+  # Ouputs _objs_ to STDOUT as JSON strings in a pretty format, with
+  # indentation and over many lines.
+  def jj(*objs)
+    objs.each do |obj|
+      puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
+    end
+    nil
+  end
+
+  # If _object_ is string-like parse the string and return the parsed result as
+  # a Ruby data structure. Otherwise generate a JSON text from the Ruby data
+  # structure object and return it.
+  #
+  # The _opts_ argument is passed through to generate/parse respectively, see
+  # generate and parse for their documentation.
+  def JSON(object, opts = {})
+    if object.respond_to? :to_str
+      JSON.parse(object.to_str, opts)
+    else
+      JSON.generate(object, opts)
+    end
+  end
+end
+
+class ::Class
+  # Returns true, if this class can be used to create an instance
+  # from a serialised JSON string. The class has to implement a class
+  # method _json_create_ that expects a hash as first parameter, which includes
+  # the required data.
+  def json_creatable?
+    respond_to?(:json_create)
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/editor.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/editor.rb
new file mode 100644 (file)
index 0000000..12a7f94
--- /dev/null
@@ -0,0 +1,1362 @@
+# To use the GUI JSON editor, start the edit_json.rb executable script. It
+# requires ruby-gtk to be installed.
+
+require 'gtk2'
+require 'iconv'
+require 'json'
+require 'rbconfig'
+require 'open-uri'
+
+module JSON
+  module Editor
+    include Gtk
+
+    # Beginning of the editor window title
+    TITLE                 = 'JSON Editor'.freeze
+
+    # Columns constants
+    ICON_COL, TYPE_COL, CONTENT_COL = 0, 1, 2
+
+    # JSON primitive types (Containers)
+    CONTAINER_TYPES = %w[Array Hash].sort
+    # All JSON primitive types
+    ALL_TYPES = (%w[TrueClass FalseClass Numeric String NilClass] +
+                 CONTAINER_TYPES).sort
+
+    # The Nodes necessary for the tree representation of a JSON document
+    ALL_NODES = (ALL_TYPES + %w[Key]).sort
+
+    DEFAULT_DIALOG_KEY_PRESS_HANDLER = lambda do |dialog, event|
+      case event.keyval
+      when Gdk::Keyval::GDK_Return
+        dialog.response Dialog::RESPONSE_ACCEPT
+      when Gdk::Keyval::GDK_Escape
+        dialog.response Dialog::RESPONSE_REJECT
+      end
+    end
+
+    # Returns the Gdk::Pixbuf of the icon named _name_ from the icon cache.
+    def Editor.fetch_icon(name)
+      @icon_cache ||= {}
+      unless @icon_cache.key?(name)
+        path = File.dirname(__FILE__)
+        @icon_cache[name] = Gdk::Pixbuf.new(File.join(path, name + '.xpm'))
+      end
+     @icon_cache[name]
+    end
+
+    # Opens an error dialog on top of _window_ showing the error message
+    # _text_.
+    def Editor.error_dialog(window, text)
+      dialog = MessageDialog.new(window, Dialog::MODAL, 
+        MessageDialog::ERROR, 
+        MessageDialog::BUTTONS_CLOSE, text)
+      dialog.show_all
+      dialog.run
+    rescue TypeError
+      dialog = MessageDialog.new(Editor.window, Dialog::MODAL, 
+        MessageDialog::ERROR, 
+        MessageDialog::BUTTONS_CLOSE, text)
+      dialog.show_all
+      dialog.run
+    ensure
+      dialog.destroy if dialog
+    end
+
+    # Opens a yes/no question dialog on top of _window_ showing the error
+    # message _text_. If yes was answered _true_ is returned, otherwise
+    # _false_.
+    def Editor.question_dialog(window, text)
+      dialog = MessageDialog.new(window, Dialog::MODAL, 
+        MessageDialog::QUESTION, 
+        MessageDialog::BUTTONS_YES_NO, text)
+      dialog.show_all
+      dialog.run do |response|
+        return Gtk::Dialog::RESPONSE_YES === response
+      end
+    ensure
+      dialog.destroy if dialog
+    end
+
+    # Convert the tree model starting from Gtk::TreeIter _iter_ into a Ruby
+    # data structure and return it.
+    def Editor.model2data(iter)
+      return nil if iter.nil?
+      case iter.type
+      when 'Hash'
+        hash = {}
+        iter.each { |c| hash[c.content] = Editor.model2data(c.first_child) }
+        hash
+      when 'Array'
+        array = Array.new(iter.n_children)
+        iter.each_with_index { |c, i| array[i] = Editor.model2data(c) }
+        array
+      when 'Key'
+        iter.content
+      when 'String'
+        iter.content
+      when 'Numeric'
+        content = iter.content
+        if /\./.match(content)
+          content.to_f
+        else
+          content.to_i
+        end
+      when 'TrueClass'
+        true
+      when 'FalseClass'
+        false
+      when 'NilClass'
+        nil
+      else
+        fail "Unknown type found in model: #{iter.type}"
+      end
+    end
+
+    # Convert the Ruby data structure _data_ into tree model data for Gtk and
+    # returns the whole model. If the parameter _model_ wasn't given a new
+    # Gtk::TreeStore is created as the model. The _parent_ parameter specifies
+    # the parent node (iter, Gtk:TreeIter instance) to which the data is
+    # appended, alternativeley the result of the yielded block is used as iter.
+    def Editor.data2model(data, model = nil, parent = nil)
+      model ||= TreeStore.new(Gdk::Pixbuf, String, String)
+      iter = if block_given?
+        yield model
+      else
+        model.append(parent)
+      end
+      case data
+      when Hash
+        iter.type = 'Hash'
+        data.sort.each do |key, value|
+          pair_iter = model.append(iter)
+          pair_iter.type    = 'Key'
+          pair_iter.content = key.to_s
+          Editor.data2model(value, model, pair_iter)
+        end
+      when Array
+        iter.type = 'Array'
+        data.each do |value|
+          Editor.data2model(value, model, iter)
+        end
+      when Numeric
+        iter.type = 'Numeric'
+        iter.content = data.to_s
+      when String, true, false, nil
+        iter.type    = data.class.name
+        iter.content = data.nil? ? 'null' : data.to_s
+      else
+        iter.type    = 'String'
+        iter.content = data.to_s
+      end
+      model
+    end
+
+    # The Gtk::TreeIter class is reopened and some auxiliary methods are added.
+    class Gtk::TreeIter
+      include Enumerable
+
+      # Traverse each of this Gtk::TreeIter instance's children
+      # and yield to them.
+      def each
+        n_children.times { |i| yield nth_child(i) }
+      end
+
+      # Recursively traverse all nodes of this Gtk::TreeIter's subtree
+      # (including self) and yield to them.
+      def recursive_each(&block)
+        yield self
+        each do |i|
+          i.recursive_each(&block)
+        end
+      end
+
+      # Remove the subtree of this Gtk::TreeIter instance from the
+      # model _model_.
+      def remove_subtree(model)
+        while current = first_child
+          model.remove(current)
+        end
+      end
+
+      # Returns the type of this node.
+      def type
+        self[TYPE_COL]
+      end
+
+      # Sets the type of this node to _value_. This implies setting
+      # the respective icon accordingly.
+      def type=(value)
+        self[TYPE_COL] = value
+        self[ICON_COL] = Editor.fetch_icon(value)
+      end
+
+      # Returns the content of this node.
+      def content
+        self[CONTENT_COL]
+      end
+
+      # Sets the content of this node to _value_.
+      def content=(value)
+        self[CONTENT_COL] = value
+      end
+    end
+
+    # This module bundles some method, that can be used to create a menu. It
+    # should be included into the class in question.
+    module MenuExtension
+      include Gtk
+
+      # Creates a Menu, that includes MenuExtension. _treeview_ is the
+      # Gtk::TreeView, on which it operates.
+      def initialize(treeview)
+        @treeview = treeview
+        @menu = Menu.new
+      end
+
+      # Returns the Gtk::TreeView of this menu.
+      attr_reader :treeview
+
+      # Returns the menu.
+      attr_reader :menu
+
+      # Adds a Gtk::SeparatorMenuItem to this instance's #menu.
+      def add_separator
+        menu.append SeparatorMenuItem.new
+      end
+
+      # Adds a Gtk::MenuItem to this instance's #menu. _label_ is the label
+      # string, _klass_ is the item type, and _callback_ is the procedure, that
+      # is called if the _item_ is activated.
+      def add_item(label, keyval = nil, klass = MenuItem, &callback)
+        label = "#{label} (C-#{keyval.chr})" if keyval
+        item = klass.new(label)
+        item.signal_connect(:activate, &callback)
+        if keyval
+          self.signal_connect(:'key-press-event') do |item, event|
+            if event.state & Gdk::Window::ModifierType::CONTROL_MASK != 0 and
+              event.keyval == keyval
+              callback.call item
+            end
+          end
+        end
+        menu.append item
+        item
+      end
+
+      # This method should be implemented in subclasses to create the #menu of
+      # this instance. It has to be called after an instance of this class is
+      # created, to build the menu.
+      def create
+        raise NotImplementedError
+      end
+
+      def method_missing(*a, &b)
+        treeview.__send__(*a, &b)
+      end
+    end
+
+    # This class creates the popup menu, that opens when clicking onto the
+    # treeview.
+    class PopUpMenu
+      include MenuExtension
+
+      # Change the type or content of the selected node.
+      def change_node(item)
+        if current = selection.selected
+          parent = current.parent
+          old_type, old_content = current.type, current.content
+          if ALL_TYPES.include?(old_type)
+            @clipboard_data = Editor.model2data(current)
+            type, content = ask_for_element(parent, current.type,
+              current.content)
+            if type
+              current.type, current.content = type, content
+              current.remove_subtree(model)
+              toplevel.display_status("Changed a node in tree.")
+              window.change
+            end
+          else
+            toplevel.display_status(
+              "Cannot change node of type #{old_type} in tree!")
+          end
+        end
+      end
+
+      # Cut the selected node and its subtree, and save it into the
+      # clipboard.
+      def cut_node(item)
+        if current = selection.selected
+          if current and current.type == 'Key'
+            @clipboard_data = {
+              current.content => Editor.model2data(current.first_child)
+            }
+          else
+            @clipboard_data = Editor.model2data(current)
+          end
+          model.remove(current)
+          window.change
+          toplevel.display_status("Cut a node from tree.")
+        end
+      end
+
+      # Copy the selected node and its subtree, and save it into the
+      # clipboard.
+      def copy_node(item)
+        if current = selection.selected
+          if current and current.type == 'Key'
+            @clipboard_data = {
+              current.content => Editor.model2data(current.first_child)
+            }
+          else
+            @clipboard_data = Editor.model2data(current)
+          end
+          window.change
+          toplevel.display_status("Copied a node from tree.")
+        end
+      end
+
+      # Paste the data in the clipboard into the selected Array or Hash by
+      # appending it.
+      def paste_node_appending(item)
+        if current = selection.selected
+          if @clipboard_data
+            case current.type
+            when 'Array'
+              Editor.data2model(@clipboard_data, model, current)
+              expand_collapse(current)
+            when 'Hash'
+              if @clipboard_data.is_a? Hash
+                parent = current.parent
+                hash = Editor.model2data(current)
+                model.remove(current)
+                hash.update(@clipboard_data)
+                Editor.data2model(hash, model, parent)
+                if parent
+                  expand_collapse(parent)
+                elsif @expanded
+                  expand_all
+                end
+                window.change
+              else
+                toplevel.display_status(
+                  "Cannot paste non-#{current.type} data into '#{current.type}'!")
+              end
+            else
+              toplevel.display_status(
+                "Cannot paste node below '#{current.type}'!")
+            end
+          else
+            toplevel.display_status("Nothing to paste in clipboard!")
+          end
+        else
+            toplevel.display_status("Append a node into the root first!")
+        end
+      end
+
+      # Paste the data in the clipboard into the selected Array inserting it
+      # before the selected element.
+      def paste_node_inserting_before(item)
+        if current = selection.selected
+          if @clipboard_data
+            parent = current.parent or return
+            parent_type = parent.type
+            if parent_type == 'Array'
+              selected_index = parent.each_with_index do |c, i|
+                break i if c == current
+              end
+              Editor.data2model(@clipboard_data, model, parent) do |m|
+                m.insert_before(parent, current)
+              end
+              expand_collapse(current)
+              toplevel.display_status("Inserted an element to " +
+                "'#{parent_type}' before index #{selected_index}.")
+              window.change
+            else
+              toplevel.display_status(
+                "Cannot insert node below '#{parent_type}'!")
+            end
+          else
+            toplevel.display_status("Nothing to paste in clipboard!")
+          end
+        else
+            toplevel.display_status("Append a node into the root first!")
+        end
+      end
+
+      # Append a new node to the selected Hash or Array.
+      def append_new_node(item)
+        if parent = selection.selected
+          parent_type = parent.type
+          case parent_type
+          when 'Hash'
+            key, type, content = ask_for_hash_pair(parent)
+            key or return
+            iter = create_node(parent, 'Key', key)
+            iter = create_node(iter, type, content)
+            toplevel.display_status(
+              "Added a (key, value)-pair to '#{parent_type}'.")
+            window.change
+          when 'Array'
+            type, content = ask_for_element(parent)
+            type or return
+            iter = create_node(parent, type, content)
+            window.change
+            toplevel.display_status("Appendend an element to '#{parent_type}'.")
+          else
+            toplevel.display_status("Cannot append to '#{parent_type}'!")
+          end
+        else
+          type, content = ask_for_element
+          type or return
+          iter = create_node(nil, type, content)
+          window.change
+        end
+      end
+
+      # Insert a new node into an Array before the selected element.
+      def insert_new_node(item)
+        if current = selection.selected
+          parent = current.parent or return
+          parent_parent = parent.parent
+          parent_type = parent.type
+          if parent_type == 'Array'
+            selected_index = parent.each_with_index do |c, i|
+              break i if c == current
+            end
+            type, content = ask_for_element(parent)
+            type or return
+            iter = model.insert_before(parent, current)
+            iter.type, iter.content = type, content
+            toplevel.display_status("Inserted an element to " +
+              "'#{parent_type}' before index #{selected_index}.")
+            window.change
+          else
+            toplevel.display_status(
+              "Cannot insert node below '#{parent_type}'!")
+          end
+        else
+            toplevel.display_status("Append a node into the root first!")
+        end
+      end
+
+      # Recursively collapse/expand a subtree starting from the selected node.
+      def collapse_expand(item)
+        if current = selection.selected
+          if row_expanded?(current.path)
+            collapse_row(current.path)
+          else
+            expand_row(current.path, true)
+          end
+        else
+            toplevel.display_status("Append a node into the root first!")
+        end
+      end
+
+      # Create the menu.
+      def create
+        add_item("Change node", ?n, &method(:change_node))
+        add_separator
+        add_item("Cut node", ?X, &method(:cut_node))
+        add_item("Copy node", ?C, &method(:copy_node))
+        add_item("Paste node (appending)", ?A, &method(:paste_node_appending))
+        add_item("Paste node (inserting before)", ?I,
+          &method(:paste_node_inserting_before))
+        add_separator
+        add_item("Append new node", ?a, &method(:append_new_node))
+        add_item("Insert new node before", ?i, &method(:insert_new_node))
+        add_separator 
+        add_item("Collapse/Expand node (recursively)", ?e,
+          &method(:collapse_expand))
+
+        menu.show_all
+        signal_connect(:button_press_event) do |widget, event|
+          if event.kind_of? Gdk::EventButton and event.button == 3
+            menu.popup(nil, nil, event.button, event.time)
+          end
+        end
+        signal_connect(:popup_menu) do
+          menu.popup(nil, nil, 0, Gdk::Event::CURRENT_TIME)
+        end
+      end
+    end
+
+    # This class creates the File pulldown menu.
+    class FileMenu
+      include MenuExtension
+
+      # Clear the model and filename, but ask to save the JSON document, if
+      # unsaved changes have occured.
+      def new(item)
+        window.clear
+      end
+
+      # Open a file and load it into the editor. Ask to save the JSON document
+      # first, if unsaved changes have occured.
+      def open(item)
+        window.file_open
+      end
+
+      def open_location(item)
+        window.location_open
+      end
+
+      # Revert the current JSON document in the editor to the saved version.
+      def revert(item)
+        window.instance_eval do
+          @filename and file_open(@filename) 
+        end
+      end
+
+      # Save the current JSON document.
+      def save(item)
+        window.file_save
+      end
+
+      # Save the current JSON document under the given filename.
+      def save_as(item)
+        window.file_save_as
+      end
+
+      # Quit the editor, after asking to save any unsaved changes first.
+      def quit(item)
+        window.quit
+      end
+
+      # Create the menu.
+      def create
+        title = MenuItem.new('File')
+        title.submenu = menu
+        add_item('New', &method(:new))
+        add_item('Open', ?o, &method(:open))
+        add_item('Open location', ?l, &method(:open_location))
+        add_item('Revert', &method(:revert))
+        add_separator
+        add_item('Save', ?s, &method(:save))
+        add_item('Save As', ?S, &method(:save_as))
+        add_separator
+        add_item('Quit', ?q, &method(:quit))
+        title
+      end
+    end
+
+    # This class creates the Edit pulldown menu.
+    class EditMenu
+      include MenuExtension
+
+      # Copy data from model into primary clipboard.
+      def copy(item)
+        data = Editor.model2data(model.iter_first)
+        json = JSON.pretty_generate(data, :max_nesting => false)
+        c = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+        c.text = json
+      end
+
+      # Copy json text from primary clipboard into model.
+      def paste(item)
+        c = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+        if json = c.wait_for_text
+          window.ask_save if @changed
+          begin
+            window.edit json
+          rescue JSON::ParserError
+            window.clear
+          end
+        end
+      end
+
+      # Find a string in all nodes' contents and select the found node in the
+      # treeview.
+      def find(item)
+        @search = ask_for_find_term(@search) or return
+        iter = model.get_iter('0') or return
+        iter.recursive_each do |i|
+          if @iter
+            if @iter != i
+              next
+            else
+              @iter = nil
+              next
+            end
+          elsif @search.match(i[CONTENT_COL])
+             set_cursor(i.path, nil, false)
+             @iter = i
+             break
+          end
+        end
+      end
+
+      # Repeat the last search given by #find.
+      def find_again(item)
+        @search or return
+        iter = model.get_iter('0')
+        iter.recursive_each do |i|
+          if @iter
+            if @iter != i
+              next
+            else
+              @iter = nil
+              next
+            end
+          elsif @search.match(i[CONTENT_COL])
+             set_cursor(i.path, nil, false)
+             @iter = i
+             break
+          end
+        end
+      end
+
+      # Sort (Reverse sort) all elements of the selected array by the given
+      # expression. _x_ is the element in question.
+      def sort(item)
+        if current = selection.selected
+          if current.type == 'Array'
+            parent = current.parent
+            ary = Editor.model2data(current)
+            order, reverse = ask_for_order
+            order or return
+            begin
+              block = eval "lambda { |x| #{order} }"
+              if reverse
+                ary.sort! { |a,b| block[b] <=> block[a] }
+              else
+                ary.sort! { |a,b| block[a] <=> block[b] }
+              end
+            rescue => e
+              Editor.error_dialog(self, "Failed to sort Array with #{order}: #{e}!")
+            else
+              Editor.data2model(ary, model, parent) do |m|
+                m.insert_before(parent, current)
+              end
+              model.remove(current)
+              expand_collapse(parent)
+              window.change
+              toplevel.display_status("Array has been sorted.")
+            end
+          else
+            toplevel.display_status("Only Array nodes can be sorted!")
+          end
+        else
+            toplevel.display_status("Select an Array to sort first!")
+        end
+      end
+
+      # Create the menu.
+      def create
+        title = MenuItem.new('Edit')
+        title.submenu = menu
+        add_item('Copy', ?c, &method(:copy))
+        add_item('Paste', ?v, &method(:paste))
+        add_separator
+        add_item('Find', ?f, &method(:find))
+        add_item('Find Again', ?g, &method(:find_again))
+        add_separator
+        add_item('Sort', ?S, &method(:sort))
+        title
+      end
+    end
+
+    class OptionsMenu
+      include MenuExtension
+
+      # Collapse/Expand all nodes by default.
+      def collapsed_nodes(item)
+        if expanded
+          self.expanded = false
+          collapse_all
+        else
+          self.expanded = true
+          expand_all 
+        end
+      end
+
+      # Toggle pretty saving mode on/off.
+      def pretty_saving(item)
+        @pretty_item.toggled
+        window.change
+      end
+
+      attr_reader :pretty_item
+
+      # Create the menu.
+      def create
+        title = MenuItem.new('Options')
+        title.submenu = menu
+        add_item('Collapsed nodes', nil, CheckMenuItem, &method(:collapsed_nodes))
+        @pretty_item = add_item('Pretty saving', nil, CheckMenuItem,
+          &method(:pretty_saving))
+        @pretty_item.active = true
+        window.unchange
+        title
+      end
+    end
+
+    # This class inherits from Gtk::TreeView, to configure it and to add a lot
+    # of behaviour to it.
+    class JSONTreeView < Gtk::TreeView
+      include Gtk
+
+      # Creates a JSONTreeView instance, the parameter _window_ is
+      # a MainWindow instance and used for self delegation.
+      def initialize(window)
+        @window = window
+        super(TreeStore.new(Gdk::Pixbuf, String, String))
+        self.selection.mode = SELECTION_BROWSE
+
+        @expanded = false
+        self.headers_visible = false
+        add_columns
+        add_popup_menu
+      end
+
+      # Returns the MainWindow instance of this JSONTreeView.
+      attr_reader :window
+
+      # Returns true, if nodes are autoexpanding, false otherwise.
+      attr_accessor :expanded
+
+      private
+
+      def add_columns
+        cell = CellRendererPixbuf.new
+        column = TreeViewColumn.new('Icon', cell,
+          'pixbuf'      => ICON_COL
+        )
+        append_column(column)
+
+        cell = CellRendererText.new
+        column = TreeViewColumn.new('Type', cell,
+          'text'      => TYPE_COL
+        )
+        append_column(column)
+
+        cell = CellRendererText.new
+        cell.editable = true
+        column = TreeViewColumn.new('Content', cell,
+          'text'       => CONTENT_COL
+        )
+        cell.signal_connect(:edited, &method(:cell_edited))
+        append_column(column)
+      end
+
+      def unify_key(iter, key)
+        return unless iter.type == 'Key'
+        parent = iter.parent
+        if parent.any? { |c| c != iter and c.content == key }
+          old_key = key
+          i = 0
+          begin
+            key = sprintf("%s.%d", old_key, i += 1)
+          end while parent.any? { |c| c != iter and c.content == key }
+        end
+        iter.content = key
+      end
+
+      def cell_edited(cell, path, value)
+        iter = model.get_iter(path)
+        case iter.type
+        when 'Key'
+          unify_key(iter, value)
+          toplevel.display_status('Key has been changed.')
+        when 'FalseClass'
+          value.downcase!
+          if value == 'true'
+            iter.type, iter.content = 'TrueClass', 'true'
+          end
+        when 'TrueClass'
+          value.downcase!
+          if value == 'false'
+            iter.type, iter.content = 'FalseClass', 'false'
+          end
+        when 'Numeric'
+          iter.content = (Integer(value) rescue Float(value) rescue 0).to_s
+        when 'String'
+          iter.content = value
+        when 'Hash', 'Array'
+          return
+        else
+          fail "Unknown type found in model: #{iter.type}"
+        end
+        window.change
+      end
+
+      def configure_value(value, type)
+        value.editable = false
+        case type
+        when 'Array', 'Hash'
+          value.text = ''
+        when 'TrueClass'
+          value.text = 'true'
+        when 'FalseClass'
+          value.text = 'false'
+        when 'NilClass'
+          value.text = 'null'
+        when 'Numeric', 'String'
+          value.text ||= ''
+          value.editable = true
+        else
+          raise ArgumentError, "unknown type '#{type}' encountered"
+        end
+      end
+
+      def add_popup_menu
+        menu = PopUpMenu.new(self)
+        menu.create
+      end
+
+      public
+
+      # Create a _type_ node with content _content_, and add it to _parent_
+      # in the model. If _parent_ is nil, create a new model and put it into
+      # the editor treeview.
+      def create_node(parent, type, content)
+        iter = if parent
+          model.append(parent)
+        else
+          new_model = Editor.data2model(nil)
+          toplevel.view_new_model(new_model)
+          new_model.iter_first
+        end
+        iter.type, iter.content = type, content
+        expand_collapse(parent) if parent
+        iter
+      end
+
+      # Ask for a hash key, value pair to be added to the Hash node _parent_.
+      def ask_for_hash_pair(parent)
+        key_input = type_input = value_input = nil
+
+        dialog = Dialog.new("New (key, value) pair for Hash", nil, nil,
+          [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+          [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+        )
+        dialog.width_request = 640
+
+        hbox = HBox.new(false, 5)
+        hbox.pack_start(Label.new("Key:"), false)
+        hbox.pack_start(key_input = Entry.new)
+        key_input.text = @key || ''
+        dialog.vbox.pack_start(hbox, false)
+        key_input.signal_connect(:activate) do
+          if parent.any? { |c| c.content == key_input.text }
+            toplevel.display_status('Key already exists in Hash!')
+            key_input.text = ''
+          else
+            toplevel.display_status('Key has been changed.')
+          end
+        end
+
+        hbox = HBox.new(false, 5)
+        hbox.pack_start(Label.new("Type:"), false)
+        hbox.pack_start(type_input = ComboBox.new(true))
+        ALL_TYPES.each { |t| type_input.append_text(t) }
+        type_input.active = @type || 0
+        dialog.vbox.pack_start(hbox, false)
+
+        type_input.signal_connect(:changed) do
+          value_input.editable = false
+          case ALL_TYPES[type_input.active]
+          when 'Array', 'Hash'
+            value_input.text = ''
+          when 'TrueClass'
+            value_input.text = 'true'
+          when 'FalseClass'
+            value_input.text = 'false'
+          when 'NilClass'
+            value_input.text = 'null'
+          else
+            value_input.text = ''
+            value_input.editable = true
+          end
+        end
+
+        hbox = HBox.new(false, 5)
+        hbox.pack_start(Label.new("Value:"), false)
+        hbox.pack_start(value_input = Entry.new)
+        value_input.width_chars = 60
+        value_input.text = @value || ''
+        dialog.vbox.pack_start(hbox, false)
+
+        dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+        dialog.show_all
+        self.focus = dialog
+        dialog.run do |response| 
+          if response == Dialog::RESPONSE_ACCEPT
+            @key = key_input.text
+            type = ALL_TYPES[@type = type_input.active]
+            content = value_input.text
+            return @key, type, content
+          end
+        end
+        return
+      ensure
+        dialog.destroy
+      end
+
+      # Ask for an element to be appended _parent_.
+      def ask_for_element(parent = nil, default_type = nil, value_text = @content)
+        type_input = value_input = nil
+
+        dialog = Dialog.new(
+          "New element into #{parent ? parent.type : 'root'}",
+          nil, nil,
+          [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+          [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+        )
+        hbox = HBox.new(false, 5)
+        hbox.pack_start(Label.new("Type:"), false)
+        hbox.pack_start(type_input = ComboBox.new(true))
+        default_active = 0
+        types = parent ? ALL_TYPES : CONTAINER_TYPES
+        types.each_with_index do |t, i|
+          type_input.append_text(t)
+          if t == default_type
+            default_active = i
+          end
+        end
+        type_input.active = default_active
+        dialog.vbox.pack_start(hbox, false)
+        type_input.signal_connect(:changed) do
+          configure_value(value_input, types[type_input.active])
+        end
+
+        hbox = HBox.new(false, 5)
+        hbox.pack_start(Label.new("Value:"), false)
+        hbox.pack_start(value_input = Entry.new)
+        value_input.width_chars = 60
+        value_input.text = value_text if value_text
+        configure_value(value_input, types[type_input.active])
+
+        dialog.vbox.pack_start(hbox, false)
+
+        dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+        dialog.show_all
+        self.focus = dialog
+        dialog.run do |response| 
+          if response == Dialog::RESPONSE_ACCEPT
+            type = types[type_input.active]
+            @content = case type
+            when 'Numeric'
+              Integer(value_input.text) rescue Float(value_input.text) rescue 0
+            else
+              value_input.text
+            end.to_s
+            return type, @content
+          end
+        end
+        return
+      ensure
+        dialog.destroy if dialog
+      end
+
+      # Ask for an order criteria for sorting, using _x_ for the element in
+      # question. Returns the order criterium, and true/false for reverse
+      # sorting.
+      def ask_for_order
+        dialog = Dialog.new(
+          "Give an order criterium for 'x'.",
+          nil, nil,
+          [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+          [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+        )
+        hbox = HBox.new(false, 5)
+
+        hbox.pack_start(Label.new("Order:"), false)
+        hbox.pack_start(order_input = Entry.new)
+        order_input.text = @order || 'x'
+        order_input.width_chars = 60
+
+        hbox.pack_start(reverse_checkbox = CheckButton.new('Reverse'), false)
+
+        dialog.vbox.pack_start(hbox, false)
+
+        dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+        dialog.show_all
+        self.focus = dialog
+        dialog.run do |response| 
+          if response == Dialog::RESPONSE_ACCEPT
+            return @order = order_input.text, reverse_checkbox.active?
+          end
+        end
+        return
+      ensure
+        dialog.destroy if dialog
+      end
+
+      # Ask for a find term to search for in the tree. Returns the term as a
+      # string.
+      def ask_for_find_term(search = nil)
+        dialog = Dialog.new(
+          "Find a node matching regex in tree.",
+          nil, nil,
+          [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+          [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+        )
+        hbox = HBox.new(false, 5)
+
+        hbox.pack_start(Label.new("Regex:"), false)
+        hbox.pack_start(regex_input = Entry.new)
+        hbox.pack_start(icase_checkbox = CheckButton.new('Icase'), false)
+        regex_input.width_chars = 60
+        if search
+          regex_input.text = search.source
+          icase_checkbox.active = search.casefold?
+        end
+
+        dialog.vbox.pack_start(hbox, false)
+
+        dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+        dialog.show_all
+        self.focus = dialog
+        dialog.run do |response| 
+          if response == Dialog::RESPONSE_ACCEPT
+            begin
+              return Regexp.new(regex_input.text, icase_checkbox.active? ? Regexp::IGNORECASE : 0)
+            rescue => e
+              Editor.error_dialog(self, "Evaluation of regex /#{regex_input.text}/ failed: #{e}!")
+              return
+            end
+          end
+        end
+        return
+      ensure
+        dialog.destroy if dialog
+      end
+
+      # Expand or collapse row pointed to by _iter_ according
+      # to the #expanded attribute.
+      def expand_collapse(iter)
+        if expanded
+          expand_row(iter.path, true)
+        else
+          collapse_row(iter.path)
+        end
+      end
+    end
+
+    # The editor main window
+    class MainWindow < Gtk::Window
+      include Gtk
+
+      def initialize(encoding)
+        @changed  = false
+        @encoding = encoding
+        super(TOPLEVEL)
+        display_title
+        set_default_size(800, 600)
+        signal_connect(:delete_event) { quit }
+
+        vbox = VBox.new(false, 0)
+        add(vbox)
+        #vbox.border_width = 0
+
+        @treeview = JSONTreeView.new(self)
+        @treeview.signal_connect(:'cursor-changed') do
+          display_status('')
+        end
+
+        menu_bar = create_menu_bar
+        vbox.pack_start(menu_bar, false, false, 0)
+
+        sw = ScrolledWindow.new(nil, nil)
+        sw.shadow_type = SHADOW_ETCHED_IN
+        sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        vbox.pack_start(sw, true, true, 0)
+        sw.add(@treeview)
+
+        @status_bar = Statusbar.new
+        vbox.pack_start(@status_bar, false, false, 0)
+
+        @filename ||= nil
+        if @filename
+          data = read_data(@filename)
+          view_new_model Editor.data2model(data)
+        end
+
+        signal_connect(:button_release_event) do |_,event|
+          if event.button == 2
+            c = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+            if url = c.wait_for_text
+              location_open url
+            end
+            false
+          else
+            true
+          end
+        end
+      end
+
+      # Creates the menu bar with the pulldown menus and returns it.
+      def create_menu_bar
+        menu_bar = MenuBar.new
+        @file_menu = FileMenu.new(@treeview)
+        menu_bar.append @file_menu.create
+        @edit_menu = EditMenu.new(@treeview)
+        menu_bar.append @edit_menu.create
+        @options_menu = OptionsMenu.new(@treeview)
+        menu_bar.append @options_menu.create
+        menu_bar
+      end
+
+      # Sets editor status to changed, to indicate that the edited data
+      # containts unsaved changes.
+      def change
+        @changed = true
+        display_title
+      end
+
+      # Sets editor status to unchanged, to indicate that the edited data
+      # doesn't containt unsaved changes.
+      def unchange
+        @changed = false
+        display_title
+      end
+
+      # Puts a new model _model_ into the Gtk::TreeView to be edited.
+      def view_new_model(model)
+        @treeview.model     = model
+        @treeview.expanded  = true
+        @treeview.expand_all
+        unchange
+      end
+
+      # Displays _text_ in the status bar.
+      def display_status(text)
+        @cid ||= nil
+        @status_bar.pop(@cid) if @cid
+        @cid = @status_bar.get_context_id('dummy')
+        @status_bar.push(@cid, text)
+      end
+
+      # Opens a dialog, asking, if changes should be saved to a file.
+      def ask_save
+        if Editor.question_dialog(self,
+          "Unsaved changes to JSON model. Save?")
+          if @filename
+            file_save
+          else
+            file_save_as
+          end
+        end
+      end
+
+      # Quit this editor, that is, leave this editor's main loop.
+      def quit
+        ask_save if @changed
+        if Gtk.main_level > 0
+          destroy
+          Gtk.main_quit
+        end
+        nil
+      end
+
+      # Display the new title according to the editor's current state.
+      def display_title
+        title = TITLE.dup
+        title << ": #@filename" if @filename
+        title << " *" if @changed
+        self.title = title
+      end
+
+      # Clear the current model, after asking to save all unsaved changes.
+      def clear
+        ask_save if @changed
+        @filename = nil
+        self.view_new_model nil
+      end
+
+      def check_pretty_printed(json)
+        pretty = !!((nl_index = json.index("\n")) && nl_index != json.size - 1)
+        @options_menu.pretty_item.active = pretty
+      end
+      private :check_pretty_printed
+
+      # Open the data at the location _uri_, if given. Otherwise open a dialog
+      # to ask for the _uri_.
+      def location_open(uri = nil)
+        uri = ask_for_location unless uri
+        uri or return
+        ask_save if @changed
+        data = load_location(uri) or return
+        view_new_model Editor.data2model(data)
+      end
+
+      # Open the file _filename_ or call the #select_file method to ask for a
+      # filename.
+      def file_open(filename = nil)
+        filename = select_file('Open as a JSON file') unless filename
+        data = load_file(filename) or return
+        view_new_model Editor.data2model(data)
+      end
+
+      # Edit the string _json_ in the editor.
+      def edit(json)
+        if json.respond_to? :read
+          json = json.read
+        end
+        data = parse_json json
+        view_new_model Editor.data2model(data)
+      end
+
+      # Save the current file.
+      def file_save
+        if @filename
+          store_file(@filename)
+        else
+          file_save_as
+        end
+      end
+
+      # Save the current file as the filename 
+      def file_save_as
+        filename = select_file('Save as a JSON file')
+        store_file(filename)
+      end
+
+      # Store the current JSON document to _path_.
+      def store_file(path)
+        if path
+          data = Editor.model2data(@treeview.model.iter_first)
+          File.open(path + '.tmp', 'wb') do |output|
+            data or break
+            if @options_menu.pretty_item.active?
+              output.puts JSON.pretty_generate(data, :max_nesting => false)
+            else
+              output.write JSON.generate(data, :max_nesting => false)
+            end
+          end
+          File.rename path + '.tmp', path
+          @filename = path
+          toplevel.display_status("Saved data to '#@filename'.")
+          unchange
+        end
+      rescue SystemCallError => e
+        Editor.error_dialog(self, "Failed to store JSON file: #{e}!")
+      end
+  
+      # Load the file named _filename_ into the editor as a JSON document.
+      def load_file(filename)
+        if filename
+          if File.directory?(filename)
+            Editor.error_dialog(self, "Try to select a JSON file!")
+            nil
+          else
+            @filename = filename
+            if data = read_data(filename)
+              toplevel.display_status("Loaded data from '#@filename'.")
+            end
+            display_title
+            data
+          end
+        end
+      end
+
+      # Load the data at location _uri_ into the editor as a JSON document.
+      def load_location(uri)
+        data = read_data(uri) or return
+        @filename = nil
+        toplevel.display_status("Loaded data from '#{uri}'.")
+        display_title
+        data
+      end
+
+      def parse_json(json)
+        check_pretty_printed(json)
+        if @encoding && !/^utf8$/i.match(@encoding)
+          iconverter = Iconv.new('utf8', @encoding)
+          json = iconverter.iconv(json)
+        end
+        JSON::parse(json, :max_nesting => false, :create_additions => false)
+      end
+      private :parse_json
+
+      # Read a JSON document from the file named _filename_, parse it into a
+      # ruby data structure, and return the data.
+      def read_data(filename)
+        open(filename) do |f|
+          json = f.read
+          return parse_json(json)
+        end
+      rescue => e
+        Editor.error_dialog(self, "Failed to parse JSON file: #{e}!")
+        return
+      end
+
+      # Open a file selecton dialog, displaying _message_, and return the
+      # selected filename or nil, if no file was selected.
+      def select_file(message)
+        filename = nil
+        fs = FileSelection.new(message)
+        fs.set_modal(true)
+        @default_dir = File.join(Dir.pwd, '') unless @default_dir
+        fs.set_filename(@default_dir)
+        fs.set_transient_for(self)
+        fs.signal_connect(:destroy) { Gtk.main_quit }
+        fs.ok_button.signal_connect(:clicked) do
+          filename = fs.filename
+          @default_dir = File.join(File.dirname(filename), '')
+          fs.destroy
+          Gtk.main_quit
+        end
+        fs.cancel_button.signal_connect(:clicked) do
+          fs.destroy
+          Gtk.main_quit
+        end
+        fs.show_all
+        Gtk.main
+        filename
+      end
+
+      # Ask for location URI a to load data from. Returns the URI as a string.
+      def ask_for_location
+        dialog = Dialog.new(
+          "Load data from location...",
+          nil, nil,
+          [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+          [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+        )
+        hbox = HBox.new(false, 5)
+
+        hbox.pack_start(Label.new("Location:"), false)
+        hbox.pack_start(location_input = Entry.new)
+        location_input.width_chars = 60
+        location_input.text = @location || ''
+
+        dialog.vbox.pack_start(hbox, false)
+
+        dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+        dialog.show_all
+        dialog.run do |response| 
+          if response == Dialog::RESPONSE_ACCEPT
+            return @location = location_input.text
+          end
+        end
+        return
+      ensure
+        dialog.destroy if dialog
+      end
+    end
+
+    class << self
+      # Starts a JSON Editor. If a block was given, it yields
+      # to the JSON::Editor::MainWindow instance.
+      def start(encoding = 'utf8') # :yield: window
+        Gtk.init
+        @window = Editor::MainWindow.new(encoding)
+        @window.icon_list = [ Editor.fetch_icon('json') ]
+        yield @window if block_given?
+        @window.show_all
+        Gtk.main
+      end
+
+      # Edit the string _json_ with encoding _encoding_ in the editor.
+      def edit(json, encoding = 'utf8')
+        start(encoding) do |window|
+          window.edit json
+        end
+      end
+
+      attr_reader :window
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/ext.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/ext.rb
new file mode 100644 (file)
index 0000000..ff4fa42
--- /dev/null
@@ -0,0 +1,13 @@
+require 'json/common'
+
+module JSON
+  # This module holds all the modules/classes that implement JSON's
+  # functionality as C extensions.
+  module Ext
+    require 'json/ext/parser'
+    require 'json/ext/generator'
+    $DEBUG and warn "Using c extension for JSON."
+    JSON.parser = Parser
+    JSON.generator = Generator
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/pure.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/pure.rb
new file mode 100644 (file)
index 0000000..6af8705
--- /dev/null
@@ -0,0 +1,22 @@
+require 'json/common'
+require 'json/pure/parser'
+require 'json/pure/generator'
+
+module JSON
+  # Swap consecutive bytes of _string_ in place.
+  def self.swap!(string) # :nodoc:
+    0.upto(string.size / 2) do |i|
+      break unless string[2 * i + 1]
+      string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
+    end
+    string
+  end
+
+  # This module holds all the modules/classes that implement JSON's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for JSON."
+    JSON.parser = Parser
+    JSON.generator = Generator
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/pure/generator.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/pure/generator.rb
new file mode 100644 (file)
index 0000000..9c7cfac
--- /dev/null
@@ -0,0 +1,394 @@
+module JSON
+  MAP = {
+    "\x0" => '\u0000',
+    "\x1" => '\u0001',
+    "\x2" => '\u0002',
+    "\x3" => '\u0003',
+    "\x4" => '\u0004',
+    "\x5" => '\u0005',
+    "\x6" => '\u0006',
+    "\x7" => '\u0007',
+    "\b"  =>  '\b',
+    "\t"  =>  '\t',
+    "\n"  =>  '\n',
+    "\xb" => '\u000b',
+    "\f"  =>  '\f',
+    "\r"  =>  '\r',
+    "\xe" => '\u000e',
+    "\xf" => '\u000f',
+    "\x10" => '\u0010',
+    "\x11" => '\u0011',
+    "\x12" => '\u0012',
+    "\x13" => '\u0013',
+    "\x14" => '\u0014',
+    "\x15" => '\u0015',
+    "\x16" => '\u0016',
+    "\x17" => '\u0017',
+    "\x18" => '\u0018',
+    "\x19" => '\u0019',
+    "\x1a" => '\u001a',
+    "\x1b" => '\u001b',
+    "\x1c" => '\u001c',
+    "\x1d" => '\u001d',
+    "\x1e" => '\u001e',
+    "\x1f" => '\u001f',
+    '"'   =>  '\"',
+    '\\'  =>  '\\\\',
+    '/'   =>  '\/',
+  } # :nodoc:
+
+  # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
+  # UTF16 big endian characters as \u????, and return it.
+  def utf8_to_json(string) # :nodoc:
+    string = string.dup.force_encoding(Encoding::ASCII_8BIT)
+    string.gsub!(/["\\\/\x0-\x1f]/) { MAP[$&] }
+    string.gsub!(/(
+                    (?:
+                      [\xc2-\xdf][\x80-\xbf]    |
+                      [\xe0-\xef][\x80-\xbf]{2} |
+                      [\xf0-\xf4][\x80-\xbf]{3}
+                    )+ |
+                    [\x80-\xc1\xf5-\xff]       # invalid
+                  )/nx) { |c|
+      c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
+      c.unpack("U*").map{|c|
+        c>0xFFFF ? ('\ud%03x\ud%03x'%[0x7C0+c/1024,0xC00+c%1024]) : ('\u%04x'%c)
+      }.join("")
+    }
+    string
+  end
+  module_function :utf8_to_json
+
+  module Pure
+    module Generator
+      # This class is used to create State instances, that are use to hold data
+      # while generating a JSON text from a a Ruby data structure.
+      class State
+        # Creates a State object from _opts_, which ought to be Hash to create
+        # a new State instance configured by _opts_, something else to create
+        # an unconfigured instance. If _opts_ is a State object, it is just
+        # returned.
+        def self.from_state(opts)
+          case opts
+          when self
+            opts
+          when Hash
+            new(opts)
+          else
+            new
+          end
+        end
+
+        # Instantiates a new State object, configured by _opts_.
+        #
+        # _opts_ can have the following keys:
+        #
+        # * *indent*: a string used to indent levels (default: ''),
+        # * *space*: a string that is put after, a : or , delimiter (default: ''),
+        # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+        # * *object_nl*: a string that is put at the end of a JSON object (default: ''), 
+        # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+        # * *check_circular*: true if checking for circular data structures
+        #   should be done (the default), false otherwise.
+        # * *check_circular*: true if checking for circular data structures
+        #   should be done, false (the default) otherwise.
+        # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+        #   generated, otherwise an exception is thrown, if these values are
+        #   encountered. This options defaults to false.
+        def initialize(opts = {})
+          @seen = {}
+          @indent         = ''
+          @space          = ''
+          @space_before   = ''
+          @object_nl      = ''
+          @array_nl       = ''
+          @check_circular = true
+          @allow_nan      = false
+          configure opts
+        end
+
+        # This string is used to indent levels in the JSON text.
+        attr_accessor :indent
+
+        # This string is used to insert a space between the tokens in a JSON
+        # string.
+        attr_accessor :space
+
+        # This string is used to insert a space before the ':' in JSON objects.
+        attr_accessor :space_before
+
+        # This string is put at the end of a line that holds a JSON object (or
+        # Hash).
+        attr_accessor :object_nl
+
+        # This string is put at the end of a line that holds a JSON array.
+        attr_accessor :array_nl
+
+        # This integer returns the maximum level of data structure nesting in
+        # the generated JSON, max_nesting = 0 if no maximum is checked.
+        attr_accessor :max_nesting
+
+        def check_max_nesting(depth) # :nodoc:
+          return if @max_nesting.zero?
+          current_nesting = depth + 1
+          current_nesting > @max_nesting and
+            raise NestingError, "nesting of #{current_nesting} is too deep"
+        end
+
+        # Returns true, if circular data structures should be checked,
+        # otherwise returns false.
+        def check_circular?
+          @check_circular
+        end
+
+        # Returns true if NaN, Infinity, and -Infinity should be considered as
+        # valid JSON and output.
+        def allow_nan?
+          @allow_nan
+        end
+
+        # Returns _true_, if _object_ was already seen during this generating
+        # run. 
+        def seen?(object)
+          @seen.key?(object.__id__)
+        end
+
+        # Remember _object_, to find out if it was already encountered (if a
+        # cyclic data structure is if a cyclic data structure is rendered). 
+        def remember(object)
+          @seen[object.__id__] = true
+        end
+
+        # Forget _object_ for this generating run.
+        def forget(object)
+          @seen.delete object.__id__
+        end
+
+        # Configure this State instance with the Hash _opts_, and return
+        # itself.
+        def configure(opts)
+          @indent         = opts[:indent] if opts.key?(:indent)
+          @space          = opts[:space] if opts.key?(:space)
+          @space_before   = opts[:space_before] if opts.key?(:space_before)
+          @object_nl      = opts[:object_nl] if opts.key?(:object_nl)
+          @array_nl       = opts[:array_nl] if opts.key?(:array_nl)
+          @check_circular = !!opts[:check_circular] if opts.key?(:check_circular)
+          @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
+          if !opts.key?(:max_nesting) # defaults to 19
+            @max_nesting = 19
+          elsif opts[:max_nesting]
+            @max_nesting = opts[:max_nesting]
+          else
+            @max_nesting = 0
+          end
+          self
+        end
+
+        # Returns the configuration instance variables as a hash, that can be
+        # passed to the configure method.
+        def to_h
+          result = {}
+          for iv in %w[indent space space_before object_nl array_nl check_circular allow_nan max_nesting]
+            result[iv.intern] = instance_variable_get("@#{iv}")
+          end
+          result
+        end
+      end
+
+      module GeneratorMethods
+        module Object
+          # Converts this object to a string (calling #to_s), converts
+          # it to a JSON string, and returns the result. This is a fallback, if no
+          # special method #to_json was defined for some object.
+          def to_json(*) to_s.to_json end
+        end
+
+        module Hash
+          # Returns a JSON string containing a JSON object, that is unparsed from
+          # this Hash instance.
+          # _state_ is a JSON::State object, that can also be used to configure the
+          # produced JSON string output further.
+          # _depth_ is used to find out nesting depth, to indent accordingly.
+          def to_json(state = nil, depth = 0, *)
+            if state
+              state = JSON.state.from_state(state)
+              state.check_max_nesting(depth)
+              json_check_circular(state) { json_transform(state, depth) }
+            else
+              json_transform(state, depth)
+            end
+          end
+
+          private
+
+          def json_check_circular(state)
+            if state and state.check_circular?
+              state.seen?(self) and raise JSON::CircularDatastructure,
+                  "circular data structures not supported!"
+              state.remember self
+            end
+            yield
+          ensure
+            state and state.forget self
+          end
+
+          def json_shift(state, depth)
+            state and not state.object_nl.empty? or return ''
+            state.indent * depth
+          end
+
+          def json_transform(state, depth)
+            delim = ','
+            delim << state.object_nl if state
+            result = '{'
+            result << state.object_nl if state
+            result << map { |key,value|
+              s = json_shift(state, depth + 1)
+              s << key.to_s.to_json(state, depth + 1)
+              s << state.space_before if state
+              s << ':'
+              s << state.space if state
+              s << value.to_json(state, depth + 1)
+            }.join(delim)
+            result << state.object_nl if state
+            result << json_shift(state, depth)
+            result << '}'
+            result
+          end
+        end
+
+        module Array
+          # Returns a JSON string containing a JSON array, that is unparsed from
+          # this Array instance.
+          # _state_ is a JSON::State object, that can also be used to configure the
+          # produced JSON string output further.
+          # _depth_ is used to find out nesting depth, to indent accordingly.
+          def to_json(state = nil, depth = 0, *)
+            if state
+              state = JSON.state.from_state(state)
+              state.check_max_nesting(depth)
+              json_check_circular(state) { json_transform(state, depth) }
+            else
+              json_transform(state, depth)
+            end
+          end
+
+          private
+
+          def json_check_circular(state)
+            if state and state.check_circular?
+              state.seen?(self) and raise JSON::CircularDatastructure,
+                "circular data structures not supported!"
+              state.remember self
+            end
+            yield
+          ensure
+            state and state.forget self
+          end
+
+          def json_shift(state, depth)
+            state and not state.array_nl.empty? or return ''
+            state.indent * depth
+          end
+
+          def json_transform(state, depth)
+            delim = ','
+            delim << state.array_nl if state
+            result = '['
+            result << state.array_nl if state
+            result << map { |value|
+              json_shift(state, depth + 1) << value.to_json(state, depth + 1)
+            }.join(delim)
+            result << state.array_nl if state
+            result << json_shift(state, depth) 
+            result << ']'
+            result
+          end
+        end
+
+        module Integer
+          # Returns a JSON string representation for this Integer number.
+          def to_json(*) to_s end
+        end
+
+        module Float
+          # Returns a JSON string representation for this Float number.
+          def to_json(state = nil, *)
+            case
+            when infinite?
+              if !state || state.allow_nan?
+                to_s
+              else
+                raise GeneratorError, "#{self} not allowed in JSON"
+              end
+            when nan?
+              if !state || state.allow_nan?
+                to_s
+              else
+                raise GeneratorError, "#{self} not allowed in JSON"
+              end
+            else
+              to_s
+            end
+          end
+        end
+
+        module String
+          # This string should be encoded with UTF-8 A call to this method
+          # returns a JSON string encoded with UTF16 big endian characters as
+          # \u????.
+          def to_json(*)
+            '"' << JSON.utf8_to_json(self) << '"'
+          end
+
+          # Module that holds the extinding methods if, the String module is
+          # included.
+          module Extend
+            # Raw Strings are JSON Objects (the raw bytes are stored in an array for the
+            # key "raw"). The Ruby String can be created by this module method.
+            def json_create(o)
+              o['raw'].pack('C*')
+            end
+          end
+
+          # Extends _modul_ with the String::Extend module.
+          def self.included(modul)
+            modul.extend Extend
+          end
+
+          # This method creates a raw object hash, that can be nested into
+          # other data structures and will be unparsed as a raw string. This
+          # method should be used, if you want to convert raw strings to JSON
+          # instead of UTF-8 strings, e. g. binary data.
+          def to_json_raw_object
+            {
+              JSON.create_id  => self.class.name,
+              'raw'           => self.unpack('C*'),
+            }
+          end
+
+          # This method creates a JSON text from the result of
+          # a call to to_json_raw_object of this String.
+          def to_json_raw(*args)
+            to_json_raw_object.to_json(*args)
+          end
+        end
+
+        module TrueClass
+          # Returns a JSON string for true: 'true'.
+          def to_json(*) 'true' end
+        end
+
+        module FalseClass
+          # Returns a JSON string for false: 'false'.
+          def to_json(*) 'false' end
+        end
+
+        module NilClass
+          # Returns a JSON string for nil: 'null'.
+          def to_json(*) 'null' end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/pure/parser.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/pure/parser.rb
new file mode 100644 (file)
index 0000000..9c3fea9
--- /dev/null
@@ -0,0 +1,269 @@
+require 'strscan'
+
+module JSON
+  module Pure
+    # This class implements the JSON parser that is used to parse a JSON string
+    # into a Ruby data structure.
+    class Parser < StringScanner
+      STRING                = /" ((?:[^\x0-\x1f"\\] |
+                                  \\["\\\/bfnrt] |
+                                  \\u[0-9a-fA-F]{4} |
+                                  \\[\x20-\xff])*)
+                              "/nx
+      INTEGER               = /(-?0|-?[1-9]\d*)/
+      FLOAT                 = /(-?
+                                (?:0|[1-9]\d*)
+                                (?:
+                                  \.\d+(?i:e[+-]?\d+) |
+                                  \.\d+ |
+                                  (?i:e[+-]?\d+)
+                                )
+                                )/x
+      NAN                   = /NaN/
+      INFINITY              = /Infinity/
+      MINUS_INFINITY        = /-Infinity/
+      OBJECT_OPEN           = /\{/
+      OBJECT_CLOSE          = /\}/
+      ARRAY_OPEN            = /\[/
+      ARRAY_CLOSE           = /\]/
+      PAIR_DELIMITER        = /:/
+      COLLECTION_DELIMITER  = /,/
+      TRUE                  = /true/
+      FALSE                 = /false/
+      NULL                  = /null/
+      IGNORE                = %r(
+        (?:
+         //[^\n\r]*[\n\r]| # line comments
+         /\*               # c-style comments
+         (?:
+          [^*/]|        # normal chars
+          /[^*]|        # slashes that do not start a nested comment
+          \*[^/]|       # asterisks that do not end this comment
+          /(?=\*/)      # single slash before this comment's end 
+         )*
+           \*/               # the End of this comment
+           |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+        )+
+      )mx
+
+      UNPARSED = Object.new
+
+      # Creates a new JSON::Pure::Parser instance for the string _source_.
+      #
+      # It will be configured by the _opts_ hash. _opts_ can have the following
+      # keys:
+      # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+      #   structures. Disable depth checking with :max_nesting => false|nil|0,
+      #   it defaults to 19.
+      # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+      #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+      #   to false.
+      # * *create_additions*: If set to false, the Parser doesn't create
+      #   additions even if a matchin class and create_id was found. This option
+      #   defaults to true.
+      def initialize(source, opts = {})
+        super
+        if !opts.key?(:max_nesting) # defaults to 19
+          @max_nesting = 19
+        elsif opts[:max_nesting]
+          @max_nesting = opts[:max_nesting]
+        else
+          @max_nesting = 0
+        end
+        @allow_nan = !!opts[:allow_nan]
+        ca = true
+        ca = opts[:create_additions] if opts.key?(:create_additions)
+        @create_id = ca ? JSON.create_id : nil
+      end
+
+      alias source string
+
+      # Parses the current JSON string _source_ and returns the complete data
+      # structure as a result.
+      def parse
+        reset
+        obj = nil
+        until eos?
+          case
+          when scan(OBJECT_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+            @current_nesting = 1
+            obj = parse_object
+          when scan(ARRAY_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+            @current_nesting = 1
+            obj = parse_array
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "source '#{peek(20)}' not in JSON!"
+          end
+        end
+        obj or raise ParserError, "source did not contain any JSON!"
+        obj
+      end
+
+      private
+
+      # Unescape characters in strings.
+      UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+      UNESCAPE_MAP.update({
+        ?"  => '"',
+        ?\\ => '\\',
+        ?/  => '/',
+        ?b  => "\b",
+        ?f  => "\f",
+        ?n  => "\n",
+        ?r  => "\r",
+        ?t  => "\t",
+        ?u  => nil, 
+      })
+
+      def parse_string
+        if scan(STRING)
+          return '' if self[1].empty?
+          self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+            if u = UNESCAPE_MAP[$&[1]]
+              u
+            else # \uXXXX
+              res = []
+              stack = nil
+              [c.delete!('\\\\u')].pack("H*").unpack("n*").each do |c|
+                case c
+                when 0xD800..0xDBFF
+                  raise JSON::ParserError, "partial character in source" if stack
+                  stack = c
+                when 0xDC00..0xDFFF
+                  raise JSON::ParserError,
+                    "partial character in source" unless (0xD800..0xDBFF).include?(stack)
+                  res << (stack << 10) - 0x35fdc00 + c
+                  stack = nil
+                else
+                  raise JSON::ParserError, "partial character in source" if stack
+                  res << c
+                end
+              end
+              raise JSON::ParserError, "partial character in source" if stack
+              res.pack("U*")
+            end
+          end.force_encoding("UTF-8")
+        else
+          UNPARSED
+        end
+      end
+
+      def parse_value
+        case
+        when scan(FLOAT)
+          Float(self[1])
+        when scan(INTEGER)
+          Integer(self[1])
+        when scan(TRUE)
+          true
+        when scan(FALSE)
+          false
+        when scan(NULL)
+          nil
+        when (string = parse_string) != UNPARSED
+          string
+        when scan(ARRAY_OPEN)
+          @current_nesting += 1
+          ary = parse_array
+          @current_nesting -= 1
+          ary
+        when scan(OBJECT_OPEN)
+          @current_nesting += 1
+          obj = parse_object
+          @current_nesting -= 1
+          obj
+        when @allow_nan && scan(NAN)
+          NaN
+        when @allow_nan && scan(INFINITY)
+          Infinity
+        when @allow_nan && scan(MINUS_INFINITY)
+          MinusInfinity
+        else
+          UNPARSED
+        end
+      end
+
+      def parse_array
+        raise NestingError, "nesting of #@current_nesting is to deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = []
+        delim = false
+        until eos?
+          case
+          when (value = parse_value) != UNPARSED
+            delim = false
+            result << value
+            skip(IGNORE)
+            if scan(COLLECTION_DELIMITER)
+              delim = true
+            elsif match?(ARRAY_CLOSE)
+              ;
+            else
+              raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+            end
+          when scan(ARRAY_CLOSE)
+            if delim
+              raise ParserError, "expected next element in array at '#{peek(20)}'!"
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+
+      def parse_object
+        raise NestingError, "nesting of #@current_nesting is to deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = {}
+        delim = false
+        until eos?
+          case
+          when (string = parse_string) != UNPARSED
+            skip(IGNORE)
+            unless scan(PAIR_DELIMITER)
+              raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+            end
+            skip(IGNORE)
+            unless (value = parse_value).equal? UNPARSED
+              result[string] = value
+              delim = false
+              skip(IGNORE)
+              if scan(COLLECTION_DELIMITER)
+                delim = true
+              elsif match?(OBJECT_CLOSE)
+                ;
+              else
+                raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+              end
+            else
+              raise ParserError, "expected value in object at '#{peek(20)}'!"
+            end
+          when scan(OBJECT_CLOSE)
+            if delim
+              raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+            end
+            if @create_id and klassname = result[@create_id]
+              klass = JSON.deep_const_get klassname
+              break unless klass and klass.json_creatable?
+              result = klass.json_create(result)
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/json/version.rb b/lib/ruby-1.9.1-rc1/.ext/common/json/version.rb
new file mode 100644 (file)
index 0000000..acf8217
--- /dev/null
@@ -0,0 +1,9 @@
+module JSON
+  # JSON version
+  VERSION         = '1.1.3'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  VARIANT_BINARY  = false
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/kconv.rb b/lib/ruby-1.9.1-rc1/.ext/common/kconv.rb
new file mode 100644 (file)
index 0000000..f2c9489
--- /dev/null
@@ -0,0 +1,282 @@
+#
+# kconv.rb - Kanji Converter.
+#
+# $Id: kconv.rb 15050 2008-01-14 14:37:29Z naruse $
+#
+# ----
+#
+# kconv.rb implements the Kconv class for Kanji Converter.  Additionally,
+# some methods in String classes are added to allow easy conversion.
+#
+
+require 'nkf'
+
+#
+# Kanji Converter for Ruby.
+#
+module Kconv
+  #
+  # Public Constants
+  #
+
+  #Constant of Encoding
+
+  # Auto-Detect
+  AUTO = NKF::AUTO
+  # ISO-2022-JP
+  JIS = NKF::JIS
+  # EUC-JP
+  EUC = NKF::EUC
+  # Shift_JIS
+  SJIS = NKF::SJIS
+  # BINARY
+  BINARY = NKF::BINARY
+  # NOCONV
+  NOCONV = NKF::NOCONV
+  # ASCII
+  ASCII = NKF::ASCII
+  # UTF-8
+  UTF8 = NKF::UTF8
+  # UTF-16
+  UTF16 = NKF::UTF16
+  # UTF-32
+  UTF32 = NKF::UTF32
+  # UNKNOWN
+  UNKNOWN = NKF::UNKNOWN
+
+  #
+  # Public Methods
+  #
+  
+  # call-seq:
+  #    Kconv.kconv(str, to_enc, from_enc=nil)
+  #
+  # Convert <code>str</code> to out_code.
+  # <code>out_code</code> and <code>in_code</code> are given as constants of Kconv.
+  def kconv(str, to_enc, from_enc=nil)
+    opt = ''
+    opt += ' --ic=' + from_enc.to_s if from_enc
+    opt += ' --oc=' + to_enc.to_s if to_enc
+
+    ::NKF::nkf(opt, str)
+  end
+  module_function :kconv
+
+  #
+  # Encode to
+  #
+
+  # call-seq:
+  #    Kconv.tojis(str)   => string
+  #
+  # Convert <code>str</code> to ISO-2022-JP
+  def tojis(str)
+    kconv(str, JIS)
+  end
+  module_function :tojis
+
+  # call-seq:
+  #    Kconv.toeuc(str)   => string
+  #
+  # Convert <code>str</code> to EUC-JP
+  def toeuc(str)
+    kconv(str, EUC)
+  end
+  module_function :toeuc
+
+  # call-seq:
+  #    Kconv.tosjis(str)   => string
+  #
+  # Convert <code>str</code> to Shift_JIS
+  def tosjis(str)
+    kconv(str, SJIS)
+  end
+  module_function :tosjis
+
+  # call-seq:
+  #    Kconv.toutf8(str)   => string
+  #
+  # Convert <code>str</code> to UTF-8
+  def toutf8(str)
+    kconv(str, UTF8)
+  end
+  module_function :toutf8
+
+  # call-seq:
+  #    Kconv.toutf16(str)   => string
+  #
+  # Convert <code>str</code> to UTF-16
+  def toutf16(str)
+    kconv(str, UTF16)
+  end
+  module_function :toutf16
+
+  # call-seq:
+  #    Kconv.toutf32(str)   => string
+  #
+  # Convert <code>str</code> to UTF-32
+  def toutf32(str)
+    kconv(str, UTF32)
+  end
+  module_function :toutf32
+
+  # call-seq:
+  #    Kconv.tolocale   => string
+  #
+  # Convert <code>self</code> to locale encoding
+  def tolocale(str)
+    kconv(str, Encoding.locale_charmap)
+  end
+  module_function :tolocale
+
+  #
+  # guess
+  #
+
+  # call-seq:
+  #    Kconv.guess(str)   => encoding
+  #
+  # Guess input encoding by NKF.guess
+  def guess(str)
+    ::NKF::guess(str)
+  end
+  module_function :guess
+
+  #
+  # isEncoding
+  #
+
+  # call-seq:
+  #    Kconv.iseuc(str)   => true or false
+  #
+  # Returns whether input encoding is EUC-JP or not.
+  #
+  # *Note* don't expect this return value is MatchData.
+  def iseuc(str)
+    str.dup.force_encoding(EUC).valid_encoding?
+  end
+  module_function :iseuc
+
+  # call-seq:
+  #    Kconv.issjis(str)   => true or false
+  #
+  # Returns whether input encoding is Shift_JIS or not.
+  def issjis(str)
+    str.dup.force_encoding(SJIS).valid_encoding?
+  end
+  module_function :issjis
+
+  # call-seq:
+  #    Kconv.isjis(str)   => true or false
+  #
+  # Returns whether input encoding is ISO-2022-JP or not.
+  def isjis(str)
+    /\A [\t\n\r\x20-\x7E]*
+      (?:
+        (?:\x1b \x28 I      [\x21-\x7E]*
+          |\x1b \x28 J      [\x21-\x7E]*
+          |\x1b \x24 @      (?:[\x21-\x7E]{2})*
+          |\x1b \x24 B      (?:[\x21-\x7E]{2})*
+          |\x1b \x24 \x28 D (?:[\x21-\x7E]{2})*
+        )*
+        \x1b \x28 B [\t\n\r\x20-\x7E]*
+      )*
+     \z/nox =~ str.dup.force_encoding('BINARY') ? true : false
+  end
+  module_function :isjis
+
+  # call-seq:
+  #    Kconv.isutf8(str)   => true or false
+  #
+  # Returns whether input encoding is UTF-8 or not.
+  def isutf8(str)
+    str.dup.force_encoding(UTF8).valid_encoding?
+  end
+  module_function :isutf8
+end
+
+class String
+  # call-seq:
+  #    String#kconv(to_enc, from_enc)
+  #
+  # Convert <code>self</code> to out_code.
+  # <code>out_code</code> and <code>in_code</code> are given as constants of Kconv.
+  def kconv(to_enc, from_enc=nil)
+    form_enc = self.encoding if !from_enc && self.encoding != Encoding.list[0]
+    Kconv::kconv(self, to_enc, from_enc)
+  end
+  
+  #
+  # to Encoding
+  #
+  
+  # call-seq:
+  #    String#tojis   => string
+  #
+  # Convert <code>self</code> to ISO-2022-JP
+  def tojis; Kconv.tojis(self) end
+
+  # call-seq:
+  #    String#toeuc   => string
+  #
+  # Convert <code>self</code> to EUC-JP
+  def toeuc; Kconv.toeuc(self) end
+
+  # call-seq:
+  #    String#tosjis   => string
+  #
+  # Convert <code>self</code> to Shift_JIS
+  def tosjis; Kconv.tosjis(self) end
+
+  # call-seq:
+  #    String#toutf8   => string
+  #
+  # Convert <code>self</code> to UTF-8
+  def toutf8; Kconv.toutf8(self) end
+
+  # call-seq:
+  #    String#toutf16   => string
+  #
+  # Convert <code>self</code> to UTF-16
+  def toutf16; Kconv.toutf16(self) end
+
+  # call-seq:
+  #    String#toutf32   => string
+  #
+  # Convert <code>self</code> to UTF-32
+  def toutf32; Kconv.toutf32(self) end
+
+  # call-seq:
+  #    String#tolocale   => string
+  #
+  # Convert <code>self</code> to locale encoding
+  def tolocale; Kconv.tolocale(self) end
+
+  #
+  # is Encoding
+  #
+
+  # call-seq:
+  #    String#iseuc   => true or false
+  #
+  # Returns whether <code>self</code>'s encoding is EUC-JP or not.
+  def iseuc;   Kconv.iseuc(self) end
+
+  # call-seq:
+  #    String#issjis   => true or false
+  #
+  # Returns whether <code>self</code>'s encoding is Shift_JIS or not.
+  def issjis;  Kconv.issjis(self) end
+
+  # call-seq:
+  #    String#isjis   => true or false
+  #
+  # Returns whether <code>self</code>'s encoding is ISO-2022-JP or not.
+  def isjis;   Kconv.isjis(self) end
+
+  # call-seq:
+  #    String#isutf8   => true or false
+  #
+  # Returns whether <code>self</code>'s encoding is UTF-8 or not.
+  def isutf8;  Kconv.isutf8(self) end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl.rb
new file mode 100644 (file)
index 0000000..411c0db
--- /dev/null
@@ -0,0 +1,24 @@
+=begin
+= $RCSfile$ -- Loader for all OpenSSL C-space and Ruby-space definitions
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: openssl.rb 11708 2007-02-12 23:01:19Z shyouhei $
+=end
+
+require 'openssl.so'
+
+require 'openssl/bn'
+require 'openssl/cipher'
+require 'openssl/digest'
+require 'openssl/ssl'
+require 'openssl/x509'
+
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl/bn.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl/bn.rb
new file mode 100644 (file)
index 0000000..cf44a09
--- /dev/null
@@ -0,0 +1,35 @@
+=begin
+= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for BN
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: bn.rb 11708 2007-02-12 23:01:19Z shyouhei $
+=end
+
+##
+# Should we care what if somebody require this file directly?
+#require 'openssl'
+
+module OpenSSL
+  class BN
+    include Comparable
+  end # BN
+end # OpenSSL
+
+##
+# Add double dispatch to Integer
+#
+class Integer
+  def to_bn
+    OpenSSL::BN::new(self)
+  end
+end # Integer
+
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl/buffering.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl/buffering.rb
new file mode 100644 (file)
index 0000000..453207c
--- /dev/null
@@ -0,0 +1,242 @@
+=begin
+= $RCSfile$ -- Buffering mix-in module.
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2001 GOTOU YUUZOU <gotoyuzo@notwork.org>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: buffering.rb 14261 2007-12-17 07:06:16Z gotoyuzo $
+=end
+
+module Buffering
+  include Enumerable
+  attr_accessor :sync
+  BLOCK_SIZE = 1024*16
+
+  def initialize(*args)
+    @eof = false
+    @rbuffer = ""
+    @sync = @io.sync
+  end
+
+  #
+  # for reading.
+  #
+  private
+
+  def fill_rbuff
+    begin
+      @rbuffer << self.sysread(BLOCK_SIZE)
+    rescue Errno::EAGAIN
+      retry
+    rescue EOFError
+      @eof = true
+    end
+  end
+
+  def consume_rbuff(size=nil)
+    if @rbuffer.empty?
+      nil
+    else
+      size = @rbuffer.size unless size
+      ret = @rbuffer[0, size]
+      @rbuffer[0, size] = ""
+      ret
+    end
+  end
+
+  public
+
+  def read(size=nil, buf=nil)
+    if size == 0
+      if buf
+        buf.clear
+        return buf
+      else
+        return ""
+      end
+    end
+    until @eof
+      break if size && size <= @rbuffer.size
+      fill_rbuff
+    end
+    ret = consume_rbuff(size) || ""
+    if buf
+      buf.replace(ret)
+      ret = buf
+    end
+    (size && ret.empty?) ? nil : ret
+  end
+
+  def readpartial(maxlen, buf=nil)
+    if maxlen == 0
+      if buf
+        buf.clear
+        return buf
+      else
+        return ""
+      end
+    end
+    if @rbuffer.empty?
+      begin
+        return sysread(maxlen, buf)
+      rescue Errno::EAGAIN
+        retry
+      end
+    end
+    ret = consume_rbuff(maxlen)
+    if buf
+      buf.replace(ret)
+      ret = buf
+    end
+    raise EOFError if ret.empty?
+    ret
+  end
+
+  def gets(eol=$/, limit=nil)
+    idx = @rbuffer.index(eol)
+    until @eof
+      break if idx
+      fill_rbuff
+      idx = @rbuffer.index(eol)
+    end
+    if eol.is_a?(Regexp)
+      size = idx ? idx+$&.size : nil
+    else
+      size = idx ? idx+eol.size : nil
+    end
+    if limit and limit >= 0
+      size = [size, limit].min
+    end
+    consume_rbuff(size)
+  end
+
+  def each(eol=$/)
+    while line = self.gets(eol)
+      yield line
+    end
+  end
+  alias each_line each
+
+  def readlines(eol=$/)
+    ary = []
+    while line = self.gets(eol)
+      ary << line
+    end
+    ary
+  end
+
+  def readline(eol=$/)
+    raise EOFError if eof?
+    gets(eol)
+  end
+
+  def getc
+    c = read(1)
+    c ? c[0] : nil
+  end
+
+  def each_byte
+    while c = getc
+      yield(c)
+    end
+  end
+
+  def readchar
+    raise EOFError if eof?
+    getc
+  end
+
+  def ungetc(c)
+    @rbuffer[0,0] = c.chr
+  end
+
+  def eof?
+    fill_rbuff if !@eof && @rbuffer.empty?
+    @eof && @rbuffer.empty?
+  end
+  alias eof eof?
+
+  #
+  # for writing.
+  #
+  private
+
+  def do_write(s)
+    @wbuffer = "" unless defined? @wbuffer
+    @wbuffer << s
+    @sync ||= false
+    if @sync or @wbuffer.size > BLOCK_SIZE or idx = @wbuffer.rindex($/)
+      remain = idx ? idx + $/.size : @wbuffer.length
+      nwritten = 0
+      while remain > 0
+        str = @wbuffer[nwritten,remain]
+        begin
+          nwrote = syswrite(str)
+        rescue Errno::EAGAIN
+          retry
+        end
+        remain -= nwrote
+        nwritten += nwrote
+      end
+      @wbuffer[0,nwritten] = ""
+    end
+  end
+
+  public
+
+  def write(s)
+    do_write(s)
+    s.length
+  end
+
+  def << (s)
+    do_write(s)
+    self
+  end
+
+  def puts(*args)
+    s = ""
+    if args.empty?
+      s << "\n"
+    end
+    args.each{|arg|
+      s << arg.to_s
+      if $/ && /\n\z/ !~ s
+        s << "\n"
+      end
+    }
+    do_write(s)
+    nil
+  end
+
+  def print(*args)
+    s = ""
+    args.each{ |arg| s << arg.to_s }
+    do_write(s)
+    nil
+  end
+
+  def printf(s, *args)
+    do_write(s % args)
+    nil
+  end
+
+  def flush
+    osync = @sync
+    @sync = true
+    do_write ""
+    @sync = osync
+  end
+
+  def close
+    flush rescue nil
+    sysclose
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl/cipher.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl/cipher.rb
new file mode 100644 (file)
index 0000000..8fb9f22
--- /dev/null
@@ -0,0 +1,65 @@
+=begin
+= $RCSfile$ -- Ruby-space predefined Cipher subclasses
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: cipher.rb 12148 2007-04-05 05:59:22Z technorama $
+=end
+
+##
+# Should we care what if somebody require this file directly?
+#require 'openssl'
+
+module OpenSSL
+  class Cipher
+    %w(AES CAST5 BF DES IDEA RC2 RC4 RC5).each{|name|
+      klass = Class.new(Cipher){
+        define_method(:initialize){|*args|
+          cipher_name = args.inject(name){|n, arg| "#{n}-#{arg}" }
+          super(cipher_name)
+        }
+      }
+      const_set(name, klass)
+    }
+
+    %w(128 192 256).each{|keylen|
+      klass = Class.new(Cipher){
+        define_method(:initialize){|mode|
+          mode ||= "CBC"
+          cipher_name = "AES-#{keylen}-#{mode}"
+          super(cipher_name)
+        }
+      }
+      const_set("AES#{keylen}", klass)
+    }
+
+    # Generate, set, and return a random key.
+    # You must call cipher.encrypt or cipher.decrypt before calling this method.
+    def random_key
+      str = OpenSSL::Random.random_bytes(self.key_len)
+      self.key = str
+      return str
+    end
+
+    # Generate, set, and return a random iv.
+    # You must call cipher.encrypt or cipher.decrypt before calling this method.
+    def random_iv
+      str = OpenSSL::Random.random_bytes(self.iv_len)
+      self.iv = str
+      return str
+    end
+
+    # This class is only provided for backwards compatibility.  Use OpenSSL::Digest in the future.
+    class Cipher < Cipher
+      # add warning
+    end
+  end # Cipher
+end # OpenSSL
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl/digest.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl/digest.rb
new file mode 100644 (file)
index 0000000..7d65e33
--- /dev/null
@@ -0,0 +1,61 @@
+=begin
+= $RCSfile$ -- Ruby-space predefined Digest subclasses
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: digest.rb 15602 2008-02-25 08:51:18Z technorama $
+=end
+
+##
+# Should we care what if somebody require this file directly?
+#require 'openssl'
+
+module OpenSSL
+  class Digest
+
+    alg = %w(DSS DSS1 MD2 MD4 MD5 MDC2 RIPEMD160 SHA SHA1)
+    if OPENSSL_VERSION_NUMBER > 0x00908000
+      alg += %w(SHA224 SHA256 SHA384 SHA512)
+    end
+
+    def self.digest(name, data)
+        super(data, name)
+    end
+
+    alg.each{|name|
+      klass = Class.new(Digest){
+        define_method(:initialize){|*data|
+          if data.length > 1
+            raise ArgumentError,
+              "wrong number of arguments (#{data.length} for 1)"
+          end
+          super(name, data.first)
+        }
+      }
+      singleton = (class <<klass; self; end)
+      singleton.class_eval{
+        define_method(:digest){|data| Digest.digest(name, data) }
+        define_method(:hexdigest){|data| Digest.hexdigest(name, data) }
+      }
+      const_set(name, klass)
+    }
+
+    # This class is only provided for backwards compatibility.  Use OpenSSL::Digest in the future.
+    class Digest < Digest
+      def initialize(*args)
+        # add warning
+        super(*args)
+      end
+    end
+
+  end # Digest
+end # OpenSSL
+
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl/ssl.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl/ssl.rb
new file mode 100644 (file)
index 0000000..892c19f
--- /dev/null
@@ -0,0 +1,178 @@
+=begin
+= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for SSL
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2001 GOTOU YUUZOU <gotoyuzo@notwork.org>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: ssl.rb 14479 2007-12-22 08:31:53Z gotoyuzo $
+=end
+
+require "openssl"
+require "openssl/buffering"
+require "fcntl"
+
+module OpenSSL
+  module SSL
+    class SSLContext
+      DEFAULT_PARAMS = {
+        :ssl_version => "SSLv23",
+        :verify_mode => OpenSSL::SSL::VERIFY_PEER,
+        :ciphers => "ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW",
+        :options => OpenSSL::SSL::OP_ALL,
+      }
+
+      DEFAULT_CERT_STORE = OpenSSL::X509::Store.new
+      DEFAULT_CERT_STORE.set_default_paths
+      if defined?(OpenSSL::X509::V_FLAG_CRL_CHECK_ALL)
+        DEFAULT_CERT_STORE.flags = OpenSSL::X509::V_FLAG_CRL_CHECK_ALL
+      end
+
+      def set_params(params={})
+        params = DEFAULT_PARAMS.merge(params)
+        params.each{|name, value| self.__send__("#{name}=", value) }
+        if self.verify_mode != OpenSSL::SSL::VERIFY_NONE
+          unless self.ca_file or self.ca_path or self.cert_store
+            self.cert_store = DEFAULT_CERT_STORE
+          end
+        end
+        return params
+      end
+    end
+
+    module SocketForwarder
+      def addr
+        to_io.addr
+      end
+
+      def peeraddr
+        to_io.peeraddr
+      end
+
+      def setsockopt(level, optname, optval)
+        to_io.setsockopt(level, optname, optval)
+      end
+
+      def getsockopt(level, optname)
+        to_io.getsockopt(level, optname)
+      end
+
+      def fcntl(*args)
+        to_io.fcntl(*args)
+      end
+
+      def closed?
+        to_io.closed?
+      end
+
+      def do_not_reverse_lookup=(flag)
+        to_io.do_not_reverse_lookup = flag
+      end
+    end
+
+    module Nonblock
+      def initialize(*args)
+        flag = File::NONBLOCK
+        flag |= @io.fcntl(Fcntl::F_GETFL) if defined?(Fcntl::F_GETFL)
+        @io.fcntl(Fcntl::F_SETFL, flag)
+        super
+      end
+    end
+
+    def verify_certificate_identity(cert, hostname)
+      should_verify_common_name = true
+      cert.extensions.each{|ext|
+        next if ext.oid != "subjectAltName"
+        ext.value.split(/,\s+/).each{|general_name|
+          if /\ADNS:(.*)/ =~ general_name
+            should_verify_common_name = false
+            reg = Regexp.escape($1).gsub(/\\\*/, "[^.]+")
+            return true if /\A#{reg}\z/i =~ hostname
+          elsif /\AIP Address:(.*)/ =~ general_name
+            should_verify_common_name = false
+            return true if $1 == hostname
+          end
+        }
+      }
+      if should_verify_common_name
+        cert.subject.to_a.each{|oid, value|
+          if oid == "CN"
+            reg = Regexp.escape(value).gsub(/\\\*/, "[^.]+")
+            return true if /\A#{reg}\z/i =~ hostname
+          end
+        }
+      end
+      return false
+    end
+    module_function :verify_certificate_identity
+
+    class SSLSocket
+      include Buffering
+      include SocketForwarder
+      include Nonblock
+
+      def post_connection_check(hostname)
+        unless OpenSSL::SSL.verify_certificate_identity(peer_cert, hostname)
+          raise SSLError, "hostname was not match with the server certificate"
+        end
+        return true
+      end
+
+      def session
+        SSL::Session.new(self)
+      rescue SSL::Session::SessionError
+        nil
+      end
+    end
+
+    class SSLServer
+      include SocketForwarder
+      attr_accessor :start_immediately
+
+      def initialize(svr, ctx)
+        @svr = svr
+        @ctx = ctx
+        unless ctx.session_id_context
+          session_id = OpenSSL::Digest::MD5.hexdigest($0)
+          @ctx.session_id_context = session_id
+        end
+        @start_immediately = true
+      end
+
+      def to_io
+        @svr
+      end
+
+      def listen(backlog=5)
+        @svr.listen(backlog)
+      end
+
+      def shutdown(how=Socket::SHUT_RDWR)
+        @svr.shutdown(how)
+      end
+
+      def accept
+        sock = @svr.accept
+        begin
+          ssl = OpenSSL::SSL::SSLSocket.new(sock, @ctx)
+          ssl.sync_close = true
+          ssl.accept if @start_immediately
+          ssl
+        rescue SSLError => ex
+          sock.close
+          raise ex
+        end
+      end
+
+      def close
+        @svr.close
+      end
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/openssl/x509.rb b/lib/ruby-1.9.1-rc1/.ext/common/openssl/x509.rb
new file mode 100644 (file)
index 0000000..179c909
--- /dev/null
@@ -0,0 +1,155 @@
+=begin
+= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for X509 and subclasses
+
+= Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
+  All rights reserved.
+
+= Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+= Version
+  $Id: x509.rb 15442 2008-02-12 06:18:06Z naruse $
+=end
+
+require "openssl"
+
+module OpenSSL
+  module X509
+    class ExtensionFactory
+      def create_extension(*arg)
+        if arg.size > 1
+          create_ext(*arg)
+        else
+          send("create_ext_from_"+arg[0].class.name.downcase, arg[0])
+        end
+      end
+
+      def create_ext_from_array(ary)
+        raise ExtensionError, "unexpected array form" if ary.size > 3 
+        create_ext(ary[0], ary[1], ary[2])
+      end
+
+      def create_ext_from_string(str) # "oid = critical, value"
+        oid, value = str.split(/=/, 2)
+        oid.strip!
+        value.strip!
+        create_ext(oid, value)
+      end
+      
+      def create_ext_from_hash(hash)
+        create_ext(hash["oid"], hash["value"], hash["critical"])
+      end
+    end
+    
+    class Extension
+      def to_s # "oid = critical, value"
+        str = self.oid
+        str << " = "
+        str << "critical, " if self.critical?
+        str << self.value.gsub(/\n/, ", ")
+      end
+        
+      def to_h # {"oid"=>sn|ln, "value"=>value, "critical"=>true|false}
+        {"oid"=>self.oid,"value"=>self.value,"critical"=>self.critical?}
+      end
+
+      def to_a
+        [ self.oid, self.value, self.critical? ]
+      end
+    end
+
+    class Name
+      module RFC2253DN
+        Special = ',=+<>#;'
+        HexChar = /[0-9a-fA-F]/
+        HexPair = /#{HexChar}#{HexChar}/
+        HexString = /#{HexPair}+/
+        Pair = /\\(?:[#{Special}]|\\|"|#{HexPair})/
+        StringChar = /[^#{Special}\\"]/
+        QuoteChar = /[^\\"]/
+        AttributeType = /[a-zA-Z][0-9a-zA-Z]*|[0-9]+(?:\.[0-9]+)*/
+        AttributeValue = /
+          (?!["#])((?:#{StringChar}|#{Pair})*)|
+          \#(#{HexString})|
+          "((?:#{QuoteChar}|#{Pair})*)"
+        /x
+        TypeAndValue = /\A(#{AttributeType})=#{AttributeValue}/
+
+        module_function
+
+        def expand_pair(str)
+          return nil unless str
+          return str.gsub(Pair){
+            pair = $&
+            case pair.size
+            when 2 then pair[1,1]
+            when 3 then Integer("0x#{pair[1,2]}").chr
+            else raise OpenSSL::X509::NameError, "invalid pair: #{str}"
+            end
+          }
+        end
+
+        def expand_hexstring(str)
+          return nil unless str
+          der = str.gsub(HexPair){$&.to_i(16).chr }
+          a1 = OpenSSL::ASN1.decode(der)
+          return a1.value, a1.tag
+        end
+
+        def expand_value(str1, str2, str3)
+          value = expand_pair(str1)
+          value, tag = expand_hexstring(str2) unless value
+          value = expand_pair(str3) unless value
+          return value, tag
+        end
+
+        def scan(dn)
+          str = dn
+          ary = []
+          while true
+            if md = TypeAndValue.match(str)
+              matched = md.to_s
+              remain = md.post_match
+              type = md[1]
+              value, tag = expand_value(md[2], md[3], md[4]) rescue nil
+              if value
+                type_and_value = [type, value]
+                type_and_value.push(tag) if tag
+                ary.unshift(type_and_value)
+                if remain.length > 2 && remain[0] == ?,
+                  str = remain[1..-1]
+                  next
+                elsif remain.length > 2 && remain[0] == ?+
+                  raise OpenSSL::X509::NameError,
+                    "multi-valued RDN is not supported: #{dn}"
+                elsif remain.empty?
+                  break
+                end
+              end
+            end
+            msg_dn = dn[0, dn.length - str.length] + " =>" + str
+            raise OpenSSL::X509::NameError, "malformed RDN: #{msg_dn}"
+          end
+          return ary
+        end
+      end
+
+      class <<self
+        def parse_rfc2253(str, template=OBJECT_TYPE_TEMPLATE)
+          ary = OpenSSL::X509::Name::RFC2253DN.scan(str)
+          self.new(ary, template)
+        end
+
+        def parse_openssl(str, template=OBJECT_TYPE_TEMPLATE)
+          ary = str.scan(/\s*([^\/,]+)\s*/).collect{|i| i[0].split("=", 2) }
+          self.new(ary, template)
+        end
+
+        alias parse parse_openssl
+      end
+    end
+  end
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/ripper.rb b/lib/ruby-1.9.1-rc1/.ext/common/ripper.rb
new file mode 100644 (file)
index 0000000..cb19da3
--- /dev/null
@@ -0,0 +1,4 @@
+require 'ripper/core'
+require 'ripper/lexer'
+require 'ripper/filter'
+require 'ripper/sexp'
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/ripper/core.rb b/lib/ruby-1.9.1-rc1/.ext/common/ripper/core.rb
new file mode 100644 (file)
index 0000000..211f722
--- /dev/null
@@ -0,0 +1,70 @@
+#
+# $Id: core.rb 11708 2007-02-12 23:01:19Z shyouhei $
+#
+# Copyright (c) 2003-2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper.so'
+
+class Ripper
+
+  # Parses Ruby program read from _src_.
+  # _src_ must be a String or a IO or a object which has #gets method.
+  def Ripper.parse(src, filename = '(ripper)', lineno = 1)
+    new(src, filename, lineno).parse
+  end
+
+  # This array contains name of parser events.
+  PARSER_EVENTS = PARSER_EVENT_TABLE.keys
+
+  # This array contains name of scanner events.
+  SCANNER_EVENTS = SCANNER_EVENT_TABLE.keys
+
+  # This array contains name of all ripper events.
+  EVENTS = PARSER_EVENTS + SCANNER_EVENTS
+
+  private
+
+  #
+  # Parser Events
+  #
+
+  PARSER_EVENT_TABLE.each do |id, arity|
+    module_eval(<<-End, __FILE__, __LINE__ + 1)
+      def on_#{id}(#{ ('a'..'z').to_a[0, arity].join(', ') })
+        #{arity == 0 ? 'nil' : 'a'}
+      end
+    End
+  end
+
+  # This method is called when weak warning is produced by the parser.
+  # _fmt_ and _args_ is printf style.
+  def warn(fmt, *args)
+  end
+
+  # This method is called when strong warning is produced by the parser.
+  # _fmt_ and _args_ is printf style.
+  def warning(fmt, *args)
+  end
+
+  # This method is called when the parser found syntax error.
+  def compile_error(msg)
+  end
+
+  #
+  # Scanner Events
+  #
+
+  SCANNER_EVENTS.each do |id|
+    module_eval(<<-End, __FILE__, __LINE__ + 1)
+      def on_#{id}(token)
+        token
+      end
+    End
+  end
+
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/ripper/filter.rb b/lib/ruby-1.9.1-rc1/.ext/common/ripper/filter.rb
new file mode 100644 (file)
index 0000000..0c37c79
--- /dev/null
@@ -0,0 +1,70 @@
+#
+# $Id: filter.rb 11708 2007-02-12 23:01:19Z shyouhei $
+#
+# Copyright (c) 2004,2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper/lexer'
+
+class Ripper
+
+  # This class handles only scanner events,
+  # and they are dispatched in the `right' order (same with input).
+  class Filter
+
+    def initialize(src, filename = '-', lineno = 1)
+      @__lexer = Lexer.new(src, filename, lineno)
+      @__line = nil
+      @__col = nil
+    end
+
+    # The file name of the input.
+    def filename
+      @__lexer.filename
+    end
+
+    # The line number of the current token.
+    # This value starts from 1.
+    # This method is valid only in event handlers.
+    def lineno
+      @__line
+    end
+
+    # The column number of the current token.
+    # This value starts from 0.
+    # This method is valid only in event handlers.
+    def column
+      @__col
+    end
+
+    # Starts parsing.  _init_ is a data accumulator.
+    # It is passed to the next event handler (as of Enumerable#inject).
+    def parse(init = nil)
+      data = init
+      @__lexer.lex.each do |pos, event, tok|
+        @__line, @__col = *pos
+        data = if respond_to?(event, true)
+               then __send__(event, tok, data)
+               else on_default(event, tok, data)
+               end
+      end
+      data
+    end
+
+    private
+
+    # This method is called when some event handler have not defined.
+    # _event_ is :on_XXX, _token_ is scanned token, _data_ is a data
+    # accumulator.  The return value of this method is passed to the
+    # next event handler (as of Enumerable#inject).
+    def on_default(event, token, data)
+      data
+    end
+
+  end
+
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/ripper/lexer.rb b/lib/ruby-1.9.1-rc1/.ext/common/ripper/lexer.rb
new file mode 100644 (file)
index 0000000..df76dd5
--- /dev/null
@@ -0,0 +1,179 @@
+#
+# $Id: lexer.rb 13966 2007-11-19 07:10:09Z matz $
+#
+# Copyright (c) 2004,2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper/core'
+
+class Ripper
+
+  # Tokenizes Ruby program and returns an Array of String.
+  def Ripper.tokenize(src, filename = '-', lineno = 1)
+    Lexer.new(src, filename, lineno).tokenize
+  end
+
+  # Tokenizes Ruby program and returns an Array of Array,
+  # which is formatted like [[lineno, column], type, token].
+  #
+  #   require 'ripper'
+  #   require 'pp'
+  #
+  #   p Ripper.lex("def m(a) nil end")
+  #     #=> [[[1,  0], :on_kw,     "def"],
+  #          [[1,  3], :on_sp,     " "  ],
+  #          [[1,  4], :on_ident,  "m"  ],
+  #          [[1,  5], :on_lparen, "("  ],
+  #          [[1,  6], :on_ident,  "a"  ],
+  #          [[1,  7], :on_rparen, ")"  ],
+  #          [[1,  8], :on_sp,     " "  ],
+  #          [[1,  9], :on_kw,     "nil"],
+  #          [[1, 12], :on_sp,     " "  ],
+  #          [[1, 13], :on_kw,     "end"]]
+  #
+  def Ripper.lex(src, filename = '-', lineno = 1)
+    Lexer.new(src, filename, lineno).lex
+  end
+
+  class Lexer < ::Ripper   #:nodoc: internal use only
+    def tokenize
+      lex().map {|pos, event, tok| tok }
+    end
+
+    def lex
+      parse().sort_by {|pos, event, tok| pos }
+    end
+
+    def parse
+      @buf = []
+      super
+      @buf
+    end
+
+    private
+
+    SCANNER_EVENTS.each do |event|
+      module_eval(<<-End, __FILE__+'/module_eval', __LINE__ + 1)
+        def on_#{event}(tok)
+          @buf.push [[lineno(), column()], :on_#{event}, tok]
+        end
+      End
+    end
+  end
+
+  # [EXPERIMENTAL]
+  # Parses +src+ and return a string which was matched to +pattern+.
+  # +pattern+ should be described as Regexp.
+  #
+  #   require 'ripper'
+  #
+  #   p Ripper.slice('def m(a) nil end', 'ident')                   #=> "m"
+  #   p Ripper.slice('def m(a) nil end', '[ident lparen rparen]+')  #=> "m(a)"
+  #   p Ripper.slice("<<EOS\nstring\nEOS",
+  #                  'heredoc_beg nl $(tstring_content*) heredoc_end', 1)
+  #       #=> "string\n"
+  #
+  def Ripper.slice(src, pattern, n = 0)
+    if m = token_match(src, pattern)
+    then m.string(n)
+    else nil
+    end
+  end
+
+  def Ripper.token_match(src, pattern)   #:nodoc:
+    TokenPattern.compile(pattern).match(src)
+  end
+
+  class TokenPattern   #:nodoc:
+
+    class Error < ::StandardError; end
+    class CompileError < Error; end
+    class MatchError < Error; end
+
+    class << self
+      alias compile new
+    end
+
+    def initialize(pattern)
+      @source = pattern
+      @re = compile(pattern)
+    end
+
+    def match(str)
+      match_list(::Ripper.lex(str))
+    end
+
+    def match_list(tokens)
+      if m = @re.match(map_tokens(tokens))
+      then MatchData.new(tokens, m)
+      else nil
+      end
+    end
+
+    private
+
+    def compile(pattern)
+      if m = /[^\w\s$()\[\]{}?*+\.]/.match(pattern)
+        raise CompileError, "invalid char in pattern: #{m[0].inspect}"
+      end
+      buf = ''
+      pattern.scan(/(?:\w+|\$\(|[()\[\]\{\}?*+\.]+)/) do |tok|
+        case tok
+        when /\w/
+          buf.concat map_token(tok)
+        when '$('
+          buf.concat '('
+        when '('
+          buf.concat '(?:'
+        when /[?*\[\])\.]/
+          buf.concat tok
+        else
+          raise 'must not happen'
+        end
+      end
+      Regexp.compile(buf)
+    rescue RegexpError => err
+      raise CompileError, err.message
+    end
+
+    def map_tokens(tokens)
+      tokens.map {|pos,type,str| map_token(type.to_s.sub(/\Aon_/,'')) }.join
+    end
+
+    MAP = {}
+    seed = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+    SCANNER_EVENT_TABLE.each do |ev, |
+      raise CompileError, "[RIPPER FATAL] too many system token" if seed.empty?
+      MAP[ev.to_s.sub(/\Aon_/,'')] = seed.shift
+    end
+
+    def map_token(tok)
+      MAP[tok]  or raise CompileError, "unknown token: #{tok}"
+    end
+
+    class MatchData
+      def initialize(tokens, match)
+        @tokens = tokens
+        @match = match
+      end
+
+      def string(n = 0)
+        return nil unless @match
+        match(n).join
+      end
+
+      private
+
+      def match(n = 0)
+        return [] unless @match
+        @tokens[@match.begin(n)...@match.end(n)].map {|pos,type,str| str }
+      end
+    end
+  
+  end
+
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/common/ripper/sexp.rb b/lib/ruby-1.9.1-rc1/.ext/common/ripper/sexp.rb
new file mode 100644 (file)
index 0000000..572def9
--- /dev/null
@@ -0,0 +1,99 @@
+#
+# $Id: sexp.rb 13465 2007-09-17 12:02:35Z aamine $
+#
+# Copyright (c) 2004,2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper/core'
+
+class Ripper
+
+  # [EXPERIMENTAL]
+  # Parses +src+ and create S-exp tree.
+  # This method is for mainly developper use.
+  #
+  #   require 'ripper'
+  #   require 'pp
+  #
+  #   pp Ripper.sexp("def m(a) nil end")
+  #     #=> [:program,
+  #          [:stmts_add,
+  #           [:stmts_new],
+  #           [:def,
+  #            [:@ident, "m", [1, 4]],
+  #            [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
+  #            [:bodystmt,
+  #             [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
+  #             nil,
+  #             nil,
+  #             nil]]]]
+  #
+  def Ripper.sexp(src, filename = '-', lineno = 1)
+    SexpBuilderPP.new(src, filename, lineno).parse
+  end
+
+  def Ripper.sexp_raw(src, filename = '-', lineno = 1)
+    SexpBuilder.new(src, filename, lineno).parse
+  end
+
+  class SexpBuilderPP < ::Ripper   #:nodoc:
+    private
+
+    PARSER_EVENT_TABLE.each do |event, arity|
+      if /_new\z/ =~ event.to_s and arity == 0
+        module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def on_#{event}
+            []
+          end
+        End
+      elsif /_add\z/ =~ event.to_s
+        module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def on_#{event}(list, item)
+            list.push item
+            list
+          end
+        End
+      else
+        module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def on_#{event}(*args)
+            [:#{event}, *args]
+          end
+        End
+      end
+    end
+
+    SCANNER_EVENTS.each do |event|
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def on_#{event}(tok)
+          [:@#{event}, tok, [lineno(), column()]]
+        end
+      End
+    end
+  end
+
+  class SexpBuilder < ::Ripper   #:nodoc:
+    private
+
+    PARSER_EVENTS.each do |event|
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def on_#{event}(*args)
+          args.unshift :#{event}
+          args
+        end
+      End
+    end
+
+    SCANNER_EVENTS.each do |event|
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def on_#{event}(tok)
+          [:@#{event}, tok, [lineno(), column()]]
+        end
+      End
+    end
+  end
+
+end
diff --git a/lib/ruby-1.9.1-rc1/.ext/include/arm-linux/ruby/config.h b/lib/ruby-1.9.1-rc1/.ext/include/arm-linux/ruby/config.h
new file mode 100644 (file)
index 0000000..8ff3088
--- /dev/null
@@ -0,0 +1,182 @@
+#define PACKAGE_NAME ""
+#define PACKAGE_TARNAME ""
+#define PACKAGE_VERSION ""
+#define PACKAGE_STRING ""
+#define PACKAGE_BUGREPORT ""
+#define CANONICALIZATION_FOR_MATHN 1
+#define STDC_HEADERS 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRING_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_UNISTD_H 1
+#define __EXTENSIONS__ 1
+#define _ALL_SOURCE 1
+#define _GNU_SOURCE 1
+#define _POSIX_PTHREAD_SEMANTICS 1
+#define _TANDEM_SOURCE 1
+#define HAVE_LONG_LONG 1
+#define HAVE_OFF_T 1
+#define SIZEOF_INT 4
+#define SIZEOF_SHORT 2
+#define SIZEOF_LONG 4
+#define SIZEOF_LONG_LONG 8
+#define SIZEOF___INT64 0
+#define SIZEOF_OFF_T 4
+#define SIZEOF_VOIDP 4
+#define SIZEOF_FLOAT 4
+#define SIZEOF_DOUBLE 8
+#define SIZEOF_TIME_T 4
+#define rb_pid_t pid_t
+#define PIDT2NUM(v) LONG2NUM(v)
+#define NUM2PIDT(v) NUM2LONG(v)
+#define rb_uid_t uid_t
+#define UIDT2NUM(v) ULONG2NUM(v)
+#define NUM2UIDT(v) NUM2ULONG(v)
+#define rb_gid_t gid_t
+#define GIDT2NUM(v) ULONG2NUM(v)
+#define NUM2GIDT(v) NUM2ULONG(v)
+#define HAVE_PROTOTYPES 1
+#define TOKEN_PASTE(x,y) x##y
+#define STRINGIZE(expr) STRINGIZE0(expr)
+#define HAVE_STDARG_PROTOTYPES 1
+#define HAVE_VA_ARGS_MACRO 1
+#define NORETURN(x) __attribute__ ((noreturn)) x
+#define DEPRECATED(x) __attribute__ ((deprecated)) x
+#define NOINLINE(x) __attribute__ ((noinline)) x
+#define FUNC_STDCALL(x) x
+#define FUNC_CDECL(x) x
+#define FUNC_FASTCALL(x) x
+#define RUBY_ALIAS_FUNCTION(old_prot, new_name, args) VALUE old_prot __attribute__((alias(#new_name)));
+#define HAVE_DECL_SYS_NERR 1
+#define HAVE_LIBDL 1
+#define HAVE_DIRENT_H 1
+#define HAVE_SYS_WAIT_H 1
+#define HAVE_LIMITS_H 1
+#define HAVE_SYS_FILE_H 1
+#define HAVE_SYS_IOCTL_H 1
+#define HAVE_SYS_SYSCALL_H 1
+#define HAVE_FCNTL_H 1
+#define HAVE_SYS_SELECT_H 1
+#define HAVE_SYS_TIME_H 1
+#define HAVE_SYS_TIMES_H 1
+#define HAVE_SYS_PARAM_H 1
+#define HAVE_PWD_H 1
+#define HAVE_GRP_H 1
+#define HAVE_A_OUT_H 1
+#define HAVE_UTIME_H 1
+#define HAVE_SYS_RESOURCE_H 1
+#define HAVE_SYS_UTIME_H 1
+#define HAVE_NETINET_IN_SYSTM_H 1
+#define HAVE_FLOAT_H 1
+#define HAVE_PTHREAD_H 1
+#define HAVE_LOCALE_H 1
+#define HAVE_SYS_SENDFILE_H 1
+#define HAVE_TIME_H 1
+#define HAVE_SYS_SOCKET_H 1
+#define SIZEOF_RLIM_T 0
+#define SIZEOF_SIZE_T 4
+#define SIZEOF_PTRDIFF_T 4
+#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
+#define HAVE_ST_BLKSIZE 1
+#define HAVE_STRUCT_STAT_ST_BLOCKS 1
+#define HAVE_ST_BLOCKS 1
+#define HAVE_STRUCT_STAT_ST_RDEV 1
+#define HAVE_ST_RDEV 1
+#define HAVE_STRUCT_TIMESPEC 1
+#define HAVE_INT8_T 1
+#define HAVE_UINT8_T 1
+#define HAVE_INT16_T 1
+#define HAVE_UINT16_T 1
+#define HAVE_INT32_T 1
+#define HAVE_UINT32_T 1
+#define HAVE_INT64_T 1
+#define HAVE_UINT64_T 1
+#define HAVE_INTPTR_T 1
+#define HAVE_UINTPTR_T 1
+#define HAVE_SSIZE_T 1
+#define GETGROUPS_T gid_t
+#define RETSIGTYPE void
+#define HAVE_ALLOCA_H 1
+#define HAVE_ALLOCA 1
+#define HAVE_MEMMOVE 1
+#define HAVE_STRERROR 1
+#define HAVE_STRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_VSNPRINTF 1
+#define HAVE_ISNAN 1
+#define HAVE_FINITE 1
+#define HAVE_ISINF 1
+#define HAVE_HYPOT 1
+#define HAVE_ACOSH 1
+#define HAVE_ERF 1
+#define HAVE_TGAMMA 1
+#define HAVE_LGAMMA_R 1
+#define HAVE_CBRT 1
+#define HAVE_STRLCPY 1
+#define HAVE_STRLCAT 1
+#define HAVE_FMOD 1
+#define HAVE_WAITPID 1
+#define HAVE_SYSCALL 1
+#define HAVE_TRUNCATE 1
+#define HAVE_TIMES 1
+#define HAVE_LSTAT 1
+#define HAVE_SOCKETPAIR 1
+#define HAVE_GETPRIORITY 1
+#define HAVE_GETRLIMIT 1
+#define HAVE_SETRLIMIT 1
+#define HAVE_DLOPEN 1
+#define HAVE_SIGPROCMASK 1
+#define HAVE_SIGACTION 1
+#define HAVE_SIGSETJMP 1
+#define HAVE__SETJMP 1
+#define HAVE__LONGJMP 1
+#define HAVE_COSH 1
+#define HAVE_SINH 1
+#define HAVE_TANH 1
+#define HAVE_ROUND 1
+#define HAVE_SETENV 1
+#define HAVE_UNSETENV 1
+#define HAVE_MKTIME 1
+#define HAVE_GMTIME_R 1
+#define HAVE_CLOCK_GETTIME 1
+#define HAVE_SENDFILE 1
+#define HAVE_SHUTDOWN 1
+#define RUBY_SETJMP(env) _setjmp(env)
+#define RUBY_LONGJMP(env,val) _longjmp(env,val)
+#define RUBY_JMP_BUF jmp_buf
+#define HAVE_STRUCT_TM_TM_ZONE 1
+#define HAVE_TM_ZONE 1
+#define HAVE_STRUCT_TM_TM_GMTOFF 1
+#define HAVE_VAR_TIMEZONE 1
+#define TYPEOF_VAR_TIMEZONE long
+#define NEGATIVE_TIME_T 1
+#define POSIX_SIGNAL 1
+#define GETPGRP_VOID 1
+#define SETPGRP_VOID 1
+#define RSHIFT(x,y) ((x)>>(int)y)
+#define FILE_COUNT _r
+#define FILE_READPTR _p
+#define HUGE_ST_INO 1
+#define STACK_GROW_DIRECTION 0
+#define _REENTRANT 1
+#define _THREAD_SAFE 1
+#define HAVE_LIBPTHREAD 1
+#define HAVE_NANOSLEEP 1
+#define HAVE_SCHED_YIELD 1
+#define USE_ELF 1
+#define DLEXT_MAXLEN 3
+#define DLEXT ".so"
+#define RUBY_LIB "/usr/local/lib/ruby/1.9.1"
+#define RUBY_SITE_LIB "/usr/local/lib/ruby/site_ruby"
+#define RUBY_SITE_LIB2 "/usr/local/lib/ruby/site_ruby/1.9.1"
+#define RUBY_VENDOR_LIB "/usr/local/lib/ruby/vendor_ruby"
+#define RUBY_VENDOR_LIB2 "/usr/local/lib/ruby/vendor_ruby/1.9.1"
+#define RUBY_PLATFORM "arm-linux"
+#define RUBY_ARCHLIB "/usr/local/lib/ruby/1.9.1/arm-linux"
+#define RUBY_SITE_ARCHLIB "/usr/local/lib/ruby/site_ruby/1.9.1/arm-linux"
+#define RUBY_VENDOR_ARCHLIB "/usr/local/lib/ruby/vendor_ruby/1.9.1/arm-linux"
diff --git a/lib/ruby-1.9.1-rc1/.ext/include/ruby/digest.h b/lib/ruby-1.9.1-rc1/.ext/include/ruby/digest.h
new file mode 100644 (file)
index 0000000..a108588
--- /dev/null
@@ -0,0 +1,32 @@
+/************************************************
+
+  digest.h - header file for ruby digest modules
+
+  $Author: shyouhei $
+  created at: Fri May 25 08:54:56 JST 2001
+
+
+  Copyright (C) 2001-2006 Akinori MUSHA
+
+  $RoughId: digest.h,v 1.3 2001/07/13 15:38:27 knu Exp $
+  $Id: digest.h 11708 2007-02-12 23:01:19Z shyouhei $
+
+************************************************/
+
+#include "ruby.h"
+
+#define RUBY_DIGEST_API_VERSION        2
+
+typedef void (*rb_digest_hash_init_func_t)(void *);
+typedef void (*rb_digest_hash_update_func_t)(void *, unsigned char *, size_t);
+typedef void (*rb_digest_hash_finish_func_t)(void *, unsigned char *);
+
+typedef struct {
+    int api_version;
+    size_t digest_len;
+    size_t block_len;
+    size_t ctx_size;
+    rb_digest_hash_init_func_t init_func;
+    rb_digest_hash_update_func_t update_func;
+    rb_digest_hash_finish_func_t finish_func;
+} rb_digest_metadata_t;
diff --git a/lib/ruby-1.9.1-rc1/.ext/include/ruby/dl.h b/lib/ruby-1.9.1-rc1/.ext/include/ruby/dl.h
new file mode 100644 (file)
index 0000000..87a5994
--- /dev/null
@@ -0,0 +1,226 @@
+#ifndef RUBY_DL_H
+#define RUBY_DL_H
+
+#include <ruby.h>
+
+#if !defined(FUNC_CDECL)
+#  define FUNC_CDECL(x) x
+#endif
+#if !defined(FUNC_STDCALL)
+#  define FUNC_STDCALL(x) x
+#endif
+
+#if defined(HAVE_DLFCN_H)
+# include <dlfcn.h>
+# /* some stranger systems may not define all of these */
+#ifndef RTLD_LAZY
+#define RTLD_LAZY 0
+#endif
+#ifndef RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+#ifndef RTLD_NOW
+#define RTLD_NOW 0
+#endif
+#else
+# if defined(HAVE_WINDOWS_H)
+#   include <windows.h>
+#   define dlclose(ptr) FreeLibrary((HINSTANCE)ptr)
+#   define dlopen(name,flag) ((void*)LoadLibrary(name))
+#   define dlerror()    "unknown error"
+#   define dlsym(handle,name) ((void*)GetProcAddress(handle,name))
+#   define RTLD_LAZY -1
+#   define RTLD_NOW  -1
+#   define RTLD_GLOBAL -1
+# endif
+#endif
+
+#define MAX_CALLBACK 5
+#define DLSTACK_TYPE long
+#define DLSTACK_SIZE (20)
+#define DLSTACK_PROTO \
+    DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,\
+    DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,\
+    DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,\
+    DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE
+#define DLSTACK_ARGS(stack) \
+    stack[0],stack[1],stack[2],stack[3],stack[4],\
+    stack[5],stack[6],stack[7],stack[8],stack[9],\
+    stack[10],stack[11],stack[12],stack[13],stack[14],\
+    stack[15],stack[16],stack[17],stack[18],stack[19]
+
+#define DLSTACK_PROTO0 
+#define DLSTACK_PROTO1_ DLSTACK_TYPE
+#define DLSTACK_PROTO2_ DLSTACK_PROTO1_, DLSTACK_TYPE
+#define DLSTACK_PROTO3_ DLSTACK_PROTO2_, DLSTACK_TYPE
+#define DLSTACK_PROTO4_ DLSTACK_PROTO3_, DLSTACK_TYPE
+#define DLSTACK_PROTO4_ DLSTACK_PROTO3_, DLSTACK_TYPE
+#define DLSTACK_PROTO5_ DLSTACK_PROTO4_, DLSTACK_TYPE
+#define DLSTACK_PROTO6_ DLSTACK_PROTO5_, DLSTACK_TYPE
+#define DLSTACK_PROTO7_ DLSTACK_PROTO6_, DLSTACK_TYPE
+#define DLSTACK_PROTO8_ DLSTACK_PROTO7_, DLSTACK_TYPE
+#define DLSTACK_PROTO9_ DLSTACK_PROTO8_, DLSTACK_TYPE
+#define DLSTACK_PROTO10_ DLSTACK_PROTO9_, DLSTACK_TYPE
+#define DLSTACK_PROTO11_ DLSTACK_PROTO10_, DLSTACK_TYPE
+#define DLSTACK_PROTO12_ DLSTACK_PROTO11_, DLSTACK_TYPE
+#define DLSTACK_PROTO13_ DLSTACK_PROTO12_, DLSTACK_TYPE
+#define DLSTACK_PROTO14_ DLSTACK_PROTO13_, DLSTACK_TYPE
+#define DLSTACK_PROTO14_ DLSTACK_PROTO13_, DLSTACK_TYPE
+#define DLSTACK_PROTO15_ DLSTACK_PROTO14_, DLSTACK_TYPE
+#define DLSTACK_PROTO16_ DLSTACK_PROTO15_, DLSTACK_TYPE
+#define DLSTACK_PROTO17_ DLSTACK_PROTO16_, DLSTACK_TYPE
+#define DLSTACK_PROTO18_ DLSTACK_PROTO17_, DLSTACK_TYPE
+#define DLSTACK_PROTO19_ DLSTACK_PROTO18_, DLSTACK_TYPE
+#define DLSTACK_PROTO20_ DLSTACK_PROTO19_, DLSTACK_TYPE
+
+/*
+ * Add ",..." as the last argument.
+ * This is required for variable argument functions such
+ * as fprintf() on x86_64-linux.
+ *
+ * http://refspecs.linuxfoundation.org/elf/x86_64-abi-0.95.pdf
+ * page 19:
+ *
+ *   For calls that may call functions that use varargs or stdargs
+ *   (prototype-less calls or calls to functions containing ellipsis
+ *   (...) in the declaration) %al is used as hidden argument to
+ *   specify the number of SSE registers used.
+ */
+#define DLSTACK_PROTO1 DLSTACK_PROTO1_, ...
+#define DLSTACK_PROTO2 DLSTACK_PROTO2_, ...
+#define DLSTACK_PROTO3 DLSTACK_PROTO3_, ...
+#define DLSTACK_PROTO4 DLSTACK_PROTO4_, ...
+#define DLSTACK_PROTO4 DLSTACK_PROTO4_, ...
+#define DLSTACK_PROTO5 DLSTACK_PROTO5_, ...
+#define DLSTACK_PROTO6 DLSTACK_PROTO6_, ...
+#define DLSTACK_PROTO7 DLSTACK_PROTO7_, ...
+#define DLSTACK_PROTO8 DLSTACK_PROTO8_, ...
+#define DLSTACK_PROTO9 DLSTACK_PROTO9_, ...
+#define DLSTACK_PROTO10 DLSTACK_PROTO10_, ...
+#define DLSTACK_PROTO11 DLSTACK_PROTO11_, ...
+#define DLSTACK_PROTO12 DLSTACK_PROTO12_, ...
+#define DLSTACK_PROTO13 DLSTACK_PROTO13_, ...
+#define DLSTACK_PROTO14 DLSTACK_PROTO14_, ...
+#define DLSTACK_PROTO14 DLSTACK_PROTO14_, ...
+#define DLSTACK_PROTO15 DLSTACK_PROTO15_, ...
+#define DLSTACK_PROTO16 DLSTACK_PROTO16_, ...
+#define DLSTACK_PROTO17 DLSTACK_PROTO17_, ...
+#define DLSTACK_PROTO18 DLSTACK_PROTO18_, ...
+#define DLSTACK_PROTO19 DLSTACK_PROTO19_, ...
+#define DLSTACK_PROTO20 DLSTACK_PROTO20_, ...
+
+#define DLSTACK_ARGS0(stack)
+#define DLSTACK_ARGS1(stack) stack[0]
+#define DLSTACK_ARGS2(stack) DLSTACK_ARGS1(stack), stack[1]
+#define DLSTACK_ARGS3(stack) DLSTACK_ARGS2(stack), stack[2]
+#define DLSTACK_ARGS4(stack) DLSTACK_ARGS3(stack), stack[3]
+#define DLSTACK_ARGS5(stack) DLSTACK_ARGS4(stack), stack[4]
+#define DLSTACK_ARGS6(stack) DLSTACK_ARGS5(stack), stack[5]
+#define DLSTACK_ARGS7(stack) DLSTACK_ARGS6(stack), stack[6]
+#define DLSTACK_ARGS8(stack) DLSTACK_ARGS7(stack), stack[7]
+#define DLSTACK_ARGS9(stack) DLSTACK_ARGS8(stack), stack[8]
+#define DLSTACK_ARGS10(stack) DLSTACK_ARGS9(stack), stack[9]
+#define DLSTACK_ARGS11(stack) DLSTACK_ARGS10(stack), stack[10]
+#define DLSTACK_ARGS12(stack) DLSTACK_ARGS11(stack), stack[11]
+#define DLSTACK_ARGS13(stack) DLSTACK_ARGS12(stack), stack[12]
+#define DLSTACK_ARGS14(stack) DLSTACK_ARGS13(stack), stack[13]
+#define DLSTACK_ARGS15(stack) DLSTACK_ARGS14(stack), stack[14]
+#define DLSTACK_ARGS16(stack) DLSTACK_ARGS15(stack), stack[15]
+#define DLSTACK_ARGS17(stack) DLSTACK_ARGS16(stack), stack[16]
+#define DLSTACK_ARGS18(stack) DLSTACK_ARGS17(stack), stack[17]
+#define DLSTACK_ARGS19(stack) DLSTACK_ARGS18(stack), stack[18]
+#define DLSTACK_ARGS20(stack) DLSTACK_ARGS19(stack), stack[19]
+
+extern VALUE rb_mDL;
+extern VALUE rb_cDLHandle;
+extern VALUE rb_cDLSymbol;
+extern VALUE rb_eDLError;
+extern VALUE rb_eDLTypeError;
+
+typedef struct { char c; void *x; } s_voidp;
+typedef struct { char c; short x; } s_short;
+typedef struct { char c; int x; } s_int;
+typedef struct { char c; long x; } s_long;
+typedef struct { char c; float x; } s_float;
+typedef struct { char c; double x; } s_double;
+#if HAVE_LONG_LONG
+typedef struct { char c; LONG_LONG x; } s_long_long;
+#endif
+
+#define ALIGN_VOIDP  (sizeof(s_voidp) - sizeof(void *))
+#define ALIGN_SHORT  (sizeof(s_short) - sizeof(short))
+#define ALIGN_CHAR   (1)
+#define ALIGN_INT    (sizeof(s_int) - sizeof(int))
+#define ALIGN_LONG   (sizeof(s_long) - sizeof(long))
+#if HAVE_LONG_LONG
+#define ALIGN_LONG_LONG (sizeof(s_long_long) - sizeof(LONG_LONG))
+#endif
+#define ALIGN_FLOAT  (sizeof(s_float) - sizeof(float))
+#define ALIGN_DOUBLE (sizeof(s_double) - sizeof(double))
+
+#define DLALIGN(ptr,offset,align) {\
+  while( (((unsigned long)((char *)ptr + offset)) % align) != 0 ) offset++;\
+}
+
+
+#define DLTYPE_VOID  0
+#define DLTYPE_VOIDP 1
+#define DLTYPE_CHAR  2
+#define DLTYPE_SHORT 3
+#define DLTYPE_INT   4
+#define DLTYPE_LONG  5
+#if HAVE_LONG_LONG
+#define DLTYPE_LONG_LONG 6
+#endif
+#define DLTYPE_FLOAT 7
+#define DLTYPE_DOUBLE 8
+#define MAX_DLTYPE 9
+
+#if SIZEOF_VOIDP == SIZEOF_LONG
+# define PTR2NUM(x)   (ULONG2NUM((unsigned long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#else
+/* # error --->> Ruby/DL2 requires sizeof(void*) == sizeof(long) to be compiled. <<--- */
+# define PTR2NUM(x)   (ULL2NUM((unsigned long long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#endif
+
+#define BOOL2INT(x)  ((x == Qtrue)?1:0)
+#define INT2BOOL(x)  (x?Qtrue:Qfalse)
+
+typedef void (*freefunc_t)(void*);
+
+struct dl_handle {
+    void *ptr;
+    int  open;
+    int  enable_close;
+};
+
+
+struct cfunc_data {
+    void *ptr;
+    char *name;
+    int  type;
+    ID   calltype;
+};
+extern ID rbdl_id_cdecl;
+extern ID rbdl_id_stdcall;
+#define CFUNC_CDECL   (rbdl_id_cdecl)
+#define CFUNC_STDCALL (rbdl_id_stdcall)
+
+struct ptr_data {
+    void *ptr;
+    long size;
+    freefunc_t free;
+};
+
+#define RDL_HANDLE(obj) ((struct dl_handle *)(DATA_PTR(obj)))
+#define RCFUNC_DATA(obj) ((struct cfunc_data *)(DATA_PTR(obj)))
+#define RPTR_DATA(obj) ((struct ptr_data *)(DATA_PTR(obj)))
+
+VALUE rb_dlcfunc_new(void (*func)(), int dltype, const char * name, ID calltype);
+VALUE rb_dlptr_new(void *ptr, long size, freefunc_t func);
+VALUE rb_dlptr_new2(VALUE klass, void *ptr, long size, freefunc_t func);
+VALUE rb_dlptr_malloc(long size, freefunc_t func);
+
+#endif
index 3b8543d..d91e55b 100644 (file)
@@ -158,7 +158,7 @@ fake.rb:    Makefile
                if RUBY_PLATFORM =~ /mswin|bccwin|mingw/; \
                  class File; \
                    remove_const :ALT_SEPARATOR; \
-                   ALT_SEPARATOR = "\\"; \
+                   ALT_SEPARATOR = "\\\\"; \
                  end; \
                end; \
                ' > $@
index 5cedf98..73a50ce 100644 (file)
@@ -123,7 +123,7 @@ COMPILE_PRELUDE = $(MINIRUBY) -I$(srcdir) -rrbconfig $(srcdir)/tool/compile_prel
 
 VCS           = svn
 
-all: encs exts
+all: exts
 exts: $(MKFILES) incs $(PREP) $(RBCONFIG) $(LIBRUBY)
        @$(MINIRUBY) $(srcdir)/ext/extmk.rb --make="$(MAKE)" $(EXTMK_ARGS)
 prog: $(PROGRAM) $(WPROGRAM)
diff --git a/lib/ruby-1.9.1-rc1/config.sh b/lib/ruby-1.9.1-rc1/config.sh
new file mode 100755 (executable)
index 0000000..6b256ca
--- /dev/null
@@ -0,0 +1,29 @@
+#!/bin/sh
+TOP=${HOME}/android
+PRODUCT=dream
+HOST=linux-x86
+GCCHOST=i686-linux
+ARCH=arch-arm
+GCCARCH=arm-eabi
+GCCVER=4.2.1
+RUBYARCH=arm-android-linux
+TOOLCHAIN_PATH=${TOP}/prebuilt/${HOST}/toolchain/${GCCARCH}-${GCCVER}
+TOOLCHAIN_PREFIX=${TOOLCHAIN_PATH}/bin/${GCCARCH}-
+LPATH=${TOP}/out/target/product/${PRODUCT}/obj/lib
+
+export CC=${TOOLCHAIN_PREFIX}gcc
+export LD=${TOOLCHAIN_PREFIX}ld
+export AR=${TOOLCHAIN_PREFIX}ar
+export RANLIB=${TOOLCHAIN_PREFIX}ranlib
+export CPPFLAGS="-nostdinc -I${TOP}/external/zlib -I${TOP}/external/openssl/include -I${TOP}/bionic/libc/include -I${TOP}/bionic/libc/${ARCH}/include -I${TOP}/bionic/libc/kernel/common -I${TOP}/bionic/libc/kernel/${ARCH} -I${TOP}/bionic/libc/kernel/common/linux -I${TOP}/bionic/libm/include -I${TOOLCHAIN_PATH}/lib/gcc/${GCCARCH}/${GCCVER}/include -Dptrdiff_t=__ptrdiff_t -include stdio.h -include unistd.h -include fcntl.h -include sys/mman.h -DHAVE_GETCWD"
+export LIBS="-nostdlib -L${LPATH} ${LPATH}/crtbegin_dynamic.o -lstdc++ -lc -lm -ldl ${LPATH}/crtend_android.o -Wl,-dynamic-linker,/system/bin/linker,-rpath,/system/lib"
+
+export ac_cv_func_getpgrp_void=yes
+export ac_cv_func_setpgrp_void=yes
+export ac_cv_prog_cc_g=no
+export ac_cv_prog_cxx_g=no
+export ac_cv_func_vsnprintf=yes
+export ac_cv_func_isinf=yes
+export ac_cv_header_langinfo_h=no
+
+./configure --build=${RUBYARCH} --target=${RUBYARCH} --host=${GCCHOST} --with-static-linked-ext --enable-wide-getaddrinfo
index 4dbddad..d648536 100755 (executable)
@@ -21264,7 +21264,10 @@ linux* | gnu* | k*bsd*-gnu | bsdi*)
     if test "$rb_cv_binary_elf" = no; then
        with_dln_a_out=yes
     else
-       LDFLAGS="$LDFLAGS -rdynamic"
+       case "$target_vendor" in
+       android) ;;
+       *) LDFLAGS="$LDFLAGS -rdynamic" ;;
+       esac
     fi;;
 esac
 LIBEXT=a
index b0f29b9..1857939 100644 (file)
@@ -1,4 +1,4 @@
-#option nodynamic
+option nodynamic
 
 #Win32API
 #bigdecimal
@@ -22,7 +22,7 @@
 #readline
 #ripper
 #sdbm
-#socket
+socket
 #stringio
 #strscan
 #syck
diff --git a/lib/ruby-1.9.1-rc1/ext/dl/callback-0.c b/lib/ruby-1.9.1-rc1/ext/dl/callback-0.c
new file mode 100644 (file)
index 0000000..2d0120f
--- /dev/null
@@ -0,0 +1,3922 @@
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID   rb_dl_cb_call;
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_0_cdecl)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 0);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_1_cdecl)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 20);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_2_cdecl)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 40);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_3_cdecl)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 60);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_4_cdecl)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 80);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 1);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 21);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 41);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 61);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 81);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 2);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 22);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 42);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 62);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 82);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 3);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 23);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 43);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 63);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 83);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 4);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 24);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 44);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 64);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 84);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 5);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 25);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 45);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 65);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 85);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 6);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 26);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 46);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 66);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 86);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 7);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 27);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 47);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 67);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 87);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 8);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 28);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 48);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 68);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 88);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 9);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 29);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 49);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 69);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 89);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 10);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 30);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 50);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 70);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 90);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+    VALUE ret, cb, args[11];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 11);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+    VALUE ret, cb, args[11];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 31);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+    VALUE ret, cb, args[11];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 51);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+    VALUE ret, cb, args[11];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 71);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+    VALUE ret, cb, args[11];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 91);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+    VALUE ret, cb, args[12];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 12);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+    VALUE ret, cb, args[12];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 32);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+    VALUE ret, cb, args[12];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 52);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+    VALUE ret, cb, args[12];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 72);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+    VALUE ret, cb, args[12];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 92);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+    VALUE ret, cb, args[13];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 13);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+    VALUE ret, cb, args[13];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 33);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+    VALUE ret, cb, args[13];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 53);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+    VALUE ret, cb, args[13];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 73);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+    VALUE ret, cb, args[13];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 93);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+    VALUE ret, cb, args[14];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 14);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+    VALUE ret, cb, args[14];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 34);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+    VALUE ret, cb, args[14];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 54);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+    VALUE ret, cb, args[14];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 74);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+    VALUE ret, cb, args[14];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 94);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+    VALUE ret, cb, args[15];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 15);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+    VALUE ret, cb, args[15];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 35);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+    VALUE ret, cb, args[15];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 55);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+    VALUE ret, cb, args[15];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 75);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+    VALUE ret, cb, args[15];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 95);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+    VALUE ret, cb, args[16];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 16);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+    VALUE ret, cb, args[16];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 36);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+    VALUE ret, cb, args[16];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 56);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+    VALUE ret, cb, args[16];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 76);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+    VALUE ret, cb, args[16];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 96);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+    VALUE ret, cb, args[17];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 17);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+    VALUE ret, cb, args[17];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 37);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+    VALUE ret, cb, args[17];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 57);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+    VALUE ret, cb, args[17];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 77);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+    VALUE ret, cb, args[17];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 97);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+    VALUE ret, cb, args[18];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 18);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+    VALUE ret, cb, args[18];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 38);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+    VALUE ret, cb, args[18];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 58);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+    VALUE ret, cb, args[18];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 78);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+    VALUE ret, cb, args[18];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 98);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+    VALUE ret, cb, args[19];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    args[18] = LONG2NUM(stack18);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 19);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+    VALUE ret, cb, args[19];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    args[18] = LONG2NUM(stack18);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 39);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+    VALUE ret, cb, args[19];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    args[18] = LONG2NUM(stack18);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 59);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+    VALUE ret, cb, args[19];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    args[18] = LONG2NUM(stack18);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 79);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+    return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+    VALUE ret, cb, args[19];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    args[10] = LONG2NUM(stack10);
+    args[11] = LONG2NUM(stack11);
+    args[12] = LONG2NUM(stack12);
+    args[13] = LONG2NUM(stack13);
+    args[14] = LONG2NUM(stack14);
+    args[15] = LONG2NUM(stack15);
+    args[16] = LONG2NUM(stack16);
+    args[17] = LONG2NUM(stack17);
+    args[18] = LONG2NUM(stack18);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 99);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_0_stdcall)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 0);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_1_stdcall)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 20);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_2_stdcall)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 40);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_3_stdcall)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 60);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_4_stdcall)()
+{
+    VALUE ret, cb;
+
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 80);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 1);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 21);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 41);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 61);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+    VALUE ret, cb, args[1];
+    args[0] = LONG2NUM(stack0);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 81);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 2);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 22);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 42);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 62);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+    VALUE ret, cb, args[2];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 82);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 3);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 23);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 43);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 63);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+    VALUE ret, cb, args[3];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 83);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 4);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 24);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 44);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 64);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+    VALUE ret, cb, args[4];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 84);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 5);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 25);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 45);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 65);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+    VALUE ret, cb, args[5];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 85);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 6);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 26);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 46);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 66);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+    VALUE ret, cb, args[6];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 86);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 7);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 27);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 47);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 67);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+    VALUE ret, cb, args[7];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 87);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 8);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 28);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 48);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 68);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+    VALUE ret, cb, args[8];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 88);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 9);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 29);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 49);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 69);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+    VALUE ret, cb, args[9];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 89);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 10);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 30);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);
+    args[9] = LONG2NUM(stack9);
+    cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 50);
+    ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+    return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+    VALUE ret, cb, args[10];
+    args[0] = LONG2NUM(stack0);
+    args[1] = LONG2NUM(stack1);
+    args[2] = LONG2NUM(stack2);
+    args[3] = LONG2NUM(stack3);
+    args[4] = LONG2NUM(stack4);
+    args[5] = LONG2NUM(stack5);
+    args[6] = LONG2NUM(stack6);
+    args[7] = LONG2NUM(stack7);
+    args[8] = LONG2NUM(stack8);