Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ext.ffi.jffi;
  
  import org.jruby.*;
 
 
 public final class JITRuntime {
     private JITRuntime() {}
     
     public static RuntimeException newArityError(ThreadContext contextint gotint expected) {
         return context.runtime.newArgumentError(gotexpected);
     }
     
     public static long other2long(IRubyObject parameter) {
         return RubyNumeric.num2long(parameter);
     }
     
     public static int s8Value32(IRubyObject parameter) {
         return (byte) (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter));
     }
 
     public static long s8Value64(IRubyObject parameter) {
         return (byte) (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter));
     }
 
     public static int u8Value32(IRubyObject parameter) {
         return (int) ((parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter)) & 0xffL);
     }
 
     public static long u8Value64(IRubyObject parameter) {
         return (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter)) & 0xffL;
     }
 
     public static int s16Value32(IRubyObject parameter) {
         return (short) (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter));
     }
 
     public static long s16Value64(IRubyObject parameter) {
         return (short) (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter));
     }
 
     public static int u16Value32(IRubyObject parameter) {
         return (int) (((parameter instanceof RubyFixnum)
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter))  & 0xffffL);
     }
 
     public static long u16Value64(IRubyObject parameter) {
         return ((parameter instanceof RubyFixnum)
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter)) & 0xffffL;
     }
 
     public static int s32Value32(IRubyObject parameter) {
         return (int) (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter));
     }
 
     public static long s32Value64(IRubyObject parameter) {
         return (int) (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter));
     }
 
     public static int u32Value32(IRubyObject parameter) {
         return (int) ((parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter)) & 0xffffffffL);
     }
 
     public static long u32Value64(IRubyObject parameter) {
         return (parameter instanceof RubyFixnum
                 ? ((RubyFixnumparameter).getLongValue()
                 : other2long(parameter)) & 0xffffffffL;
     }
 
     public static long s64Value64(IRubyObject parameter) {
        return parameter instanceof RubyFixnum
                ? ((RubyFixnumparameter).getLongValue()
                : other2long(parameter);
    }
    public static long other2u64(IRubyObject parameter) {
        if (parameter instanceof RubyBignum) {
            return ((RubyBignumparameter).getValue().longValue();
        } else {
            return other2long(parameter);
        }
    }
    public static long u64Value64(IRubyObject parameter) {
        return parameter instanceof RubyFixnum
                ? ((RubyFixnumparameter).getLongValue()
                : other2u64(parameter);
    }
    public static int f32Value32(IRubyObject parameter) {
        if (parameter instanceof RubyFloat) {
            return Float.floatToRawIntBits((float) ((RubyFloatparameter).getDoubleValue());
        } else {
            return (intother2long(parameter);
        }
    }
    public static long f32Value64(IRubyObject parameter) {
        if (parameter instanceof RubyFloat) {
            return Float.floatToRawIntBits((float) ((RubyFloatparameter).getDoubleValue());
        } else {
            return other2long(parameter);
        }
    }
    
    public static long f64Value64(IRubyObject parameter) {
        if (parameter instanceof RubyFloat) {
            return Double.doubleToRawLongBits(((RubyFloatparameter).getDoubleValue());
        
        } else {
            return other2long(parameter);
        }
    }
    public static int boolValue32(IRubyObject parameter) {
        return boolValue(parameter) ? 1 : 0;
    }
    public static long boolValue64(IRubyObject parameter) {
        return boolValue(parameter) ? 1L : 0L;
    }
    private static boolean other2bool(IRubyObject parameter) {
        if (parameter instanceof RubyNumeric) {
            return ((RubyNumericparameter).getLongValue() != 0;
        }
        
        throw parameter.getRuntime().newTypeError("cannot convert " 
                + parameter.getMetaClass().getRealClass() + " to bool");
    }
    public static boolean boolValue(IRubyObject parameter) {
        if (parameter instanceof RubyBoolean) {
            return parameter.isTrue();
        }
        
        return other2bool(parameter);
    }
    
    public static IRubyObject other2ptr(ThreadContext contextIRubyObject parameter) {
        if (parameter instanceof Struct) {
            return ((Structparameter).getMemory();
        
        } else if (parameter instanceof RubyString || parameter instanceof Buffer || parameter.isNil()) {
            // Cannot be converted to a Pointer instance, let the asm code check it
            return parameter;
        }
        
        return convert2ptr(contextparameter);
    }
    
    public static IRubyObject convert2ptr(ThreadContext contextIRubyObject parameter) {
        final int MAXRECURSE = 4;
        IRubyObject ptr = parameter;
        for (int i = 0; i < MAXRECURSE && !(ptr instanceof AbstractMemory) && ptr.respondsTo("to_ptr"); i++) {
            ptr = ptr.callMethod(context"to_ptr");
        }
        return ptr;
    }
    
    public static IRubyObject newSigned8(ThreadContext contextint value) {
        return RubyFixnum.newFixnum(context.runtime, (bytevalue);
    }
    public static IRubyObject newSigned8(Ruby runtimeint value) {
        return RubyFixnum.newFixnum(runtime, (bytevalue);
    }
    public static IRubyObject newSigned8(ThreadContext contextlong value) {
        return RubyFixnum.newFixnum(context.runtime, (bytevalue);
    }
    public static IRubyObject newSigned8(Ruby runtimelong value) {
        return RubyFixnum.newFixnum(runtime, (bytevalue);
    }
    public static IRubyObject newUnsigned8(ThreadContext contextint value) {
        int n = (bytevalue// sign-extend the low 8 bits to 32
        return RubyFixnum.newFixnum(context.runtimen < 0 ? ((n & 0x7F) + 0x80) : n);
    }
    public static IRubyObject newUnsigned8(Ruby runtimeint value) {
        int n = (bytevalue// sign-extend the low 8 bits to 32
        return RubyFixnum.newFixnum(runtimen < 0 ? ((n & 0x7F) + 0x80) : n);
    }
    public static IRubyObject newUnsigned8(ThreadContext contextlong value) {
        int n = (bytevalue// sign-extend the low 8 bits to 32
        return RubyFixnum.newFixnum(context.runtimen < 0 ? ((n & 0x7F) + 0x80) : n);
    }
    public static IRubyObject newUnsigned8(Ruby runtimelong value) {
        int n = (bytevalue// sign-extend the low 8 bits to 32
        return RubyFixnum.newFixnum(runtimen < 0 ? ((n & 0x7F) + 0x80) : n);
    }
    public static IRubyObject newSigned16(ThreadContext contextint value) {
        return RubyFixnum.newFixnum(context.runtime, (shortvalue);
    }
    public static IRubyObject newSigned16(Ruby runtimeint value) {
        return RubyFixnum.newFixnum(runtime, (shortvalue);
    }
    public static IRubyObject newSigned16(ThreadContext contextlong value) {
        return RubyFixnum.newFixnum(context.runtime, (shortvalue);
    }
    public static IRubyObject newSigned16(Ruby runtimelong value) {
        return RubyFixnum.newFixnum(runtime, (shortvalue);
    }
    public static IRubyObject newUnsigned16(ThreadContext contextint value) {
        int n = (shortvalue// sign-extend the low 16 bits to 32
        return RubyFixnum.newFixnum(context.runtimen < 0 ? ((n & 0x7FFF) + 0x8000) : n);
    }
    public static IRubyObject newUnsigned16(Ruby runtimeint value) {
        int n = (shortvalue// sign-extend the low 16 bits to 32
        return RubyFixnum.newFixnum(runtimen < 0 ? ((n & 0x7FFF) + 0x8000) : n);
    }
    public static IRubyObject newUnsigned16(ThreadContext contextlong value) {
        int n = (shortvalue// sign-extend the low 16 bits to 32
        return RubyFixnum.newFixnum(context.runtimen < 0 ? ((n & 0x7FFF) + 0x8000) : n);
    }
    public static IRubyObject newUnsigned16(Ruby runtimelong value) {
        int n = (shortvalue// sign-extend the low 16 bits to 32
        return RubyFixnum.newFixnum(runtimen < 0 ? ((n & 0x7FFF) + 0x8000) : n);
    }
    public static IRubyObject newSigned32(ThreadContext contextint value) {
        return RubyFixnum.newFixnum(context.runtimevalue);
    }
    public static IRubyObject newSigned32(Ruby runtimeint value) {
        return RubyFixnum.newFixnum(runtimevalue);
    }
    public static IRubyObject newSigned32(ThreadContext contextlong value) {
        return RubyFixnum.newFixnum(context.runtime, (intvalue);
    }
    public static IRubyObject newSigned32(Ruby runtimelong value) {
        return RubyFixnum.newFixnum(runtime, (intvalue);
    }
    public static IRubyObject newUnsigned32(ThreadContext contextint value) {
        long n = value;
        return RubyFixnum.newFixnum(context.runtimen < 0 ? ((n & 0x7FFFFFFFL) + 0x80000000L) : n);
    }
    public static IRubyObject newUnsigned32(Ruby runtimeint value) {
        long n = value;
        return RubyFixnum.newFixnum(runtimen < 0 ? ((n & 0x7FFFFFFFL) + 0x80000000L) : n);
    }
    public static IRubyObject newUnsigned32(ThreadContext contextlong value) {
        long n = (intvalue// only keep the low 32 bits
        return RubyFixnum.newFixnum(context.runtimen < 0 ? ((n & 0x7FFFFFFFL) + 0x80000000L) : n);
    }
    public static IRubyObject newUnsigned32(Ruby runtimelong value) {
        long n = (intvalue// only keep the low 32 bits
        return RubyFixnum.newFixnum(runtimen < 0 ? ((n & 0x7FFFFFFFL) + 0x80000000L) : n);
    }
    public static IRubyObject newSigned64(ThreadContext contextlong value) {
        return RubyFixnum.newFixnum(context.runtimevalue);
    }
    public static IRubyObject newSigned64(Ruby runtimelong value) {
        return RubyFixnum.newFixnum(runtimevalue);
    }
    private static final BigInteger UINT64_BASE = BigInteger.valueOf(.).add(.);
    public static IRubyObject newUnsigned64(ThreadContext contextlong value) {
        return value < 0
                ? RubyBignum.newBignum(context.runtime, BigInteger.valueOf(value & 0x7fffffffffffffffL).add())
                : RubyFixnum.newFixnum(context.runtimevalue);
    }
    public static IRubyObject newUnsigned64(Ruby runtimelong value) {
        return value < 0
                ? RubyBignum.newBignum(runtime, BigInteger.valueOf(value & 0x7fffffffffffffffL).add())
                : RubyFixnum.newFixnum(runtimevalue);
    }
    public static IRubyObject newNil(ThreadContext contextint ignored) {
        return context.nil;
    }
    public static IRubyObject newNil(Ruby runtimeint ignored) {
        return runtime.getNil();
    }
    
    public static IRubyObject newNil(ThreadContext contextlong ignored) {
        return context.nil;
    }
    public static IRubyObject newNil(Ruby runtimelong ignored) {
        return runtime.getNil();
    }
    
    public static IRubyObject newPointer32(ThreadContext contextint address) {
        Ruby runtime = context.runtime;
        return new Pointer(runtime
                NativeMemoryIO.wrap(runtime, ((longaddress) & 0xffffffffL));
    }
    public static IRubyObject newPointer32(Ruby runtimeint address) {
        return new Pointer(runtime,
                NativeMemoryIO.wrap(runtime, ((longaddress) & 0xffffffffL));
    }
    
    public static IRubyObject newPointer32(ThreadContext contextlong address) {
        Ruby runtime = context.runtime;
        return new Pointer(runtime
                NativeMemoryIO.wrap(runtimeaddress & 0xffffffffL));
    }
    public static IRubyObject newPointer32(Ruby runtimelong address) {
        return new Pointer(runtime,
                NativeMemoryIO.wrap(runtimeaddress & 0xffffffffL));
    }
    
    public static IRubyObject newPointer64(ThreadContext contextlong address) {
        Ruby runtime = context.runtime;
        return new Pointer(runtime, NativeMemoryIO.wrap(runtimeaddress));
    }
    public static IRubyObject newPointer64(Ruby runtimelong address) {
        return new Pointer(runtime, NativeMemoryIO.wrap(runtimeaddress));
    }
    
    public static IRubyObject newString(ThreadContext contextint address) {
        return FFIUtil.getString(context.runtimeaddress);
    }
    public static IRubyObject newString(Ruby runtimeint address) {
        return FFIUtil.getString(runtimeaddress);
    }
    
    public static IRubyObject newString(ThreadContext contextlong address) {
        return FFIUtil.getString(context.runtimeaddress);
    }
    public static IRubyObject newString(Ruby runtimelong address) {
        return FFIUtil.getString(runtimeaddress);
    }
    
    public static IRubyObject newBoolean(ThreadContext contextint value) {
        return context.runtime.newBoolean((value & 0x1) != 0);
    }
    public static IRubyObject newBoolean(Ruby runtimeint value) {
        return runtime.newBoolean((value & 0x1) != 0);
    }
    
    public static IRubyObject newBoolean(ThreadContext contextlong value) {
        return context.runtime.newBoolean((value & 0x1L) != 0);
    }
    public static IRubyObject newBoolean(Ruby runtimelong value) {
        return runtime.newBoolean((value & 0x1L) != 0);
    }
    
    public static IRubyObject newFloat32(ThreadContext contextint value) {
        return RubyFloat.newFloat(context.runtime, Float.intBitsToFloat(value));
    }
    public static IRubyObject newFloat32(Ruby runtimeint value) {
        return RubyFloat.newFloat(runtime, Float.intBitsToFloat(value));
    }
    
    public static IRubyObject newFloat32(ThreadContext contextlong value) {
        return RubyFloat.newFloat(context.runtime, Float.intBitsToFloat((intvalue));
    }
    public static IRubyObject newFloat32(Ruby runtimelong value) {
        return RubyFloat.newFloat(runtime, Float.intBitsToFloat((intvalue));
    }
    
    public static IRubyObject newFloat64(ThreadContext contextlong value) {
        return RubyFloat.newFloat(context.runtime, Double.longBitsToDouble(value));
    }
    public static IRubyObject newFloat64(Ruby runtimelong value) {
        return RubyFloat.newFloat(runtime, Double.longBitsToDouble(value));
    }
    private static final PointerParameterStrategy DIRECT_MEMORY_OBJECT = new MemoryObjectParameterStrategy(true);
    private static final PointerParameterStrategy HEAP_MEMORY_OBJECT = new MemoryObjectParameterStrategy(false);
    private static final PointerParameterStrategy DIRECT_MEMORY_IO = new MemoryIOParameterStrategy(true);
    private static final PointerParameterStrategy HEAP_MEMORY_IO = new MemoryIOParameterStrategy(false);
    private static final PointerParameterStrategy HEAP_STRING_POINTER_STRATEGY = new StringParameterStrategy(falsefalse);
    private static final PointerParameterStrategy TRANSIENT_STRING_PARAMETER_STRATEGY = new StringParameterStrategy(falsetrue);
    private static final PointerParameterStrategy DIRECT_STRING_PARAMETER_STRATEGY = new StringParameterStrategy(truetrue);
        if (parameter instanceof MemoryObject) {
            return ((MemoryObjectparameter).getMemoryIO().isDirect() ?  : ;
        } else if (parameter instanceof RubyNil) {
            return ;
        } else if (parameter instanceof RubyString) {
            return ;
        }
        
        return null;
    }
    public static MemoryIO lookupPointerMemoryIO(IRubyObject parameter) {
        if (parameter instanceof MemoryObject) {
            return ((MemoryObjectparameter).getMemoryIO();
        } else if (parameter instanceof RubyNil) {
            return ..;
        } else if (parameter instanceof RubyString) {
            return StringParameterStrategy.getMemoryIO((RubyStringparameterfalsefalse);
        }
        return null;
    }
    public static MemoryIO getPointerMemoryIO(IRubyObject parameter) {
        MemoryIO memory = lookupPointerMemoryIO(parameter);
        if (memory != null) {
            return memory;
        } else {
            return convertToPointerMemoryIO(parameter);
        }
    }
    private static MemoryIO convertToPointerMemoryIO(IRubyObject parameter) {
        IRubyObject obj = parameter;
        ThreadContext context = parameter.getRuntime().getCurrentContext();
        for (int depth = 0; depth < 4; depth++) {
            if (obj.respondsTo("to_ptr")) {
                obj = obj.callMethod(context"to_ptr");
                MemoryIO memory = lookupPointerMemoryIO(obj);
                if (memory != null) {
                    return memory;
                }
            
            } else {
                throw parameter.getRuntime().newTypeError("cannot convert parameter to native pointer");
            }
        }
        throw parameter.getRuntime().newRuntimeError("to_ptr recursion limit reached for " + parameter.getMetaClass());
    }
    
    private static MemoryIO convertToStringMemoryIO(IRubyObject parameterThreadContext contextCachingCallSite callSite,
                                                    boolean isDirectboolean checkStringSafety) {
        DynamicMethod conversionMethod;
        if (parameter instanceof RubyString) {
            return StringParameterStrategy.getMemoryIO((RubyStringparameterisDirectcheckStringSafety);
        } else if (parameter instanceof RubyNil) {
            return ..;
        } else if (!(conversionMethod = callSite.retrieveCache(parameter.getMetaClass(), callSite.getMethodName()).).isUndefined()) {
            IRubyObject convertedParameter = conversionMethod.call(contextparameterparameter.getMetaClass(), callSite.getMethodName(), .);
            if (convertedParameter instanceof RubyString) {
                return StringParameterStrategy.getMemoryIO((RubyStringconvertedParameterisDirectcheckStringSafety);
            }
            // Fall through to the default conversion which will raise an error if the converted value is not of the correct type.
        }
        
        return StringParameterStrategy.getMemoryIO(parameter.convertToString(), isDirectcheckStringSafety);
    } 
    public static MemoryIO convertToStringMemoryIO(IRubyObject parameterThreadContext contextCachingCallSite callSite) {
        return convertToStringMemoryIO(parametercontextcallSitetruetrue); 
    }
    public static MemoryIO convertToTransientStringMemoryIO(IRubyObject parameterThreadContext contextCachingCallSite callSite) {
        return convertToStringMemoryIO(parametercontextcallSitefalsetrue);
    }
    public static PointerParameterStrategy getMemoryIOStrategy(MemoryIO memory) {
        return memory.isDirect() ?  : ;
    }
    public static PointerParameterStrategy pointerParameterStrategy(IRubyObject parameter) {
        PointerParameterStrategy strategy = lookupPointerParameterStrategy(parameter);
        if (strategy != null) {
            return strategy;
        
        } else if (parameter.respondsTo("to_ptr")) {
            IRubyObject ptr = parameter.callMethod(parameter.getRuntime().getCurrentContext(), "to_ptr");
            return new DelegatingPointerParameterStrategy(ptrpointerParameterStrategy(ptr));
        } else {
            throw parameter.getRuntime().newTypeError("cannot convert parameter to native pointer");
        }
    }
    public static PointerParameterStrategy stringParameterStrategy(IRubyObject parameter) {
        if (parameter instanceof RubyString) {
            return ;
        } else if (parameter.isNil()) {
            return ;
        } else {
            return stringParameterStrategy(parameter.convertToString());
        }
    }
        if (parameter instanceof RubyString) {
            return ;
        } else if (parameter.isNil()) {
            return ;
        } else {
            return transientStringParameterStrategy(parameter.convertToString());
        }
    }
    public static MemoryIO convertToPointerMemoryIO(ThreadContext contextIRubyObject parameterCachingCallSite callSite) {
        DynamicMethod method = getConversionMethod(parametercallSite);
        IRubyObject ptr = method.call(contextparameterparameter.getMetaClass(), callSite.getMethodName(), .);
        if (ptr instanceof AbstractMemory) {
            return ((AbstractMemoryptr).getMemoryIO();
        }
        throw parameter.getRuntime().newTypeError(parameter.getMetaClass() + "#" + callSite.getMethodName() 
                + " should return " + context.runtime.getFFI().);
    }
    public static DynamicMethod getConversionMethod(IRubyObject parameterCachingCallSite callSite) {
        DynamicMethod method = callSite.retrieveCache(parameter.getMetaClass(), callSite.getMethodName()).;
        if (method.isUndefined()) {
            throw parameter.getRuntime().newTypeError("cannot convert parameter of type " + parameter.getMetaClass()
                    + " to native pointer; does not respond to :" + callSite.getMethodName());
        }
        
        return method;
    }
    public static boolean isDirectPointer(IRubyObject parameter) {
        return parameter instanceof MemoryObject && ((MemoryObjectparameter).getMemoryIO().isDirect();
    }
    public static int pointerValue32(IRubyObject parameter) {
        return (int) ((MemoryObjectparameter).getMemoryIO().address();
    }
    public static long pointerValue64(IRubyObject parameter) {
        return ((MemoryObjectparameter).getMemoryIO().address();
    }
    public static boolean isTrue(boolean p1) {
        return p1;
    }
    public static boolean isTrue(boolean p1boolean p2) {
        return p1 & p2;
    }
    public static boolean isTrue(boolean p1boolean p2boolean p3) {
        return p1 & p2 & p3;
    }
    public static boolean isTrue(boolean p1boolean p2boolean p3boolean p4) {
        return p1 & p2 & p3 & p4;
    }
    public static boolean isTrue(boolean p1boolean p2boolean p3boolean p4boolean p5) {
        return p1 & p2 & p3 & p4 & p5;
    }
    public static boolean isTrue(boolean p1boolean p2boolean p3boolean p4boolean p5boolean p6) {
        return p1 & p2 & p3 & p4 & p5 & p5 & p6;
    }
New to GrepCode? Check out our FAQ X