--- old/make/jdk/src/classes/build/tools/generatebreakiteratordata/RuleBasedBreakIteratorBuilder.java 2020-03-20 12:37:54.482069160 +0100 +++ new/make/jdk/src/classes/build/tools/generatebreakiteratordata/RuleBasedBreakIteratorBuilder.java 2020-03-20 12:37:54.178069162 +0100 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -290,7 +290,7 @@ } lastOpen = c; - parenStack.push(new Character((char)c)); + parenStack.push(Character.valueOf((char)c)); if (c == '<') { sawVarName = true; } @@ -902,11 +902,11 @@ // if we're adding rules to the backward state table, mark the initial state // as a looping state if (!forward) { - loopingStates.addElement(new Integer(1)); + loopingStates.addElement(Integer.valueOf(1)); } // put the current state on the decision point list before we start - decisionPointList.addElement(new Integer(currentState)); // we want currentState to + decisionPointList.addElement(Integer.valueOf(currentState)); // we want currentState to // be 1 here... currentState = tempStateTable.size() - 1; // but after that, we want it to be // 1 less than the state number of the next state @@ -978,7 +978,7 @@ // if the period is followed by an asterisk, then just set the current // state to loop back on itself if (p + 1 < rule.length() && rule.charAt(p + 1) == '*' && state[0] != 0) { - decisionPointList.addElement(new Integer(state[0])); + decisionPointList.addElement(Integer.valueOf(state[0])); pendingChars = ""; ++p; } @@ -1012,7 +1012,7 @@ // it to the end of the state table int newState = tempStateTable.size(); if (loopingStates.size() != 0) { - statesToBackfill.addElement(new Integer(newState)); + statesToBackfill.addElement(Integer.valueOf(newState)); } state = new short[numCategories + 1]; if (sawEarlyBreak) { @@ -1032,7 +1032,7 @@ lastState = currentState; do { ++currentState; - decisionPointList.addElement(new Integer(currentState)); + decisionPointList.addElement(Integer.valueOf(currentState)); } while (currentState + 1 < tempStateTable.size()); } } @@ -1058,7 +1058,7 @@ if (c == '*') { for (int i = lastState + 1; i < tempStateTable.size(); i++) { Vector temp = new Vector<>(); - temp.addElement(new Integer(i)); + temp.addElement(Integer.valueOf(i)); updateStateTable(temp, pendingChars, (short)(lastState + 1)); } } @@ -1121,7 +1121,7 @@ // add the current state to the decision point list (add it at the // BEGINNING so we can find it later) - decisionPointList.insertElementAt(new Integer(currentState), 0); + decisionPointList.insertElementAt(Integer.valueOf(currentState), 0); // finally, push a copy of the current decision point list onto the // stack (this keeps track of the active decision point list before @@ -1208,7 +1208,7 @@ for (int i = 0; i < tempState.length; i++) { if (tempState[i] > tempStateNum) { updateStateTable(exitPoints, - new Character((char)(i + 0x100)).toString(), + Character.valueOf((char)(i + 0x100)).toString(), tempState[i]); } } @@ -1330,7 +1330,7 @@ short[] newValues, Vector rowsBeingUpdated) { short[] oldValues = tempStateTable.elementAt(rowNum); - boolean isLoopingState = loopingStates.contains(new Integer(rowNum)); + boolean isLoopingState = loopingStates.contains(Integer.valueOf(rowNum)); // for each of the cells in the rows we're reconciling, do... for (int i = 0; i < oldValues.length; i++) { @@ -1343,7 +1343,7 @@ // if oldValues is a looping state and the state the current cell points to // is too, then we can just stomp over the current value of that cell (and // set the clear-looping-states flag if necessary) - else if (isLoopingState && loopingStates.contains(new Integer(oldValues[i]))) { + else if (isLoopingState && loopingStates.contains(Integer.valueOf(oldValues[i]))) { if (newValues[i] != 0) { if (oldValues[i] == 0) { clearLoopingStates = true; @@ -1401,29 +1401,29 @@ // if the decision point list contains either of the parent rows, // update it to include the new row as well - if ((decisionPointList.contains(new Integer(oldRowNum)) - || decisionPointList.contains(new Integer(newRowNum))) - && !decisionPointList.contains(new Integer(combinedRowNum)) + if ((decisionPointList.contains(Integer.valueOf(oldRowNum)) + || decisionPointList.contains(Integer.valueOf(newRowNum))) + && !decisionPointList.contains(Integer.valueOf(combinedRowNum)) ) { - decisionPointList.addElement(new Integer(combinedRowNum)); + decisionPointList.addElement(Integer.valueOf(combinedRowNum)); } // do the same thing with the list of rows being updated - if ((rowsBeingUpdated.contains(new Integer(oldRowNum)) - || rowsBeingUpdated.contains(new Integer(newRowNum))) - && !rowsBeingUpdated.contains(new Integer(combinedRowNum)) + if ((rowsBeingUpdated.contains(Integer.valueOf(oldRowNum)) + || rowsBeingUpdated.contains(Integer.valueOf(newRowNum))) + && !rowsBeingUpdated.contains(Integer.valueOf(combinedRowNum)) ) { - decisionPointList.addElement(new Integer(combinedRowNum)); + decisionPointList.addElement(Integer.valueOf(combinedRowNum)); } // now (groan) do the same thing for all the entries on the // decision point stack for (int k = 0; k < decisionPointStack.size(); k++) { Vector dpl = decisionPointStack.elementAt(k); - if ((dpl.contains(new Integer(oldRowNum)) - || dpl.contains(new Integer(newRowNum))) - && !dpl.contains(new Integer(combinedRowNum)) + if ((dpl.contains(Integer.valueOf(oldRowNum)) + || dpl.contains(Integer.valueOf(newRowNum))) + && !dpl.contains(Integer.valueOf(combinedRowNum)) ) { - dpl.addElement(new Integer(combinedRowNum)); + dpl.addElement(Integer.valueOf(combinedRowNum)); } } @@ -1536,10 +1536,10 @@ private void eliminateBackfillStates(int baseState) { // don't do anything unless this state is actually in the backfill list... - if (statesToBackfill.contains(new Integer(baseState))) { + if (statesToBackfill.contains(Integer.valueOf(baseState))) { // if it is, take it out - statesToBackfill.removeElement(new Integer(baseState)); + statesToBackfill.removeElement(Integer.valueOf(baseState)); // then go through and recursively call this function for every // state that the base state points to @@ -1608,7 +1608,7 @@ int[] rowNumMap = new int[tempStateTable.size()]; Stack rowsToFollow = new Stack<>(); - rowsToFollow.push(new Integer(1)); + rowsToFollow.push(Integer.valueOf(1)); rowNumMap[1] = 1; // determine which states are no longer reachable from the start state @@ -1622,7 +1622,7 @@ if (row[i] != 0) { if (rowNumMap[row[i]] == 0) { rowNumMap[row[i]] = row[i]; - rowsToFollow.push(new Integer(row[i])); + rowsToFollow.push(Integer.valueOf(row[i])); } } }