Merge pull request #4288 from melissalinkert/implicit-type-narrowing

Fix a bunch of `Implicit type narrowing` warnings

Author: sbesson

components/formats-bsd/src/loci/formats/ResourceNamer.java

@@ -139,8 +139,14 @@ public String getLetter() {
   public static int alphabeticIndexCount(String index) {
     int count = 0;
     char[] letters = index.toCharArray();
+    if (letters.length > 6) {
+      // this will cause an integer overflow
+      throw new IllegalArgumentException("Cannot count more than 6 characters");
+    }
     for (int i = 0; i < letters.length; i++) {
-      count += (letters[i] - 64) * Math.pow(ALPHABET_LENGTH, i);
+      int letterIndex = (int) Math.pow(ALPHABET_LENGTH, i);
+      int letterValue = letterIndex * (letters[i] - 64);
+      count += letterValue;
     }
     return count;
   }

components/formats-bsd/src/loci/formats/gui/AWTImageTools.java

@@ -1632,7 +1632,7 @@ else if (pixels instanceof short[][]) {
 
       for (int i=0; i<out.length; i++) {
         for (int j=0; j<out[i].length; j++) {
-          if (shorts[i][j] < 0) shorts[i][j] += 32767;
+          if (shorts[i][j] < 0) shorts[i][j] += Short.MAX_VALUE;
 
           int diff = max - min;
           float dist = (float) (shorts[i][j] - min) / diff;

components/formats-bsd/src/loci/formats/in/FlowSightReader.java

@@ -382,11 +382,21 @@ public boolean hasNext() {
         shift = 0;
         value = 0;
         while (! loaded) {
+          if (shift > 15) {
+            // this implies that all subsequently read bits will be cleared
+            LOGGER.error("Unexpected bit shift value {}, image may be truncated", shift);
+            return false;
+          }
           byte nibble;
           try {
             nibble = getNextNibble();
-            value += ((short) (nibble & 0x7) ) << shift;
-            shift += 3;
+
+            // these 2 additions are safe since shift is 15 or less at this point
+            // due to check at top of loop
+            short lowBits = (short) (nibble & 0x7);
+            value += (short) (lowBits << shift);
+            shift += (short) 3;
+
             if ((nibble & 0x8) == 0) {
               loaded = true;
               bHasNext = true;

components/formats-bsd/src/loci/formats/in/MinimalTiffReader.java

@@ -341,14 +341,16 @@ public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
             }
             exponent++;
             mantissa &= (int) (Math.pow(2, mantissaBits) - 1);
-            exponent += 127 - (Math.pow(2, exponentBits - 1) - 1);
+            int max = (int) Math.pow(2, exponentBits - 1);
+            exponent += 127 - (max - 1);
           }
         }
         else if (exponent == maxExponent) {
           exponent = 255;
         }
         else {
-          exponent += 127 - (Math.pow(2, exponentBits - 1) - 1);
+          int max = (int) Math.pow(2, exponentBits - 1);
+          exponent += 127 - (max - 1);
         }
 
         mantissa <<= (23 - mantissaBits);

components/formats-bsd/src/loci/formats/in/OBFReader.java

@@ -756,9 +756,13 @@ private void readFromStack(Stack stack, byte[] buffer, int bufferOffset, int byt
           long bytesWrittenAfter = inflater.getBytesWritten();
 
           long decompressedBytes = bytesWrittenAfter - bytesWrittenBefore;
+          if (decompressedBytes + bufferOffset > Integer.MAX_VALUE) {
+            throw new FormatException(
+              "Unexpectedly large number of bytes decompressed: " + decompressedBytes);
+          }
 
-          bufferOffset += decompressedBytes;
-          remainingBytes -= decompressedBytes;
+          bufferOffset += (int) decompressedBytes;
+          remainingBytes -= (int) decompressedBytes;
 
           if(remainingBytes != 0) {
             throw new FormatException(

components/formats-bsd/src/loci/formats/tiff/TiffParser.java

@@ -1062,7 +1062,12 @@ public byte[] getSamples(IFD ifd, byte[] buf, int x, int y,
       return buf;
     }
 
-    long nrows = numTileRows;
+    // very unlikely, but checking here so that the tile row count
+    // can be cast to int without worrying about overflowing
+    if (numTileRows > Integer.MAX_VALUE) {
+      throw new FormatException(numTileRows + " rows of tiles not supported");
+    }
+    int nrows = (int) numTileRows;
     if (planarConfig == 2) numTileRows *= samplesPerPixel;
 
     Region imageBounds = new Region(x, y, (int) width, (int) height);
@@ -1145,7 +1150,9 @@ public byte[] getSamples(IFD ifd, byte[] buf, int x, int y,
           int src = (int) (q * tileSize) + realX + realY;
           int dest = (int) (q * planeSize) + pixel * (tileX - x) +
             outputRowLen * (tileY - y);
-          if (planarConfig == 2) dest += (planeSize * (row / nrows));
+          if (planarConfig == 2) {
+            dest += (planeSize * (row / nrows));
+          }
 
           // copying the tile directly will only work if there is no overlap
           // and only one tile needs to be read

components/formats-bsd/src/loci/formats/tools/MakeTestOmeTiff.java

@@ -374,7 +374,7 @@ private BufferedImage createPlane(final String name, final CoreMetadata info,
       g.setFont(text.font);
       final Rectangle2D r =
         g.getFont().getStringBounds(text.line, g.getFontRenderContext());
-      yoff += r.getHeight() + text.ypad;
+      yoff += (int) r.getHeight() + text.ypad;
       g.drawString(text.line, text.xoff, yoff);
     }
     g.dispose();

components/formats-gpl/src/loci/formats/in/BioRadGelReader.java

@@ -152,7 +152,7 @@ protected void initFile(String id) throws FormatException, IOException {
     in.seek(START_OFFSET);
 
     boolean codeFound = false;
-    int skip = 0;
+    long skip = 0;
     long baseFP = 0;
 
     while (!codeFound) {

components/formats-gpl/src/loci/formats/in/PCIReader.java

@@ -415,7 +415,16 @@ else if (relativePath.equals("Comments")) {
       TiffParser tp = new TiffParser(s);
       // don't correct the image width if it's stored as a TIFF
       if (!tp.isValidHeader() && s.length() > expectedPlaneSize) {
-        m.sizeX += (s.length() - expectedPlaneSize) / (m.sizeY * bpp * m.sizeC);
+        long extraBytesInFile = s.length() - expectedPlaneSize;
+        long extraPixelsPerRow = extraBytesInFile / (m.sizeY * bpp * m.sizeC);
+
+        // this would be very unexpected, but checking here so that
+        // casting extraPixelsPerRow to int or adding to m.sizeX cannot overflow
+        if (extraPixelsPerRow >= Integer.MAX_VALUE - m.sizeX) {
+          throw new FormatException("Stream length (" + s.length() +
+            ") inconsistent with plane size in bytes (" + expectedPlaneSize + ")");
+        }
+        m.sizeX += (int) extraPixelsPerRow;
       }
     }
 

components/formats-gpl/src/loci/formats/in/XLEFReader.java

@@ -341,7 +341,7 @@ private void transformBytes8To16(byte[] in, byte[] out, int outRes) {
 
     int inPtr = 0;
     int outPtr = 0;
-    double factor = Math.pow(2, outRes - 8);
+    int factor = (int) Math.pow(2, outRes - 8);
     while (inPtr < in.length && outPtr < out.length) {
       int val = in[inPtr++];
       val *= factor;