|
|
@@ -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 @@ public RuleBasedBreakIteratorBuilder(String description) { |
|
|
} |
|
|
|
|
|
lastOpen = c; |
|
|
parenStack.push(new Character((char)c)); |
|
|
parenStack.push(Character.valueOf((char)c)); |
|
|
if (c == '<') { |
|
|
sawVarName = true; |
|
|
} |
|
@@ -902,11 +902,11 @@ private void parseRule(String rule, boolean forward) { |
|
|
// 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 @@ else if (c == '\\') { |
|
|
// 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 @@ else if (c == '\\') { |
|
|
// 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 @@ else if (c == '\\') { |
|
|
lastState = currentState; |
|
|
do { |
|
|
++currentState; |
|
|
decisionPointList.addElement(new Integer(currentState)); |
|
|
decisionPointList.addElement(Integer.valueOf(currentState)); |
|
|
} while (currentState + 1 < tempStateTable.size()); |
|
|
} |
|
|
} |
|
@@ -1058,7 +1058,7 @@ else if (c == '}' || c == '*') { |
|
|
if (c == '*') { |
|
|
for (int i = lastState + 1; i < tempStateTable.size(); i++) { |
|
|
Vector<Integer> temp = new Vector<>(); |
|
|
temp.addElement(new Integer(i)); |
|
|
temp.addElement(Integer.valueOf(i)); |
|
|
updateStateTable(temp, pendingChars, (short)(lastState + 1)); |
|
|
} |
|
|
} |
|
@@ -1121,7 +1121,7 @@ else if (c == '(') { |
|
|
|
|
|
// 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 @@ else if (c == ')') { |
|
|
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 @@ private void mergeStates(int rowNum, |
|
|
short[] newValues, |
|
|
Vector<Integer> 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 @@ private void mergeStates(int rowNum, |
|
|
// 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 @@ else if (oldValues[i] != 0 && newValues[i] != 0) { |
|
|
|
|
|
// 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<Integer> 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 setLoopingStates(Vector<Integer> newLoopingStates, |
|
|
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 @@ private void finishBuildingStateTable(boolean forward) { |
|
|
|
|
|
int[] rowNumMap = new int[tempStateTable.size()]; |
|
|
Stack<Integer> 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 @@ private void finishBuildingStateTable(boolean forward) { |
|
|
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])); |
|
|
} |
|
|
} |
|
|
} |
|
|