giteadmin/script-astra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4380f00a78
script-astra/Android/Sdk/sources/android-35/android/icu/text/MessagePattern.java

1549 lines
58 KiB
Java
Raw Normal View History

init
2025-01-20 15:15:20 +00:00
/* GENERATED SOURCE. DO NOT MODIFY. */
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2010-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* created on: 2010aug21
* created by: Markus W. Scherer
*/
package android.icu.text;
import java.util.ArrayList;
import java.util.Locale;
import android.icu.impl.ICUConfig;
import android.icu.impl.PatternProps;
import android.icu.util.Freezable;
import android.icu.util.ICUCloneNotSupportedException;
//Note: Minimize ICU dependencies, only use a very small part of the ICU core.
//In particular, do not depend on *Format classes.
/**
* Parses and represents ICU MessageFormat patterns.
* Also handles patterns for ChoiceFormat, PluralFormat and SelectFormat.
* Used in the implementations of those classes as well as in tools
* for message validation, translation and format conversion.
* <p>
* The parser handles all syntax relevant for identifying message arguments.
* This includes "complex" arguments whose style strings contain
* nested MessageFormat pattern substrings.
* For "simple" arguments (with no nested MessageFormat pattern substrings),
* the argument style is not parsed any further.
* <p>
* The parser handles named and numbered message arguments and allows both in one message.
* <p>
* Once a pattern has been parsed successfully, iterate through the parsed data
* with countParts(), getPart() and related methods.
* <p>
* The data logically represents a parse tree, but is stored and accessed
* as a list of "parts" for fast and simple parsing and to minimize object allocations.
* Arguments and nested messages are best handled via recursion.
* For every _START "part", {@link #getLimitPartIndex(int)} efficiently returns
* the index of the corresponding _LIMIT "part".
* <p>
* List of "parts":
* <pre>
* message = MSG_START (SKIP_SYNTAX | INSERT_CHAR | REPLACE_NUMBER | argument)* MSG_LIMIT
* argument = noneArg | simpleArg | complexArg
* complexArg = choiceArg | pluralArg | selectArg
*
* noneArg = ARG_START.NONE (ARG_NAME | ARG_NUMBER) ARG_LIMIT.NONE
* simpleArg = ARG_START.SIMPLE (ARG_NAME | ARG_NUMBER) ARG_TYPE [ARG_STYLE] ARG_LIMIT.SIMPLE
* choiceArg = ARG_START.CHOICE (ARG_NAME | ARG_NUMBER) choiceStyle ARG_LIMIT.CHOICE
* pluralArg = ARG_START.PLURAL (ARG_NAME | ARG_NUMBER) pluralStyle ARG_LIMIT.PLURAL
* selectArg = ARG_START.SELECT (ARG_NAME | ARG_NUMBER) selectStyle ARG_LIMIT.SELECT
*
* choiceStyle = ((ARG_INT | ARG_DOUBLE) ARG_SELECTOR message)+
* pluralStyle = [ARG_INT | ARG_DOUBLE] (ARG_SELECTOR [ARG_INT | ARG_DOUBLE] message)+
* selectStyle = (ARG_SELECTOR message)+
* </pre>
* <ul>
* <li>Literal output text is not represented directly by "parts" but accessed
* between parts of a message, from one part's getLimit() to the next part's getIndex().
* <li><code>ARG_START.CHOICE</code> stands for an ARG_START Part with ArgType CHOICE.
* <li>In the choiceStyle, the ARG_SELECTOR has the '&lt;', the '#' or
* the less-than-or-equal-to sign (U+2264).
* <li>In the pluralStyle, the first, optional numeric Part has the "offset:" value.
* The optional numeric Part between each (ARG_SELECTOR, message) pair
* is the value of an explicit-number selector like "=2",
* otherwise the selector is a non-numeric identifier.
* <li>The REPLACE_NUMBER Part can occur only in an immediate sub-message of the pluralStyle.
* </ul>
* <p>
* This class is not intended for public subclassing.
*
* @author Markus Scherer
*/
public final class MessagePattern implements Cloneable, Freezable<MessagePattern> {
/**
* Mode for when an apostrophe starts quoted literal text for MessageFormat output.
* The default is DOUBLE_OPTIONAL unless overridden via ICUConfig
* (/com/ibm/icu/ICUConfig.properties).
* <p>
* A pair of adjacent apostrophes always results in a single apostrophe in the output,
* even when the pair is between two single, text-quoting apostrophes.
* <p>
* The following table shows examples of desired MessageFormat.format() output
* with the pattern strings that yield that output.
*
* <table>
* <tr>
* <th>Desired output</th>
* <th>DOUBLE_OPTIONAL</th>
* <th>DOUBLE_REQUIRED</th>
* </tr>
* <tr>
* <td>I see {many}</td>
* <td>I see '{many}'</td>
* <td>(same)</td>
* </tr>
* <tr>
* <td>I said {'Wow!'}</td>
* <td>I said '{''Wow!''}'</td>
* <td>(same)</td>
* </tr>
* <tr>
* <td>I don't know</td>
* <td>I don't know OR<br> I don''t know</td>
* <td>I don''t know</td>
* </tr>
* </table>
*/
public enum ApostropheMode {
/**
* A literal apostrophe is represented by
* either a single or a double apostrophe pattern character.
* Within a MessageFormat pattern, a single apostrophe only starts quoted literal text
* if it immediately precedes a curly brace {},
* or a pipe symbol | if inside a choice format,
* or a pound symbol # if inside a plural format.
* <p>
* This is the default behavior starting with ICU 4.8.
*/
DOUBLE_OPTIONAL,
/**
* A literal apostrophe must be represented by
* a double apostrophe pattern character.
* A single apostrophe always starts quoted literal text.
* <p>
* This is the behavior of ICU 4.6 and earlier, and of {@link java.text.MessageFormat}.
*/
DOUBLE_REQUIRED
}
/**
* Constructs an empty MessagePattern with default ApostropheMode.
*/
public MessagePattern() {
aposMode=defaultAposMode;
}
/**
* Constructs an empty MessagePattern.
* @param mode Explicit ApostropheMode.
*/
public MessagePattern(ApostropheMode mode) {
aposMode=mode;
}
/**
* Constructs a MessagePattern with default ApostropheMode and
* parses the MessageFormat pattern string.
* @param pattern a MessageFormat pattern string
* @throws IllegalArgumentException for syntax errors in the pattern string
* @throws IndexOutOfBoundsException if certain limits are exceeded
* (e.g., argument number too high, argument name too long, etc.)
* @throws NumberFormatException if a number could not be parsed
*/
public MessagePattern(String pattern) {
aposMode=defaultAposMode;
parse(pattern);
}
/**
* Parses a MessageFormat pattern string.
* @param pattern a MessageFormat pattern string
* @return this
* @throws IllegalArgumentException for syntax errors in the pattern string
* @throws IndexOutOfBoundsException if certain limits are exceeded
* (e.g., argument number too high, argument name too long, etc.)
* @throws NumberFormatException if a number could not be parsed
*/
public MessagePattern parse(String pattern) {
preParse(pattern);
parseMessage(0, 0, 0, ArgType.NONE);
postParse();
return this;
}
/**
* Parses a ChoiceFormat pattern string.
* @param pattern a ChoiceFormat pattern string
* @return this
* @throws IllegalArgumentException for syntax errors in the pattern string
* @throws IndexOutOfBoundsException if certain limits are exceeded
* (e.g., argument number too high, argument name too long, etc.)
* @throws NumberFormatException if a number could not be parsed
*/
public MessagePattern parseChoiceStyle(String pattern) {
preParse(pattern);
parseChoiceStyle(0, 0);
postParse();
return this;
}
/**
* Parses a PluralFormat pattern string.
* @param pattern a PluralFormat pattern string
* @return this
* @throws IllegalArgumentException for syntax errors in the pattern string
* @throws IndexOutOfBoundsException if certain limits are exceeded
* (e.g., argument number too high, argument name too long, etc.)
* @throws NumberFormatException if a number could not be parsed
*/
public MessagePattern parsePluralStyle(String pattern) {
preParse(pattern);
parsePluralOrSelectStyle(ArgType.PLURAL, 0, 0);
postParse();
return this;
}
/**
* Parses a SelectFormat pattern string.
* @param pattern a SelectFormat pattern string
* @return this
* @throws IllegalArgumentException for syntax errors in the pattern string
* @throws IndexOutOfBoundsException if certain limits are exceeded
* (e.g., argument number too high, argument name too long, etc.)
* @throws NumberFormatException if a number could not be parsed
*/
public MessagePattern parseSelectStyle(String pattern) {
preParse(pattern);
parsePluralOrSelectStyle(ArgType.SELECT, 0, 0);
postParse();
return this;
}
/**
* Clears this MessagePattern.
* countParts() will return 0.
*/
public void clear() {
// Mostly the same as preParse().
if(isFrozen()) {
throw new UnsupportedOperationException(
"Attempt to clear() a frozen MessagePattern instance.");
}
msg=null;
hasArgNames=hasArgNumbers=false;
needsAutoQuoting=false;
parts.clear();
if(numericValues!=null) {
numericValues.clear();
}
}
/**
* Clears this MessagePattern and sets the ApostropheMode.
* countParts() will return 0.
* @param mode The new ApostropheMode.
*/
public void clearPatternAndSetApostropheMode(ApostropheMode mode) {
clear();
aposMode=mode;
}
/**
* @param other another object to compare with.
* @return true if this object is equivalent to the other one.
*/
@Override
public boolean equals(Object other) {
if(this==other) {
return true;
}
if(other==null || getClass()!=other.getClass()) {
return false;
}
MessagePattern o=(MessagePattern)other;
return
aposMode.equals(o.aposMode) &&
(msg==null ? o.msg==null : msg.equals(o.msg)) &&
parts.equals(o.parts);
// No need to compare numericValues if msg and parts are the same.
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return (aposMode.hashCode()*37+(msg!=null ? msg.hashCode() : 0))*37+parts.hashCode();
}
/**
* @return this instance's ApostropheMode.
*/
public ApostropheMode getApostropheMode() {
return aposMode;
}
/**
* @return true if getApostropheMode() == ApostropheMode.DOUBLE_REQUIRED
* @hide draft / provisional / internal are hidden on Android
*/
/* package */ boolean jdkAposMode() {
return aposMode == ApostropheMode.DOUBLE_REQUIRED;
}
/**
* @return the parsed pattern string (null if none was parsed).
*/
public String getPatternString() {
return msg;
}
/**
* Does the parsed pattern have named arguments like {first_name}?
* @return true if the parsed pattern has at least one named argument.
*/
public boolean hasNamedArguments() {
return hasArgNames;
}
/**
* Does the parsed pattern have numbered arguments like {2}?
* @return true if the parsed pattern has at least one numbered argument.
*/
public boolean hasNumberedArguments() {
return hasArgNumbers;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return msg;
}
/**
* Validates and parses an argument name or argument number string.
* An argument name must be a "pattern identifier", that is, it must contain
* no Unicode Pattern_Syntax or Pattern_White_Space characters.
* If it only contains ASCII digits, then it must be a small integer with no leading zero.
* @param name Input string.
* @return &gt;=0 if the name is a valid number,
* ARG_NAME_NOT_NUMBER (-1) if it is a "pattern identifier" but not all ASCII digits,
* ARG_NAME_NOT_VALID (-2) if it is neither.
*/
public static int validateArgumentName(String name) {
if(!PatternProps.isIdentifier(name)) {
return ARG_NAME_NOT_VALID;
}
return parseArgNumber(name, 0, name.length());
}
/**
* Return value from {@link #validateArgumentName(String)} for when
* the string is a valid "pattern identifier" but not a number.
*/
public static final int ARG_NAME_NOT_NUMBER=-1;
/**
* Return value from {@link #validateArgumentName(String)} for when
* the string is invalid.
* It might not be a valid "pattern identifier",
* or it have only ASCII digits but there is a leading zero or the number is too large.
*/
public static final int ARG_NAME_NOT_VALID=-2;
/**
* Returns a version of the parsed pattern string where each ASCII apostrophe
* is doubled (escaped) if it is not already, and if it is not interpreted as quoting syntax.
* <p>
* For example, this turns "I don't '{know}' {gender,select,female{h''er}other{h'im}}."
* into "I don''t '{know}' {gender,select,female{h''er}other{h''im}}."
* @return the deep-auto-quoted version of the parsed pattern string.
* @see MessageFormat#autoQuoteApostrophe(String)
*/
public String autoQuoteApostropheDeep() {
if(!needsAutoQuoting) {
return msg;
}
StringBuilder modified=null;
// Iterate backward so that the insertion indexes do not change.
int count=countParts();
for(int i=count; i>0;) {
Part part;
if((part=getPart(--i)).getType()==Part.Type.INSERT_CHAR) {
if(modified==null) {
modified=new StringBuilder(msg.length()+10).append(msg);
}
modified.insert(part.index, (char)part.value);
}
}
if(modified==null) {
return msg;
} else {
return modified.toString();
}
}
/**
* Returns the number of "parts" created by parsing the pattern string.
* Returns 0 if no pattern has been parsed or clear() was called.
* @return the number of pattern parts.
*/
public int countParts() {
return parts.size();
}
/**
* Gets the i-th pattern "part".
* @param i The index of the Part data. (0..countParts()-1)
* @return the i-th pattern "part".
* @throws IndexOutOfBoundsException if i is outside the (0..countParts()-1) range
*/
public Part getPart(int i) {
return parts.get(i);
}
/**
* Returns the Part.Type of the i-th pattern "part".
* Convenience method for getPart(i).getType().
* @param i The index of the Part data. (0..countParts()-1)
* @return The Part.Type of the i-th Part.
* @throws IndexOutOfBoundsException if i is outside the (0..countParts()-1) range
*/
public Part.Type getPartType(int i) {
return parts.get(i).type;
}
/**
* Returns the pattern index of the specified pattern "part".
* Convenience method for getPart(partIndex).getIndex().
* @param partIndex The index of the Part data. (0..countParts()-1)
* @return The pattern index of this Part.
* @throws IndexOutOfBoundsException if partIndex is outside the (0..countParts()-1) range
*/
public int getPatternIndex(int partIndex) {
return parts.get(partIndex).index;
}
/**
* Returns the substring of the pattern string indicated by the Part.
* Convenience method for getPatternString().substring(part.getIndex(), part.getLimit()).
* @param part a part of this MessagePattern.
* @return the substring associated with part.
*/
public String getSubstring(Part part) {
int index=part.index;
return msg.substring(index, index+part.length);
}
/**
* Compares the part's substring with the input string s.
* @param part a part of this MessagePattern.
* @param s a string.
* @return true if getSubstring(part).equals(s).
*/
public boolean partSubstringMatches(Part part, String s) {
return part.length == s.length() && msg.regionMatches(part.index, s, 0, part.length);
}
/**
* Returns the numeric value associated with an ARG_INT or ARG_DOUBLE.
* @param part a part of this MessagePattern.
* @return the part's numeric value, or NO_NUMERIC_VALUE if this is not a numeric part.
*/
public double getNumericValue(Part part) {
Part.Type type=part.type;
if(type==Part.Type.ARG_INT) {
return part.value;
} else if(type==Part.Type.ARG_DOUBLE) {
return numericValues.get(part.value);
} else {
return NO_NUMERIC_VALUE;
}
}
/**
* Special value that is returned by getNumericValue(Part) when no
* numeric value is defined for a part.
* @see #getNumericValue
*/
public static final double NO_NUMERIC_VALUE=-123456789;
/**
* Returns the "offset:" value of a PluralFormat argument, or 0 if none is specified.
* @param pluralStart the index of the first PluralFormat argument style part. (0..countParts()-1)
* @return the "offset:" value.
* @throws IndexOutOfBoundsException if pluralStart is outside the (0..countParts()-1) range
*/
public double getPluralOffset(int pluralStart) {
Part part=parts.get(pluralStart);
if(part.type.hasNumericValue()) {
return getNumericValue(part);
} else {
return 0;
}
}
/**
* Returns the index of the ARG|MSG_LIMIT part corresponding to the ARG|MSG_START at start.
* @param start The index of some Part data (0..countParts()-1);
* this Part should be of Type ARG_START or MSG_START.
* @return The first i&gt;start where getPart(i).getType()==ARG|MSG_LIMIT at the same nesting level,
* or start itself if getPartType(msgStart)!=ARG|MSG_START.
* @throws IndexOutOfBoundsException if start is outside the (0..countParts()-1) range
*/
public int getLimitPartIndex(int start) {
int limit=parts.get(start).limitPartIndex;
if(limit<start) {
return start;
}
return limit;
}
/**
* A message pattern "part", representing a pattern parsing event.
* There is a part for the start and end of a message or argument,
* for quoting and escaping of and with ASCII apostrophes,
* and for syntax elements of "complex" arguments.
*/
public static final class Part {
private Part(Type t, int i, int l, int v) {
type=t;
index=i;
length=(char)l;
value=(short)v;
}
/**
* Returns the type of this part.
* @return the part type.
*/
public Type getType() {
return type;
}
/**
* Returns the pattern string index associated with this Part.
* @return this part's pattern string index.
*/
public int getIndex() {
return index;
}
/**
* Returns the length of the pattern substring associated with this Part.
* This is 0 for some parts.
* @return this part's pattern substring length.
*/
public int getLength() {
return length;
}
/**
* Returns the pattern string limit (exclusive-end) index associated with this Part.
* Convenience method for getIndex()+getLength().
* @return this part's pattern string limit index, same as getIndex()+getLength().
*/
public int getLimit() {
return index+length;
}
/**
* Returns a value associated with this part.
* See the documentation of each part type for details.
* @return the part value.
*/
public int getValue() {
return value;
}
/**
* Returns the argument type if this part is of type ARG_START or ARG_LIMIT,
* otherwise ArgType.NONE.
* @return the argument type for this part.
*/
public ArgType getArgType() {
Type type=getType();
if(type==Type.ARG_START || type==Type.ARG_LIMIT) {
return argTypes[value];
} else {
return ArgType.NONE;
}
}
/**
* Part type constants.
*/
public enum Type {
/**
* Start of a message pattern (main or nested).
* The length is 0 for the top-level message
* and for a choice argument sub-message, otherwise 1 for the '{'.
* The value indicates the nesting level, starting with 0 for the main message.
* <p>
* There is always a later MSG_LIMIT part.
*/
MSG_START,
/**
* End of a message pattern (main or nested).
* The length is 0 for the top-level message and
* the last sub-message of a choice argument,
* otherwise 1 for the '}' or (in a choice argument style) the '|'.
* The value indicates the nesting level, starting with 0 for the main message.
*/
MSG_LIMIT,
/**
* Indicates a substring of the pattern string which is to be skipped when formatting.
* For example, an apostrophe that begins or ends quoted text
* would be indicated with such a part.
* The value is undefined and currently always 0.
*/
SKIP_SYNTAX,
/**
* Indicates that a syntax character needs to be inserted for auto-quoting.
* The length is 0.
* The value is the character code of the insertion character. (U+0027=APOSTROPHE)
*/
INSERT_CHAR,
/**
* Indicates a syntactic (non-escaped) # symbol in a plural variant.
* When formatting, replace this part's substring with the
* (value-offset) for the plural argument value.
* The value is undefined and currently always 0.
*/
REPLACE_NUMBER,
/**
* Start of an argument.
* The length is 1 for the '{'.
* The value is the ordinal value of the ArgType. Use getArgType().
* <p>
* This part is followed by either an ARG_NUMBER or ARG_NAME,
* followed by optional argument sub-parts (see ArgType constants)
* and finally an ARG_LIMIT part.
*/
ARG_START,
/**
* End of an argument.
* The length is 1 for the '}'.
* The value is the ordinal value of the ArgType. Use getArgType().
*/
ARG_LIMIT,
/**
* The argument number, provided by the value.
*/
ARG_NUMBER,
/**
* The argument name.
* The value is undefined and currently always 0.
*/
ARG_NAME,
/**
* The argument type.
* The value is undefined and currently always 0.
*/
ARG_TYPE,
/**
* The argument style text.
* The value is undefined and currently always 0.
*/
ARG_STYLE,
/**
* A selector substring in a "complex" argument style.
* The value is undefined and currently always 0.
*/
ARG_SELECTOR,
/**
* An integer value, for example the offset or an explicit selector value
* in a PluralFormat style.
* The part value is the integer value.
*/
ARG_INT,
/**
* A numeric value, for example the offset or an explicit selector value
* in a PluralFormat style.
* The part value is an index into an internal array of numeric values;
* use getNumericValue().
*/
ARG_DOUBLE;
/**
* Indicates whether this part has a numeric value.
* If so, then that numeric value can be retrieved via {@link MessagePattern#getNumericValue(Part)}.
* @return true if this part has a numeric value.
*/
public boolean hasNumericValue() {
return this==ARG_INT || this==ARG_DOUBLE;
}
}
/**
* @return a string representation of this part.
*/
@Override
public String toString() {
String valueString=(type==Type.ARG_START || type==Type.ARG_LIMIT) ?
getArgType().name() : Integer.toString(value);
return type.name()+"("+valueString+")@"+index;
}
/**
* @param other another object to compare with.
* @return true if this object is equivalent to the other one.
*/
@Override
public boolean equals(Object other) {
if(this==other) {
return true;
}
if(other==null || getClass()!=other.getClass()) {
return false;
}
Part o=(Part)other;
return
type.equals(o.type) &&
index==o.index &&
length==o.length &&
value==o.value &&
limitPartIndex==o.limitPartIndex;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return ((type.hashCode()*37+index)*37+length)*37+value;
}
private static final int MAX_LENGTH=0xffff;
private static final int MAX_VALUE=Short.MAX_VALUE;
// Some fields are not final because they are modified during pattern parsing.
// After pattern parsing, the parts are effectively immutable.
private final Type type;
private final int index;
private final char length;
private short value;
private int limitPartIndex;
}
/**
* Argument type constants.
* Returned by Part.getArgType() for ARG_START and ARG_LIMIT parts.
*
* Messages nested inside an argument are each delimited by MSG_START and MSG_LIMIT,
* with a nesting level one greater than the surrounding message.
*/
public enum ArgType {
/**
* The argument has no specified type.
*/
NONE,
/**
* The argument has a "simple" type which is provided by the ARG_TYPE part.
* An ARG_STYLE part might follow that.
*/
SIMPLE,
/**
* The argument is a ChoiceFormat with one or more
* ((ARG_INT | ARG_DOUBLE), ARG_SELECTOR, message) tuples.
*/
CHOICE,
/**
* The argument is a cardinal-number PluralFormat with an optional ARG_INT or ARG_DOUBLE offset
* (e.g., offset:1)
* and one or more (ARG_SELECTOR [explicit-value] message) tuples.
* If the selector has an explicit value (e.g., =2), then
* that value is provided by the ARG_INT or ARG_DOUBLE part preceding the message.
* Otherwise the message immediately follows the ARG_SELECTOR.
*/
PLURAL,
/**
* The argument is a SelectFormat with one or more (ARG_SELECTOR, message) pairs.
*/
SELECT,
/**
* The argument is an ordinal-number PluralFormat
* with the same style parts sequence and semantics as {@link ArgType#PLURAL}.
*/
SELECTORDINAL;
/**
* @return true if the argument type has a plural style part sequence and semantics,
* for example {@link ArgType#PLURAL} and {@link ArgType#SELECTORDINAL}.
*/
public boolean hasPluralStyle() {
return this == PLURAL || this == SELECTORDINAL;
}
}
/**
* Creates and returns a copy of this object.
* @return a copy of this object (or itself if frozen).
*/
@Override
public Object clone() {
if(isFrozen()) {
return this;
} else {
return cloneAsThawed();
}
}
/**
* Creates and returns an unfrozen copy of this object.
* @return a copy of this object.
*/
@Override
@SuppressWarnings("unchecked")
public MessagePattern cloneAsThawed() {
MessagePattern newMsg;
try {
newMsg=(MessagePattern)super.clone();
} catch (CloneNotSupportedException e) {
throw new ICUCloneNotSupportedException(e);
}
newMsg.parts=(ArrayList<Part>)parts.clone();
if(numericValues!=null) {
newMsg.numericValues=(ArrayList<Double>)numericValues.clone();
}
newMsg.frozen=false;
return newMsg;
}
/**
* Freezes this object, making it immutable and thread-safe.
* @return this
*/
@Override
public MessagePattern freeze() {
frozen=true;
return this;
}
/**
* Determines whether this object is frozen (immutable) or not.
* @return true if this object is frozen.
*/
@Override
public boolean isFrozen() {
return frozen;
}
private void preParse(String pattern) {
if(isFrozen()) {
throw new UnsupportedOperationException(
"Attempt to parse("+prefix(pattern)+") on frozen MessagePattern instance.");
}
msg=pattern;
hasArgNames=hasArgNumbers=false;
needsAutoQuoting=false;
parts.clear();
if(numericValues!=null) {
numericValues.clear();
}
}
private void postParse() {
// Nothing to be done currently.
}
private int parseMessage(int index, int msgStartLength, int nestingLevel, ArgType parentType) {
if(nestingLevel>Part.MAX_VALUE) {
throw new IndexOutOfBoundsException();
}
int msgStart=parts.size();
addPart(Part.Type.MSG_START, index, msgStartLength, nestingLevel);
index+=msgStartLength;
while(index<msg.length()) {
char c=msg.charAt(index++);
if(c=='\'') {
if(index==msg.length()) {
// The apostrophe is the last character in the pattern.
// Add a Part for auto-quoting.
addPart(Part.Type.INSERT_CHAR, index, 0, '\''); // value=char to be inserted
needsAutoQuoting=true;
} else {
c=msg.charAt(index);
if(c=='\'') {
// double apostrophe, skip the second one
addPart(Part.Type.SKIP_SYNTAX, index++, 1, 0);
} else if(
aposMode==ApostropheMode.DOUBLE_REQUIRED ||
c=='{' || c=='}' ||
(parentType==ArgType.CHOICE && c=='|') ||
(parentType.hasPluralStyle() && c=='#')
) {
// skip the quote-starting apostrophe
addPart(Part.Type.SKIP_SYNTAX, index-1, 1, 0);
// find the end of the quoted literal text
for(;;) {
index=msg.indexOf('\'', index+1);
if(index>=0) {
if((index+1)<msg.length() && msg.charAt(index+1)=='\'') {
// double apostrophe inside quoted literal text
// still encodes a single apostrophe, skip the second one
addPart(Part.Type.SKIP_SYNTAX, ++index, 1, 0);
} else {
// skip the quote-ending apostrophe
addPart(Part.Type.SKIP_SYNTAX, index++, 1, 0);
break;
}
} else {
// The quoted text reaches to the end of the of the message.
index=msg.length();
// Add a Part for auto-quoting.
addPart(Part.Type.INSERT_CHAR, index, 0, '\''); // value=char to be inserted
needsAutoQuoting=true;
break;
}
}
} else {
// Interpret the apostrophe as literal text.
// Add a Part for auto-quoting.
addPart(Part.Type.INSERT_CHAR, index, 0, '\''); // value=char to be inserted
needsAutoQuoting=true;
}
}
} else if(parentType.hasPluralStyle() && c=='#') {
// The unquoted # in a plural message fragment will be replaced
// with the (number-offset).
addPart(Part.Type.REPLACE_NUMBER, index-1, 1, 0);
} else if(c=='{') {
index=parseArg(index-1, 1, nestingLevel);
} else if((nestingLevel>0 && c=='}') || (parentType==ArgType.CHOICE && c=='|')) {
// Finish the message before the terminator.
// In a choice style, report the "}" substring only for the following ARG_LIMIT,
// not for this MSG_LIMIT.
int limitLength=(parentType==ArgType.CHOICE && c=='}') ? 0 : 1;
addLimitPart(msgStart, Part.Type.MSG_LIMIT, index-1, limitLength, nestingLevel);
if(parentType==ArgType.CHOICE) {
// Let the choice style parser see the '}' or '|'.
return index-1;
} else {
// continue parsing after the '}'
return index;
}
} // else: c is part of literal text
}
if(nestingLevel>0 && !inTopLevelChoiceMessage(nestingLevel, parentType)) {
throw new IllegalArgumentException(
"Unmatched '{' braces in message "+prefix());
}
addLimitPart(msgStart, Part.Type.MSG_LIMIT, index, 0, nestingLevel);
return index;
}
private int parseArg(int index, int argStartLength, int nestingLevel) {
int argStart=parts.size();
ArgType argType=ArgType.NONE;
addPart(Part.Type.ARG_START, index, argStartLength, argType.ordinal());
int nameIndex=index=skipWhiteSpace(index+argStartLength);
if(index==msg.length()) {
throw new IllegalArgumentException(
"Unmatched '{' braces in message "+prefix());
}
// parse argument name or number
index=skipIdentifier(index);
int number=parseArgNumber(nameIndex, index);
if(number>=0) {
int length=index-nameIndex;
if(length>Part.MAX_LENGTH || number>Part.MAX_VALUE) {
throw new IndexOutOfBoundsException(
"Argument number too large: "+prefix(nameIndex));
}
hasArgNumbers=true;
addPart(Part.Type.ARG_NUMBER, nameIndex, length, number);
} else if(number==ARG_NAME_NOT_NUMBER) {
int length=index-nameIndex;
if(length>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Argument name too long: "+prefix(nameIndex));
}
hasArgNames=true;
addPart(Part.Type.ARG_NAME, nameIndex, length, 0);
} else { // number<-1 (ARG_NAME_NOT_VALID)
throw new IllegalArgumentException("Bad argument syntax: "+prefix(nameIndex));
}
index=skipWhiteSpace(index);
if(index==msg.length()) {
throw new IllegalArgumentException(
"Unmatched '{' braces in message "+prefix());
}
char c=msg.charAt(index);
if(c=='}') {
// all done
} else if(c!=',') {
throw new IllegalArgumentException("Bad argument syntax: "+prefix(nameIndex));
} else /* ',' */ {
// parse argument type: case-sensitive a-zA-Z
int typeIndex=index=skipWhiteSpace(index+1);
while(index<msg.length() && isArgTypeChar(msg.charAt(index))) {
++index;
}
int length=index-typeIndex;
index=skipWhiteSpace(index);
if(index==msg.length()) {
throw new IllegalArgumentException(
"Unmatched '{' braces in message "+prefix());
}
if(length==0 || ((c=msg.charAt(index))!=',' && c!='}')) {
throw new IllegalArgumentException("Bad argument syntax: "+prefix(nameIndex));
}
if(length>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Argument type name too long: "+prefix(nameIndex));
}
argType=ArgType.SIMPLE;
if(length==6) {
// case-insensitive comparisons for complex-type names
if(isChoice(typeIndex)) {
argType=ArgType.CHOICE;
} else if(isPlural(typeIndex)) {
argType=ArgType.PLURAL;
} else if(isSelect(typeIndex)) {
argType=ArgType.SELECT;
}
} else if(length==13) {
if(isSelect(typeIndex) && isOrdinal(typeIndex+6)) {
argType=ArgType.SELECTORDINAL;
}
}
// change the ARG_START type from NONE to argType
parts.get(argStart).value=(short)argType.ordinal();
if(argType==ArgType.SIMPLE) {
addPart(Part.Type.ARG_TYPE, typeIndex, length, 0);
}
// look for an argument style (pattern)
if(c=='}') {
if(argType!=ArgType.SIMPLE) {
throw new IllegalArgumentException(
"No style field for complex argument: "+prefix(nameIndex));
}
} else /* ',' */ {
++index;
if(argType==ArgType.SIMPLE) {
index=parseSimpleStyle(index);
} else if(argType==ArgType.CHOICE) {
index=parseChoiceStyle(index, nestingLevel);
} else {
index=parsePluralOrSelectStyle(argType, index, nestingLevel);
}
}
}
// Argument parsing stopped on the '}'.
addLimitPart(argStart, Part.Type.ARG_LIMIT, index, 1, argType.ordinal());
return index+1;
}
private int parseSimpleStyle(int index) {
int start=index;
int nestedBraces=0;
while(index<msg.length()) {
char c=msg.charAt(index++);
if(c=='\'') {
// Treat apostrophe as quoting but include it in the style part.
// Find the end of the quoted literal text.
index=msg.indexOf('\'', index);
if(index<0) {
throw new IllegalArgumentException(
"Quoted literal argument style text reaches to the end of the message: "+
prefix(start));
}
// skip the quote-ending apostrophe
++index;
} else if(c=='{') {
++nestedBraces;
} else if(c=='}') {
if(nestedBraces>0) {
--nestedBraces;
} else {
int length=--index-start;
if(length>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Argument style text too long: "+prefix(start));
}
addPart(Part.Type.ARG_STYLE, start, length, 0);
return index;
}
} // c is part of literal text
}
throw new IllegalArgumentException(
"Unmatched '{' braces in message "+prefix());
}
private int parseChoiceStyle(int index, int nestingLevel) {
int start=index;
index=skipWhiteSpace(index);
if(index==msg.length() || msg.charAt(index)=='}') {
throw new IllegalArgumentException(
"Missing choice argument pattern in "+prefix());
}
for(;;) {
// The choice argument style contains |-separated (number, separator, message) triples.
// Parse the number.
int numberIndex=index;
index=skipDouble(index);
int length=index-numberIndex;
if(length==0) {
throw new IllegalArgumentException("Bad choice pattern syntax: "+prefix(start));
}
if(length>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Choice number too long: "+prefix(numberIndex));
}
parseDouble(numberIndex, index, true); // adds ARG_INT or ARG_DOUBLE
// Parse the separator.
index=skipWhiteSpace(index);
if(index==msg.length()) {
throw new IllegalArgumentException("Bad choice pattern syntax: "+prefix(start));
}
char c=msg.charAt(index);
if(!(c=='#' || c=='<' || c=='\u2264')) { // U+2264 is <=
throw new IllegalArgumentException(
"Expected choice separator (#<\u2264) instead of '"+c+
"' in choice pattern "+prefix(start));
}
addPart(Part.Type.ARG_SELECTOR, index, 1, 0);
// Parse the message fragment.
index=parseMessage(++index, 0, nestingLevel+1, ArgType.CHOICE);
// parseMessage(..., CHOICE) returns the index of the terminator, or msg.length().
if(index==msg.length()) {
return index;
}
if(msg.charAt(index)=='}') {
if(!inMessageFormatPattern(nestingLevel)) {
throw new IllegalArgumentException(
"Bad choice pattern syntax: "+prefix(start));
}
return index;
} // else the terminator is '|'
index=skipWhiteSpace(index+1);
}
}
private int parsePluralOrSelectStyle(ArgType argType, int index, int nestingLevel) {
int start=index;
boolean isEmpty=true;
boolean hasOther=false;
for(;;) {
// First, collect the selector looking for a small set of terminators.
// It would be a little faster to consider the syntax of each possible
// token right here, but that makes the code too complicated.
index=skipWhiteSpace(index);
boolean eos=index==msg.length();
if(eos || msg.charAt(index)=='}') {
if(eos==inMessageFormatPattern(nestingLevel)) {
throw new IllegalArgumentException(
"Bad "+
argType.toString().toLowerCase(Locale.ENGLISH)+
" pattern syntax: "+prefix(start));
}
if(!hasOther) {
throw new IllegalArgumentException(
"Missing 'other' keyword in "+
argType.toString().toLowerCase(Locale.ENGLISH)+
" pattern in "+prefix());
}
return index;
}
int selectorIndex=index;
if(argType.hasPluralStyle() && msg.charAt(selectorIndex)=='=') {
// explicit-value plural selector: =double
index=skipDouble(index+1);
int length=index-selectorIndex;
if(length==1) {
throw new IllegalArgumentException(
"Bad "+
argType.toString().toLowerCase(Locale.ENGLISH)+
" pattern syntax: "+prefix(start));
}
if(length>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Argument selector too long: "+prefix(selectorIndex));
}
addPart(Part.Type.ARG_SELECTOR, selectorIndex, length, 0);
parseDouble(selectorIndex+1, index, false); // adds ARG_INT or ARG_DOUBLE
} else {
index=skipIdentifier(index);
int length=index-selectorIndex;
if(length==0) {
throw new IllegalArgumentException(
"Bad "+
argType.toString().toLowerCase(Locale.ENGLISH)+
" pattern syntax: "+prefix(start));
}
// Note: The ':' in "offset:" is just beyond the skipIdentifier() range.
if( argType.hasPluralStyle() && length==6 && index<msg.length() &&
msg.regionMatches(selectorIndex, "offset:", 0, 7)
) {
// plural offset, not a selector
if(!isEmpty) {
throw new IllegalArgumentException(
"Plural argument 'offset:' (if present) must precede key-message pairs: "+
prefix(start));
}
// allow whitespace between offset: and its value
int valueIndex=skipWhiteSpace(index+1); // The ':' is at index.
index=skipDouble(valueIndex);
if(index==valueIndex) {
throw new IllegalArgumentException(
"Missing value for plural 'offset:' "+prefix(start));
}
if((index-valueIndex)>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Plural offset value too long: "+prefix(valueIndex));
}
parseDouble(valueIndex, index, false); // adds ARG_INT or ARG_DOUBLE
isEmpty=false;
continue; // no message fragment after the offset
} else {
// normal selector word
if(length>Part.MAX_LENGTH) {
throw new IndexOutOfBoundsException(
"Argument selector too long: "+prefix(selectorIndex));
}
addPart(Part.Type.ARG_SELECTOR, selectorIndex, length, 0);
if(msg.regionMatches(selectorIndex, "other", 0, length)) {
hasOther=true;
}
}
}
// parse the message fragment following the selector
index=skipWhiteSpace(index);
if(index==msg.length() || msg.charAt(index)!='{') {
throw new IllegalArgumentException(
"No message fragment after "+
argType.toString().toLowerCase(Locale.ENGLISH)+
" selector: "+prefix(selectorIndex));
}
index=parseMessage(index, 1, nestingLevel+1, argType);
isEmpty=false;
}
}
/**
* Validates and parses an argument name or argument number string.
* This internal method assumes that the input substring is a "pattern identifier".
* @return &gt;=0 if the name is a valid number,
* ARG_NAME_NOT_NUMBER (-1) if it is a "pattern identifier" but not all ASCII digits,
* ARG_NAME_NOT_VALID (-2) if it is neither.
* @see #validateArgumentName(String)
*/
private static int parseArgNumber(CharSequence s, int start, int limit) {
// If the identifier contains only ASCII digits, then it is an argument _number_
// and must not have leading zeros (except "0" itself).
// Otherwise it is an argument _name_.
if(start>=limit) {
return ARG_NAME_NOT_VALID;
}
int number;
// Defer numeric errors until we know there are only digits.
boolean badNumber;
char c=s.charAt(start++);
if(c=='0') {
if(start==limit) {
return 0;
} else {
number=0;
badNumber=true; // leading zero
}
} else if('1'<=c && c<='9') {
number=c-'0';
badNumber=false;
} else {
return ARG_NAME_NOT_NUMBER;
}
while(start<limit) {
c=s.charAt(start++);
if('0'<=c && c<='9') {
if(number>=Integer.MAX_VALUE/10) {
badNumber=true; // overflow
}
number=number*10+(c-'0');
} else {
return ARG_NAME_NOT_NUMBER;
}
}
// There are only ASCII digits.
if(badNumber) {
return ARG_NAME_NOT_VALID;
} else {
return number;
}
}
private int parseArgNumber(int start, int limit) {
return parseArgNumber(msg, start, limit);
}
/**
* Parses a number from the specified message substring.
* @param start start index into the message string
* @param limit limit index into the message string, must be start<limit
* @param allowInfinity true if U+221E is allowed (for ChoiceFormat)
*/
private void parseDouble(int start, int limit, boolean allowInfinity) {
assert start<limit;
// fake loop for easy exit and single throw statement
for(;;) {
// fast path for small integers and infinity
int value=0;
int isNegative=0; // not boolean so that we can easily add it to value
int index=start;
char c=msg.charAt(index++);
if(c=='-') {
isNegative=1;
if(index==limit) {
break; // no number
}
c=msg.charAt(index++);
} else if(c=='+') {
if(index==limit) {
break; // no number
}
c=msg.charAt(index++);
}
if(c==0x221e) { // infinity
if(allowInfinity && index==limit) {
addArgDoublePart(
isNegative!=0 ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY,
start, limit-start);
return;
} else {
break;
}
}
// try to parse the number as a small integer but fall back to a double
while('0'<=c && c<='9') {
value=value*10+(c-'0');
if(value>(Part.MAX_VALUE+isNegative)) {
break; // not a small-enough integer
}
if(index==limit) {
addPart(Part.Type.ARG_INT, start, limit-start, isNegative!=0 ? -value : value);
return;
}
c=msg.charAt(index++);
}
// Let Double.parseDouble() throw a NumberFormatException.
double numericValue=Double.parseDouble(msg.substring(start, limit));
addArgDoublePart(numericValue, start, limit-start);
return;
}
throw new NumberFormatException(
"Bad syntax for numeric value: "+msg.substring(start, limit));
}
/**
* Appends the s[start, limit[ substring to sb, but with only half of the apostrophes
* according to JDK pattern behavior.
* @hide draft / provisional / internal are hidden on Android
*/
/* package */ static void appendReducedApostrophes(String s, int start, int limit,
StringBuilder sb) {
int doubleApos=-1;
for(;;) {
int i=s.indexOf('\'', start);
if(i<0 || i>=limit) {
sb.append(s, start, limit);
break;
}
if(i==doubleApos) {
// Double apostrophe at start-1 and start==i, append one.
sb.append('\'');
++start;
doubleApos=-1;
} else {
// Append text between apostrophes and skip this one.
sb.append(s, start, i);
doubleApos=start=i+1;
}
}
}
private int skipWhiteSpace(int index) {
return PatternProps.skipWhiteSpace(msg, index);
}
private int skipIdentifier(int index) {
return PatternProps.skipIdentifier(msg, index);
}
/**
* Skips a sequence of characters that could occur in a double value.
* Does not fully parse or validate the value.
*/
private int skipDouble(int index) {
while(index<msg.length()) {
char c=msg.charAt(index);
// U+221E: Allow the infinity symbol, for ChoiceFormat patterns.
if((c<'0' && "+-.".indexOf(c)<0) || (c>'9' && c!='e' && c!='E' && c!=0x221e)) {
break;
}
++index;
}
return index;
}
private static boolean isArgTypeChar(int c) {
return ('a'<=c && c<='z') || ('A'<=c && c<='Z');
}
private boolean isChoice(int index) {
char c;
return
((c=msg.charAt(index++))=='c' || c=='C') &&
((c=msg.charAt(index++))=='h' || c=='H') &&
((c=msg.charAt(index++))=='o' || c=='O') &&
((c=msg.charAt(index++))=='i' || c=='I') &&
((c=msg.charAt(index++))=='c' || c=='C') &&
((c=msg.charAt(index))=='e' || c=='E');
}
private boolean isPlural(int index) {
char c;
return
((c=msg.charAt(index++))=='p' || c=='P') &&
((c=msg.charAt(index++))=='l' || c=='L') &&
((c=msg.charAt(index++))=='u' || c=='U') &&
((c=msg.charAt(index++))=='r' || c=='R') &&
((c=msg.charAt(index++))=='a' || c=='A') &&
((c=msg.charAt(index))=='l' || c=='L');
}
private boolean isSelect(int index) {
char c;
return
((c=msg.charAt(index++))=='s' || c=='S') &&
((c=msg.charAt(index++))=='e' || c=='E') &&
((c=msg.charAt(index++))=='l' || c=='L') &&
((c=msg.charAt(index++))=='e' || c=='E') &&
((c=msg.charAt(index++))=='c' || c=='C') &&
((c=msg.charAt(index))=='t' || c=='T');
}
private boolean isOrdinal(int index) {
char c;
return
((c=msg.charAt(index++))=='o' || c=='O') &&
((c=msg.charAt(index++))=='r' || c=='R') &&
((c=msg.charAt(index++))=='d' || c=='D') &&
((c=msg.charAt(index++))=='i' || c=='I') &&
((c=msg.charAt(index++))=='n' || c=='N') &&
((c=msg.charAt(index++))=='a' || c=='A') &&
((c=msg.charAt(index))=='l' || c=='L');
}
/**
* @return true if we are inside a MessageFormat (sub-)pattern,
* as opposed to inside a top-level choice/plural/select pattern.
*/
private boolean inMessageFormatPattern(int nestingLevel) {
return nestingLevel>0 || parts.get(0).type==Part.Type.MSG_START;
}
/**
* @return true if we are in a MessageFormat sub-pattern
* of a top-level ChoiceFormat pattern.
*/
private boolean inTopLevelChoiceMessage(int nestingLevel, ArgType parentType) {
return
nestingLevel==1 &&
parentType==ArgType.CHOICE &&
parts.get(0).type!=Part.Type.MSG_START;
}
private void addPart(Part.Type type, int index, int length, int value) {
parts.add(new Part(type, index, length, value));
}
private void addLimitPart(int start, Part.Type type, int index, int length, int value) {
parts.get(start).limitPartIndex=parts.size();
addPart(type, index, length, value);
}
private void addArgDoublePart(double numericValue, int start, int length) {
int numericIndex;
if(numericValues==null) {
numericValues=new ArrayList<Double>();
numericIndex=0;
} else {
numericIndex=numericValues.size();
if(numericIndex>Part.MAX_VALUE) {
throw new IndexOutOfBoundsException("Too many numeric values");
}
}
numericValues.add(numericValue);
addPart(Part.Type.ARG_DOUBLE, start, length, numericIndex);
}
private static final int MAX_PREFIX_LENGTH=24;
/**
* Returns a prefix of s.substring(start). Used for Exception messages.
* @param s
* @param start start index in s
* @return s.substring(start) or a prefix of that
*/
private static String prefix(String s, int start) {
StringBuilder prefix=new StringBuilder(MAX_PREFIX_LENGTH+20);
if(start==0) {
prefix.append("\"");
} else {
prefix.append("[at pattern index ").append(start).append("] \"");
}
int substringLength=s.length()-start;
if(substringLength<=MAX_PREFIX_LENGTH) {
prefix.append(start==0 ? s : s.substring(start));
} else {
int limit=start+MAX_PREFIX_LENGTH-4;
if(Character.isHighSurrogate(s.charAt(limit-1))) {
// remove lead surrogate from the end of the prefix
--limit;
}
prefix.append(s, start, limit).append(" ...");
}
return prefix.append("\"").toString();
}
private static String prefix(String s) {
return prefix(s, 0);
}
private String prefix(int start) {
return prefix(msg, start);
}
private String prefix() {
return prefix(msg, 0);
}
private ApostropheMode aposMode;
private String msg;
private ArrayList<Part> parts=new ArrayList<Part>();
private ArrayList<Double> numericValues;
private boolean hasArgNames;
private boolean hasArgNumbers;
private boolean needsAutoQuoting;
private volatile boolean frozen;
private static final ApostropheMode defaultAposMode=
ApostropheMode.valueOf(
ICUConfig.get("android.icu.text.MessagePattern.ApostropheMode", "DOUBLE_OPTIONAL"));
private static final ArgType[] argTypes=ArgType.values();
}
Reference in New Issue Copy Permalink