MemoryUtil.java

  1. package org.jruby.ext.ffi;

  3. import org.jruby.Ruby;
  4. import org.jruby.RubyArray;
  5. import org.jruby.RubyFloat;
  6. import org.jruby.RubyString;
  7. import org.jruby.runtime.builtin.IRubyObject;

  9. public final class MemoryUtil {
  10.     private MemoryUtil() {}

  12.     public static final IRubyObject getArrayOfSigned8(Ruby runtime, MemoryIO io, long offset, int count) {

  14.         byte[] array = new byte[count];
  15.         io.get(offset, array, 0, array.length);
  16.         
  17.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  18.         for (int i = 0; i < array.length; ++i) {
  19.             arr.add(Util.newSigned8(runtime, array[i]));
  20.         }

  22.         return arr;
  23.     }

  25.     public static final void putArrayOfSigned8(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  27.         byte[] array = new byte[ary.size()];
  28.         for (int i = 0; i < array.length; ++i) {
  29.             array[i] = Util.int8Value(ary.entry(i));
  30.         }

  32.         io.put(offset, array, 0, array.length);
  33.     }

  35.     public static final IRubyObject getArrayOfUnsigned8(Ruby runtime, MemoryIO io, long offset, int count) {

  37.         byte[] array = new byte[count];
  38.         io.get(offset, array, 0, array.length);

  40.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  41.         for (int i = 0; i < array.length; ++i) {
  42.             arr.add(Util.newUnsigned8(runtime, array[i]));
  43.         }

  45.         return arr;
  46.     }

  48.     public static final void putArrayOfUnsigned8(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  50.         byte[] array = new byte[ary.size()];
  51.         for (int i = 0; i < array.length; ++i) {
  52.             array[i] = (byte) Util.uint8Value(ary.entry(i));
  53.         }

  55.         io.put(offset, array, 0, array.length);
  56.     }

  58.     public static final IRubyObject getArrayOfSigned16(Ruby runtime, MemoryIO io, long offset, int count) {

  60.         short[] array = new short[count];
  61.         io.get(offset, array, 0, array.length);

  63.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  64.         for (int i = 0; i < array.length; ++i) {
  65.             arr.add(Util.newSigned16(runtime, array[i]));
  66.         }

  68.         return arr;
  69.     }
  70.     
  71.     public static final void putArrayOfSigned16(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  73.         short[] array = new short[ary.size()];
  74.         for (int i = 0; i < array.length; ++i) {
  75.             array[i] = Util.int16Value(ary.entry(i));
  76.         }

  78.         io.put(offset, array, 0, array.length);
  79.     }

  81.     public static final IRubyObject getArrayOfUnsigned16(Ruby runtime, MemoryIO io, long offset, int count) {

  83.         short[] array = new short[count];
  84.         io.get(offset, array, 0, array.length);

  86.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  87.         for (int i = 0; i < array.length; ++i) {
  88.             arr.add(Util.newUnsigned16(runtime, array[i]));
  89.         }

  91.         return arr;
  92.     }

  94.     public static final void putArrayOfUnsigned16(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  96.         short[] array = new short[ary.size()];
  97.         for (int i = 0; i < array.length; ++i) {
  98.             array[i] = (short) Util.uint16Value(ary.entry(i));
  99.         }

  101.         io.put(offset, array, 0, array.length);
  102.     }

  104.     public static final IRubyObject getArrayOfSigned32(Ruby runtime, MemoryIO io, long offset, int count) {

  106.         int[] array = new int[count];
  107.         io.get(offset, array, 0, array.length);

  109.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  110.         for (int i = 0; i < array.length; ++i) {
  111.             arr.add(Util.newSigned32(runtime, array[i]));
  112.         }

  114.         return arr;
  115.     }

  117.     public static final void putArrayOfSigned32(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  119.         int[] array = new int[ary.size()];
  120.         for (int i = 0; i < array.length; ++i) {
  121.             array[i] = Util.int32Value(ary.entry(i));
  122.         }

  124.         io.put(offset, array, 0, array.length);
  125.     }
  126.     
  127.     public static final IRubyObject getArrayOfUnsigned32(Ruby runtime, MemoryIO io, long offset, int count) {

  129.         int[] array = new int[count];
  130.         io.get(offset, array, 0, array.length);

  132.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  133.         for (int i = 0; i < array.length; ++i) {
  134.             arr.add(Util.newUnsigned32(runtime, array[i]));
  135.         }

  137.         return arr;
  138.     }

  140.     public static final void putArrayOfUnsigned32(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  142.         int[] array = new int[ary.size()];
  143.         for (int i = 0; i < array.length; ++i) {
  144.             array[i] = (int) Util.uint32Value(ary.entry(i));
  145.         }

  147.         io.put(offset, array, 0, array.length);
  148.     }

  150.     public static final IRubyObject getArrayOfSigned64(Ruby runtime, MemoryIO io, long offset, int count) {

  152.         long[] array = new long[count];
  153.         io.get(offset, array, 0, array.length);

  155.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  156.         for (int i = 0; i < array.length; ++i) {
  157.             arr.add(Util.newSigned64(runtime, array[i]));
  158.         }

  160.         return arr;
  161.     }

  163.     public static final void putArrayOfSigned64(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  165.         long[] array = new long[ary.size()];
  166.         for (int i = 0; i < array.length; ++i) {
  167.             array[i] = Util.int64Value(ary.entry(i));
  168.         }

  170.         io.put(offset, array, 0, array.length);
  171.     }

  173.     public static final IRubyObject getArrayOfUnsigned64(Ruby runtime, MemoryIO io, long offset, int count) {

  175.         long[] array = new long[count];
  176.         io.get(offset, array, 0, array.length);

  178.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  179.         for (int i = 0; i < array.length; ++i) {
  180.             arr.add(Util.newUnsigned64(runtime, array[i]));
  181.         }

  183.         return arr;
  184.     }

  186.     public static final void putArrayOfUnsigned64(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  188.         long[] array = new long[ary.size()];
  189.         for (int i = 0; i < array.length; ++i) {
  190.             array[i] = Util.uint64Value(ary.entry(i));
  191.         }

  193.         io.put(offset, array, 0, array.length);
  194.     }

  196.     public static final IRubyObject getArrayOfFloat32(Ruby runtime, MemoryIO io, long offset, int count) {

  198.         float[] array = new float[count];
  199.         io.get(offset, array, 0, array.length);

  201.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  202.         for (int i = 0; i < array.length; ++i) {
  203.             arr.add(RubyFloat.newFloat(runtime, array[i]));
  204.         }

  206.         return arr;
  207.     }

  209.     public static final void putArrayOfFloat32(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  211.         float[] array = new float[ary.size()];
  212.         for (int i = 0; i < array.length; ++i) {
  213.             array[i] = Util.floatValue(ary.entry(i));
  214.         }

  216.         io.put(offset, array, 0, array.length);
  217.     }

  219.     public static final IRubyObject getArrayOfFloat64(Ruby runtime, MemoryIO io, long offset, int count) {

  221.         double[] array = new double[count];
  222.         io.get(offset, array, 0, array.length);

  224.         RubyArray arr = RubyArray.newArray(runtime, array.length);
  225.         for (int i = 0; i < array.length; ++i) {
  226.             arr.add(RubyFloat.newFloat(runtime, array[i]));
  227.         }

  229.         return arr;
  230.     }

  232.     public static final void putArrayOfFloat64(Ruby runtime, MemoryIO io, long offset, RubyArray ary) {

  234.         double[] array = new double[ary.size()];
  235.         for (int i = 0; i < array.length; ++i) {
  236.             array[i] = Util.doubleValue(ary.entry(i));
  237.         }

  239.         io.put(offset, array, 0, array.length);
  240.     }

  242.     /**
  243.      * Creates a ruby string from a byte array and sets the taint flag on it
  244.      *
  245.      * @param runtime The ruby runtime
  246.      * @param bytes The array to make into a ruby string.
  247.      * @return A ruby string.
  248.      */
  249.     public static final RubyString newTaintedString(Ruby runtime, byte[] bytes) {
  250.         RubyString s = RubyString.newStringNoCopy(runtime, bytes);
  251.         s.setTaint(true);
  252.         return s;
  253.     }

  255.     /**
  256.      * Reads a byte (binary) string from a memory object.
  257.      *
  258.      * @param runtime The ruby runtime
  259.      * @param io The memory object to read the string from
  260.      * @param offset The offset within the memory object to start reading
  261.      * @param length The number of bytes to read
  262.      * @return A ruby string
  263.      */
  264.     public static final RubyString getTaintedByteString(Ruby runtime, MemoryIO io, long offset, int length) {
  265.         byte[] bytes = new byte[length];
  266.         io.get(offset, bytes, 0, bytes.length);
  267.         return newTaintedString(runtime, bytes);
  268.     }

  270.     /**
  271.      * Gets a NUL terminated string from a memory object
  272.      *
  273.      * @param runtime The ruby runtime
  274.      * @param io The memory object to read the string from
  275.      * @param offset The offset within the memory object to start reading
  276.      * @return A ruby string
  277.      */
  278.     public static final IRubyObject getTaintedString(Ruby runtime, MemoryIO io, long offset) {
  279.         return newTaintedString(runtime, io.getZeroTerminatedByteArray(offset));
  280.     }

  282.     /**
  283.      * Reads a NUL terminated string from a memory object
  284.      *
  285.      * @param runtime The ruby runtime
  286.      * @param io The memory object to read the string from
  287.      * @param offset The offset within the memory object to start reading
  288.      * @param maxlen The maximum number of bytes to read
  289.      * @return A ruby string
  290.      */
  291.     public static final IRubyObject getTaintedString(Ruby runtime, MemoryIO io, long offset, int length) {
  292.         return newTaintedString(runtime, io.getZeroTerminatedByteArray(offset, length));
  293.     }
  294. }
Created with JaCoCo 0.7.3.201501050207