You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by mi...@apache.org on 2011/07/08 14:47:41 UTC
svn commit: r1144294 - in
/lucene/dev/trunk/lucene/src/java/org/apache/lucene:
index/values/FixedDerefBytesImpl.java util/ArrayUtil.java
Author: mikemccand
Date: Fri Jul 8 12:47:41 2011
New Revision: 1144294
URL: http://svn.apache.org/viewvc?rev=1144294&view=rev
Log:
try to catch int overflow in ArrayUtil.grow/shrink
Modified:
lucene/dev/trunk/lucene/src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java
lucene/dev/trunk/lucene/src/java/org/apache/lucene/util/ArrayUtil.java
Modified: lucene/dev/trunk/lucene/src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java?rev=1144294&r1=1144293&r2=1144294&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java (original)
+++ lucene/dev/trunk/lucene/src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java Fri Jul 8 12:47:41 2011
@@ -221,8 +221,10 @@ class FixedDerefBytesImpl {
idxIn.readInt();// read valueCount
idx = PackedInts.getReaderIterator(idxIn);
fp = datIn.getFilePointer();
- bytesRef.grow(this.size);
- bytesRef.length = this.size;
+ if (size > 0) {
+ bytesRef.grow(this.size);
+ bytesRef.length = this.size;
+ }
bytesRef.offset = 0;
valueCount = idx.size();
}
Modified: lucene/dev/trunk/lucene/src/java/org/apache/lucene/util/ArrayUtil.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/java/org/apache/lucene/util/ArrayUtil.java?rev=1144294&r1=1144293&r2=1144294&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/java/org/apache/lucene/util/ArrayUtil.java (original)
+++ lucene/dev/trunk/lucene/src/java/org/apache/lucene/util/ArrayUtil.java Fri Jul 8 12:47:41 2011
@@ -230,6 +230,7 @@ public final class ArrayUtil {
}
public static short[] grow(short[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
short[] newArray = new short[oversize(minSize, RamUsageEstimator.NUM_BYTES_SHORT)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -243,6 +244,7 @@ public final class ArrayUtil {
}
public static float[] grow(float[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
float[] newArray = new float[oversize(minSize, RamUsageEstimator.NUM_BYTES_FLOAT)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -256,6 +258,7 @@ public final class ArrayUtil {
}
public static double[] grow(double[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
double[] newArray = new double[oversize(minSize, RamUsageEstimator.NUM_BYTES_DOUBLE)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -269,6 +272,7 @@ public final class ArrayUtil {
}
public static short[] shrink(short[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_SHORT);
if (newSize != array.length) {
short[] newArray = new short[newSize];
@@ -279,6 +283,7 @@ public final class ArrayUtil {
}
public static int[] grow(int[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
int[] newArray = new int[oversize(minSize, RamUsageEstimator.NUM_BYTES_INT)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -292,6 +297,7 @@ public final class ArrayUtil {
}
public static int[] shrink(int[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_INT);
if (newSize != array.length) {
int[] newArray = new int[newSize];
@@ -302,6 +308,7 @@ public final class ArrayUtil {
}
public static long[] grow(long[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
long[] newArray = new long[oversize(minSize, RamUsageEstimator.NUM_BYTES_LONG)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -315,6 +322,7 @@ public final class ArrayUtil {
}
public static long[] shrink(long[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_LONG);
if (newSize != array.length) {
long[] newArray = new long[newSize];
@@ -325,6 +333,7 @@ public final class ArrayUtil {
}
public static byte[] grow(byte[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
byte[] newArray = new byte[oversize(minSize, 1)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -338,6 +347,7 @@ public final class ArrayUtil {
}
public static byte[] shrink(byte[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, 1);
if (newSize != array.length) {
byte[] newArray = new byte[newSize];
@@ -348,6 +358,7 @@ public final class ArrayUtil {
}
public static boolean[] grow(boolean[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
boolean[] newArray = new boolean[oversize(minSize, 1)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -361,6 +372,7 @@ public final class ArrayUtil {
}
public static boolean[] shrink(boolean[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, 1);
if (newSize != array.length) {
boolean[] newArray = new boolean[newSize];
@@ -371,6 +383,7 @@ public final class ArrayUtil {
}
public static char[] grow(char[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
char[] newArray = new char[oversize(minSize, RamUsageEstimator.NUM_BYTES_CHAR)];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -384,6 +397,7 @@ public final class ArrayUtil {
}
public static char[] shrink(char[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_CHAR);
if (newSize != array.length) {
char[] newArray = new char[newSize];
@@ -394,6 +408,7 @@ public final class ArrayUtil {
}
public static int[][] grow(int[][] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
int[][] newArray = new int[oversize(minSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF)][];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -408,6 +423,7 @@ public final class ArrayUtil {
}
public static int[][] shrink(int[][] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
if (newSize != array.length) {
int[][] newArray = new int[newSize][];
@@ -419,6 +435,7 @@ public final class ArrayUtil {
}
public static float[][] grow(float[][] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
float[][] newArray = new float[oversize(minSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF)][];
System.arraycopy(array, 0, newArray, 0, array.length);
@@ -433,6 +450,7 @@ public final class ArrayUtil {
}
public static float[][] shrink(float[][] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
if (newSize != array.length) {
float[][] newArray = new float[newSize][];
@@ -494,6 +512,7 @@ public final class ArrayUtil {
/* DISABLE THIS FOR NOW: This has performance problems until Java creates intrinsics for Class#getComponentType() and Array.newInstance()
public static <T> T[] grow(T[] array, int minSize) {
+ assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";
if (array.length < minSize) {
@SuppressWarnings("unchecked") final T[] newArray =
(T[]) Array.newInstance(array.getClass().getComponentType(), oversize(minSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF));
@@ -508,6 +527,7 @@ public final class ArrayUtil {
}
public static <T> T[] shrink(T[] array, int targetSize) {
+ assert targetSize >= 0: "size must be positive (got " + targetSize + "): likely integer overflow?";
final int newSize = getShrinkSize(array.length, targetSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
if (newSize != array.length) {
@SuppressWarnings("unchecked") final T[] newArray =