Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.jruby.ext.ffi.jffi;
  
  import org.jruby.Ruby;
  import org.jruby.RubyHash;
 
 public class JFFIInvoker extends org.jruby.ext.ffi.AbstractInvoker {
     private final Function function;
     private final Type returnType;
     private final Type[] parameterTypes;
     private final CallingConvention convention;
     private final IRubyObject enums;
     
     public static RubyClass createInvokerClass(Ruby runtimeRubyModule module) {
         RubyClass result = module.defineClassUnder("Invoker",
                 module.getClass("AbstractInvoker"),
                 .);
         result.defineAnnotatedMethods(AbstractInvoker.class);
         result.defineAnnotatedMethods(JFFIInvoker.class);
         result.defineAnnotatedConstants(JFFIInvoker.class);
 
         return result;
     }
 
     JFFIInvoker(Ruby runtimelong addressType returnTypeType[] parameterTypesCallingConvention convention) {
         this(runtimeruntime.getModule("FFI").getClass("Invoker"),
                 new CodeMemoryIO(runtimeaddress),
                 returnTypeparameterTypesconventionnull);
     }
 
     JFFIInvoker(Ruby runtimeRubyClass klassMemoryIO fptr,
             Type returnTypeType[] parameterTypesCallingConvention conventionIRubyObject enums) {
         super(runtimeklassparameterTypes.lengthfptr);
 
         final com.kenai.jffi.Type jffiReturnType = FFIUtil.getFFIType(returnType);
         if (jffiReturnType == null) {
             throw runtime.newArgumentError("Invalid return type " + returnType);
         }
         
         com.kenai.jffi.Type[] jffiParamTypes = new com.kenai.jffi.Type[parameterTypes.length];
         for (int i = 0; i < jffiParamTypes.length; ++i) {
             if ((jffiParamTypes[i] = FFIUtil.getFFIType(parameterTypes[i])) == null) {
                 throw runtime.newArgumentError("Invalid parameter type " + parameterTypes[i]);
             }
         }
         
          = new Function(fptr.address(), jffiReturnTypejffiParamTypes);
         this. = (Type[]) parameterTypes.clone();
         this. = returnType;
         this. = convention;
         this. = enums;
         // Wire up Function#call(*args) to use the super-fast native invokers
     }
     
     @JRubyMethod(name = { "new" }, meta = true, required = 4)
     public static IRubyObject newInstance(ThreadContext contextIRubyObject recvIRubyObject[] args) {
 
         if (!(args[0] instanceof Pointer)) {
             throw context.runtime.newTypeError("Invalid function address "
                     + args[0].getMetaClass().getName() + " (expected FFI::Pointer)");
         }
         
         if (!(args[1] instanceof RubyArray)) {
             throw context.runtime.newTypeError("Invalid parameter array "
                     + args[1].getMetaClass().getName() + " (expected Array)");
         }
 
         if (!(args[2] instanceof Type)) {
             throw context.runtime.newTypeError("Invalid return type " + args[2]);
         }
         Pointer ptr = (Pointerargs[0];
         RubyArray paramTypes = (RubyArrayargs[1];
         Type returnType = (Typeargs[2];
 
         // Get the convention from the options hash
         String convention = "default";
         IRubyObject enums = null;
         if (args[3] instanceof RubyHash) {
             RubyHash options = (RubyHashargs[3];
             convention = options.fastARef(context.runtime.newSymbol("convention")).asJavaString();
             enums = options.fastARef(context.runtime.newSymbol("enums"));
             if (enums != null && !enums.isNil() && !(enums instanceof RubyHash)) {
                 throw context.runtime.newTypeError("wrong type for options[:enum] "
                         + enums.getMetaClass().getName() + " (expected Hash or Enums)");
 
             }
         } else {
            convention = args[3].asJavaString();
        }
        Type[] parameterTypes = new Type[paramTypes.size()];
        for (int i = 0; i < parameterTypes.length; ++i) {
            IRubyObject type = paramTypes.entry(i);
            if (!(type instanceof Type)) {
                throw context.runtime.newArgumentError("Invalid parameter type");
            }
            parameterTypes[i] = (TypeparamTypes.entry(i);
        }
        MemoryIO fptr = ptr.getMemoryIO();
        return new JFFIInvoker(context.runtime, (RubyClassrecvfptr,
                (TypereturnTypeparameterTypes
                "stdcall".equals(convention) ? . : .,
                enums);
    }
    @Override
    public DynamicMethod createDynamicMethod(RubyModule module) {
        return MethodFactory.createDynamicMethod(getRuntime(), module,
                    false);
    }
    
New to GrepCode? Check out our FAQ X