1 files changed, 49 insertions, 27 deletions

diff --git a/src/jdk/nashorn/internal/runtime/regexp/joni/MinMaxLen.java b/src/jdk/nashorn/internal/runtime/regexp/joni/MinMaxLen.java
index 388c0c52..83a9e2dc 100644
--- a/src/jdk/nashorn/internal/runtime/regexp/joni/MinMaxLen.java
+++ b/src/jdk/nashorn/internal/runtime/regexp/joni/MinMaxLen.java
@@ -26,7 +26,7 @@ final class MinMaxLen {
     MinMaxLen() {
     }
 
-    MinMaxLen(int min, int max) {
+    MinMaxLen(final int min, final int max) {
         this.min = min;
         this.max = max;
     }
@@ -46,32 +46,48 @@ final class MinMaxLen {
     };
 
     int distanceValue() {
-        if (max == INFINITE_DISTANCE) return 0;
-        int d = max - min;
+        if (max == INFINITE_DISTANCE) {
+            return 0;
+        }
+        final int d = max - min;
         /* return dist_vals[d] * 16 / (mm->min + 12); */
         return d < distValues.length ? distValues[d] : 1;
     }
 
-    int compareDistanceValue(MinMaxLen other, int v1, int v2) {
-        if (v2 <= 0) return -1;
-        if (v1 <= 0) return 1;
+    int compareDistanceValue(final MinMaxLen other, final int v1p, final int v2p) {
+        int v1 = v1p, v2 = v2p;
+
+        if (v2 <= 0) {
+            return -1;
+        }
+        if (v1 <= 0) {
+            return 1;
+        }
 
         v1 *= distanceValue();
         v2 *= other.distanceValue();
 
-        if (v2 > v1) return 1;
-        if (v2 < v1) return -1;
+        if (v2 > v1) {
+            return 1;
+        }
+        if (v2 < v1) {
+            return -1;
+        }
 
-        if (other.min < min) return 1;
-        if (other.min > min) return -1;
+        if (other.min < min) {
+            return 1;
+        }
+        if (other.min > min) {
+            return -1;
+        }
         return 0;
     }
 
-    boolean equal(MinMaxLen other) {
+    boolean equal(final MinMaxLen other) {
         return min == other.min && max == other.max;
     }
 
-    void set(int min, int max) {
+    void set(final int min, final int max) {
         this.min = min;
         this.max = max;
     }
@@ -80,46 +96,52 @@ final class MinMaxLen {
         min = max = 0;
     }
 
-    void copy(MinMaxLen other) {
+    void copy(final MinMaxLen other) {
         min = other.min;
         max = other.max;
     }
 
-    void add(MinMaxLen other) {
+    void add(final MinMaxLen other) {
         min = distanceAdd(min, other.min);
         max = distanceAdd(max, other.max);
     }
 
-    void addLength(int len) {
+    void addLength(final int len) {
         min = distanceAdd(min, len);
         max = distanceAdd(max, len);
     }
 
-    void altMerge(MinMaxLen other) {
-        if (min > other.min) min = other.min;
-        if (max < other.max) max = other.max;
+    void altMerge(final MinMaxLen other) {
+        if (min > other.min) {
+            min = other.min;
+        }
+        if (max < other.max) {
+            max = other.max;
+        }
     }
 
     static final int INFINITE_DISTANCE = 0x7FFFFFFF;
-    static int distanceAdd(int d1, int d2) {
+    static int distanceAdd(final int d1, final int d2) {
         if (d1 == INFINITE_DISTANCE || d2 == INFINITE_DISTANCE) {
             return INFINITE_DISTANCE;
-        } else {
-            if (d1 <= INFINITE_DISTANCE - d2) return d1 + d2;
-            else return INFINITE_DISTANCE;
         }
+        if (d1 <= INFINITE_DISTANCE - d2) {
+            return d1 + d2;
+        }
+        return INFINITE_DISTANCE;
     }
 
-    static int distanceMultiply(int d, int m) {
-        if (m == 0) return 0;
+    static int distanceMultiply(final int d, final int m) {
+        if (m == 0) {
+            return 0;
+        }
         if (d < INFINITE_DISTANCE / m) {
             return d * m;
-        } else {
-            return INFINITE_DISTANCE;
         }
+        return INFINITE_DISTANCE;
     }
 
-    static String distanceRangeToString(int a, int b) {
+    static String distanceRangeToString(final int a, final int b) {
         String s = "";
         if (a == INFINITE_DISTANCE) {
             s += "inf";