Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ext.ffi;
  
  import org.jruby.Ruby;
  
  public final class MemoryUtil {
     private MemoryUtil() {}
 
     public static final IRubyObject getArrayOfSigned8(Ruby runtimeMemoryIO iolong offsetint count) {
 
         byte[] array = new byte[count];
         io.get(offsetarray, 0, array.length);
         
         RubyArray arr = RubyArray.newArray(runtimearray.length);
         for (int i = 0; i < array.length; ++i) {
             arr.add(Util.newSigned8(runtimearray[i]));
         }
 
         return arr;
     }
 
     public static final void putArrayOfSigned8(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
 
         byte[] array = new byte[ary.size()];
         for (int i = 0; i < array.length; ++i) {
             array[i] = Util.int8Value(ary.entry(i));
         }
 
         io.put(offsetarray, 0, array.length);
     }
 
     public static final IRubyObject getArrayOfUnsigned8(Ruby runtimeMemoryIO iolong offsetint count) {
 
         byte[] array = new byte[count];
         io.get(offsetarray, 0, array.length);
 
         RubyArray arr = RubyArray.newArray(runtimearray.length);
         for (int i = 0; i < array.length; ++i) {
             arr.add(Util.newUnsigned8(runtimearray[i]));
         }
 
         return arr;
     }
 
     public static final void putArrayOfUnsigned8(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
 
         byte[] array = new byte[ary.size()];
         for (int i = 0; i < array.length; ++i) {
             array[i] = (byte) Util.uint8Value(ary.entry(i));
         }
 
         io.put(offsetarray, 0, array.length);
     }
 
     public static final IRubyObject getArrayOfSigned16(Ruby runtimeMemoryIO iolong offsetint count) {
 
         short[] array = new short[count];
         io.get(offsetarray, 0, array.length);
 
         RubyArray arr = RubyArray.newArray(runtimearray.length);
         for (int i = 0; i < array.length; ++i) {
             arr.add(Util.newSigned16(runtimearray[i]));
         }
 
         return arr;
     }
     
     public static final void putArrayOfSigned16(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
 
         short[] array = new short[ary.size()];
         for (int i = 0; i < array.length; ++i) {
             array[i] = Util.int16Value(ary.entry(i));
         }
 
         io.put(offsetarray, 0, array.length);
     }
 
     public static final IRubyObject getArrayOfUnsigned16(Ruby runtimeMemoryIO iolong offsetint count) {
 
         short[] array = new short[count];
         io.get(offsetarray, 0, array.length);
 
         RubyArray arr = RubyArray.newArray(runtimearray.length);
         for (int i = 0; i < array.length; ++i) {
             arr.add(Util.newUnsigned16(runtimearray[i]));
         }
 
         return arr;
     }
 
     public static final void putArrayOfUnsigned16(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
 
         short[] array = new short[ary.size()];
         for (int i = 0; i < array.length; ++i) {
             array[i] = (short) Util.uint16Value(ary.entry(i));
         }
        io.put(offsetarray, 0, array.length);
    }
    public static final IRubyObject getArrayOfSigned32(Ruby runtimeMemoryIO iolong offsetint count) {
        int[] array = new int[count];
        io.get(offsetarray, 0, array.length);
        RubyArray arr = RubyArray.newArray(runtimearray.length);
        for (int i = 0; i < array.length; ++i) {
            arr.add(Util.newSigned32(runtimearray[i]));
        }
        return arr;
    }
    public static final void putArrayOfSigned32(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
        int[] array = new int[ary.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = Util.int32Value(ary.entry(i));
        }
        io.put(offsetarray, 0, array.length);
    }
    
    public static final IRubyObject getArrayOfUnsigned32(Ruby runtimeMemoryIO iolong offsetint count) {
        int[] array = new int[count];
        io.get(offsetarray, 0, array.length);
        RubyArray arr = RubyArray.newArray(runtimearray.length);
        for (int i = 0; i < array.length; ++i) {
            arr.add(Util.newUnsigned32(runtimearray[i]));
        }
        return arr;
    }
    public static final void putArrayOfUnsigned32(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
        int[] array = new int[ary.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = (int) Util.uint32Value(ary.entry(i));
        }
        io.put(offsetarray, 0, array.length);
    }
    public static final IRubyObject getArrayOfSigned64(Ruby runtimeMemoryIO iolong offsetint count) {
        long[] array = new long[count];
        io.get(offsetarray, 0, array.length);
        RubyArray arr = RubyArray.newArray(runtimearray.length);
        for (int i = 0; i < array.length; ++i) {
            arr.add(Util.newSigned64(runtimearray[i]));
        }
        return arr;
    }
    public static final void putArrayOfSigned64(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
        long[] array = new long[ary.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = Util.int64Value(ary.entry(i));
        }
        io.put(offsetarray, 0, array.length);
    }
    public static final IRubyObject getArrayOfUnsigned64(Ruby runtimeMemoryIO iolong offsetint count) {
        long[] array = new long[count];
        io.get(offsetarray, 0, array.length);
        RubyArray arr = RubyArray.newArray(runtimearray.length);
        for (int i = 0; i < array.length; ++i) {
            arr.add(Util.newUnsigned64(runtimearray[i]));
        }
        return arr;
    }
    public static final void putArrayOfUnsigned64(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
        long[] array = new long[ary.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = Util.uint64Value(ary.entry(i));
        }
        io.put(offsetarray, 0, array.length);
    }
    public static final IRubyObject getArrayOfFloat32(Ruby runtimeMemoryIO iolong offsetint count) {
        float[] array = new float[count];
        io.get(offsetarray, 0, array.length);
        RubyArray arr = RubyArray.newArray(runtimearray.length);
        for (int i = 0; i < array.length; ++i) {
            arr.add(RubyFloat.newFloat(runtimearray[i]));
        }
        return arr;
    }
    public static final void putArrayOfFloat32(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
        float[] array = new float[ary.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = Util.floatValue(ary.entry(i));
        }
        io.put(offsetarray, 0, array.length);
    }
    public static final IRubyObject getArrayOfFloat64(Ruby runtimeMemoryIO iolong offsetint count) {
        double[] array = new double[count];
        io.get(offsetarray, 0, array.length);
        RubyArray arr = RubyArray.newArray(runtimearray.length);
        for (int i = 0; i < array.length; ++i) {
            arr.add(RubyFloat.newFloat(runtimearray[i]));
        }
        return arr;
    }
    public static final void putArrayOfFloat64(Ruby runtimeMemoryIO iolong offsetRubyArray ary) {
        double[] array = new double[ary.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = Util.doubleValue(ary.entry(i));
        }
        io.put(offsetarray, 0, array.length);
    }

    
Creates a ruby string from a byte array and sets the taint flag on it

Parameters:
runtime The ruby runtime
bytes The array to make into a ruby string.
Returns:
A ruby string.
    public static final RubyString newTaintedString(Ruby runtimebyte[] bytes) {
        RubyString s = RubyString.newStringNoCopy(runtimebytes);
        s.setTaint(true);
        return s;
    }

    
Reads a byte (binary) string from a memory object.

Parameters:
runtime The ruby runtime
io The memory object to read the string from
offset The offset within the memory object to start reading
length The number of bytes to read
Returns:
A ruby string
    public static final RubyString getTaintedByteString(Ruby runtimeMemoryIO iolong offsetint length) {
        byte[] bytes = new byte[length];
        io.get(offsetbytes, 0, bytes.length);
        return newTaintedString(runtimebytes);
    }

    
Gets a NUL terminated string from a memory object

Parameters:
runtime The ruby runtime
io The memory object to read the string from
offset The offset within the memory object to start reading
Returns:
A ruby string
    public static final IRubyObject getTaintedString(Ruby runtimeMemoryIO iolong offset) {
        return newTaintedString(runtimeio.getZeroTerminatedByteArray(offset));
    }

    
Reads a NUL terminated string from a memory object

Parameters:
runtime The ruby runtime
io The memory object to read the string from
offset The offset within the memory object to start reading
maxlen The maximum number of bytes to read
Returns:
A ruby string
    public static final IRubyObject getTaintedString(Ruby runtimeMemoryIO iolong offsetint length) {
        return newTaintedString(runtimeio.getZeroTerminatedByteArray(offsetlength));
    }
New to GrepCode? Check out our FAQ X