1 /* 2 * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /** 25 * @test 26 * @bug 7047069 27 * @summary Array can dynamically change size when assigned to an object field 28 * @modules java.desktop 29 * 30 * @run main/othervm -Xbatch compiler.c2.Test7047069 31 */ 32 33 package compiler.c2; 34 35 import java.awt.geom.Line2D; 36 37 public class Test7047069 { 38 static boolean verbose; 39 40 static final int GROW_SIZE = 24; // Multiple of cubic & quad curve size 41 42 float squareflat; // Square of the flatness parameter 43 // for testing against squared lengths 44 45 int limit; // Maximum number of recursion levels 46 47 float hold[] = new float[14]; // The cache of interpolated coords 48 // Note that this must be long enough 49 // to store a full cubic segment and 50 // a relative cubic segment to avoid 51 // aliasing when copying the coords 52 // of a curve to the end of the array. 53 // This is also serendipitously equal 54 // to the size of a full quad segment 55 // and 2 relative quad segments. 56 57 int holdEnd; // The index of the last curve segment 58 // being held for interpolation 59 60 int holdIndex; // The index of the curve segment 61 // that was last interpolated. This 62 // is the curve segment ready to be 63 // returned in the next call to 64 // currentSegment(). 65 66 int levels[]; // The recursion level at which 67 // each curve being held in storage 68 // was generated. 69 70 int levelIndex; // The index of the entry in the 71 // levels array of the curve segment 72 // at the holdIndex 73 subdivide(float src[], int srcoff, float left[], int leftoff, float right[], int rightoff)74 public static void subdivide(float src[], int srcoff, 75 float left[], int leftoff, 76 float right[], int rightoff) 77 { 78 float x1 = src[srcoff + 0]; 79 float y1 = src[srcoff + 1]; 80 float ctrlx = src[srcoff + 2]; 81 float ctrly = src[srcoff + 3]; 82 float x2 = src[srcoff + 4]; 83 float y2 = src[srcoff + 5]; 84 if (left != null) { 85 left[leftoff + 0] = x1; 86 left[leftoff + 1] = y1; 87 } 88 if (right != null) { 89 right[rightoff + 4] = x2; 90 right[rightoff + 5] = y2; 91 } 92 x1 = (x1 + ctrlx) / 2f; 93 y1 = (y1 + ctrly) / 2f; 94 x2 = (x2 + ctrlx) / 2f; 95 y2 = (y2 + ctrly) / 2f; 96 ctrlx = (x1 + x2) / 2f; 97 ctrly = (y1 + y2) / 2f; 98 if (left != null) { 99 left[leftoff + 2] = x1; 100 left[leftoff + 3] = y1; 101 left[leftoff + 4] = ctrlx; 102 left[leftoff + 5] = ctrly; 103 } 104 if (right != null) { 105 right[rightoff + 0] = ctrlx; 106 right[rightoff + 1] = ctrly; 107 right[rightoff + 2] = x2; 108 right[rightoff + 3] = y2; 109 } 110 } 111 getFlatnessSq(float coords[], int offset)112 public static double getFlatnessSq(float coords[], int offset) { 113 return Line2D.ptSegDistSq(coords[offset + 0], coords[offset + 1], 114 coords[offset + 4], coords[offset + 5], 115 coords[offset + 2], coords[offset + 3]); 116 } 117 Test7047069()118 public Test7047069() { 119 this.squareflat = .0001f * .0001f; 120 holdIndex = hold.length - 6; 121 holdEnd = hold.length - 2; 122 hold[holdIndex + 0] = (float) (Math.random() * 100); 123 hold[holdIndex + 1] = (float) (Math.random() * 100); 124 hold[holdIndex + 2] = (float) (Math.random() * 100); 125 hold[holdIndex + 3] = (float) (Math.random() * 100); 126 hold[holdIndex + 4] = (float) (Math.random() * 100); 127 hold[holdIndex + 5] = (float) (Math.random() * 100); 128 levelIndex = 0; 129 this.limit = 10; 130 this.levels = new int[limit + 1]; 131 } 132 133 /* 134 * Ensures that the hold array can hold up to (want) more values. 135 * It is currently holding (hold.length - holdIndex) values. 136 */ ensureHoldCapacity(int want)137 void ensureHoldCapacity(int want) { 138 if (holdIndex - want < 0) { 139 int have = hold.length - holdIndex; 140 int newsize = hold.length + GROW_SIZE; 141 float newhold[] = new float[newsize]; 142 System.arraycopy(hold, holdIndex, 143 newhold, holdIndex + GROW_SIZE, 144 have); 145 if (verbose) System.err.println("old hold = "+hold+"["+hold.length+"]"); 146 if (verbose) System.err.println("replacement hold = "+newhold+"["+newhold.length+"]"); 147 hold = newhold; 148 if (verbose) System.err.println("new hold = "+hold+"["+hold.length+"]"); 149 if (verbose) System.err.println("replacement hold still = "+newhold+"["+newhold.length+"]"); 150 holdIndex += GROW_SIZE; 151 holdEnd += GROW_SIZE; 152 } 153 } 154 next()155 private boolean next() { 156 if (holdIndex >= holdEnd) { 157 return false; 158 } 159 160 int level = levels[levelIndex]; 161 while (level < limit) { 162 if (getFlatnessSq(hold, holdIndex) < squareflat) { 163 break; 164 } 165 166 ensureHoldCapacity(4); 167 subdivide(hold, holdIndex, 168 hold, holdIndex - 4, 169 hold, holdIndex); 170 holdIndex -= 4; 171 172 // Now that we have subdivided, we have constructed 173 // two curves of one depth lower than the original 174 // curve. One of those curves is in the place of 175 // the former curve and one of them is in the next 176 // set of held coordinate slots. We now set both 177 // curves level values to the next higher level. 178 level++; 179 levels[levelIndex] = level; 180 levelIndex++; 181 levels[levelIndex] = level; 182 } 183 184 // This curve segment is flat enough, or it is too deep 185 // in recursion levels to try to flatten any more. The 186 // two coordinates at holdIndex+4 and holdIndex+5 now 187 // contain the endpoint of the curve which can be the 188 // endpoint of an approximating line segment. 189 holdIndex += 4; 190 levelIndex--; 191 return true; 192 } 193 main(String argv[])194 public static void main(String argv[]) { 195 verbose = (argv.length > 0); 196 for (int i = 0; i < 100000; i++) { 197 Test7047069 st = new Test7047069(); 198 while (st.next()) {} 199 } 200 } 201 } 202