wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-25 01:47:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1971 - Part 2: Update ICU source to 63.2.

Browse source
This commit is contained in:
Job Bautista 2022-07-24 21:03:27 +08:00 • committed by roytam1
commit 1e69214382
3160 changed files with 275815 additions and 234203 deletions
Download patch file Download diff file Expand all files Collapse all files

299
intl/icu/source/i18n/unicode/translit.h
View file

@ -1,4 +1,4 @@
// Copyright (C) 2016 and later: Unicode, Inc. and others.
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
@ -15,10 +15,10 @@
#include "unicode/utypes.h"
/**
* \file
* \file
* \brief C++ API: Tranforms text from one format to another.
*/
#if !UCONFIG_NO_TRANSLITERATION
#include "unicode/uobject.h"
@ -31,7 +31,6 @@ U_NAMESPACE_BEGIN
class UnicodeFilter;
class UnicodeSet;
class CompoundTransliterator;
class TransliteratorParser;
class NormalizationTransliterator;
class TransliteratorIDParser;
@ -77,8 +76,7 @@ class TransliteratorIDParser;
* transliteration. For example, given a string <code>input</code>
* and a transliterator <code>t</code>, the call
*
* \htmlonly<blockquote>\endhtmlonly<code>String result = t.transliterate(input);
* </code>\htmlonly</blockquote>\endhtmlonly
* String result = t.transliterate(input);
*
* will transliterate it and return the result. Other methods allow
* the client to specify a substring to be transliterated and to use
@ -98,22 +96,20 @@ class TransliteratorIDParser;
* contents of the buffer may show text being modified as each new
* character arrives.
*
* <p>Consider the simple <code>RuleBasedTransliterator</code>:
*
* \htmlonly<blockquote>\endhtmlonly<code>
* th&gt;{theta}<br>
* t&gt;{tau}
* </code>\htmlonly</blockquote>\endhtmlonly
* <p>Consider the simple rule-based Transliterator:
* <pre>
* th>{theta}
* t>{tau}
* </pre>
*
* When the user types 't', nothing will happen, since the
* transliterator is waiting to see if the next character is 'h'. To
* remedy this, we introduce the notion of a cursor, marked by a '|'
* in the output string:
*
* \htmlonly<blockquote>\endhtmlonly<code>
* t&gt;|{tau}<br>
* {tau}h&gt;{theta}
* </code>\htmlonly</blockquote>\endhtmlonly
* <pre>
* t>|{tau}
* {tau}h>{theta}
* </pre>
*
* Now when the user types 't', tau appears, and if the next character
* is 'h', the tau changes to a theta. This is accomplished by
@ -135,7 +131,7 @@ class TransliteratorIDParser;
* which the transliterator last stopped, either because it reached
* the end, or because it required more characters to disambiguate
* between possible inputs. The <code>CURSOR</code> can also be
* explicitly set by rules in a <code>RuleBasedTransliterator</code>.
* explicitly set by rules in a rule-based Transliterator.
* Any characters before the <code>CURSOR</code> index are frozen;
* future keyboard transliteration calls within this input sequence
* will not change them. New text is inserted at the
@ -237,6 +233,255 @@ class TransliteratorIDParser;
* if the performance of these methods can be improved over the
* performance obtained by the default implementations in this class.
*
* <p><b>Rule syntax</b>
*
* <p>A set of rules determines how to perform translations.
* Rules within a rule set are separated by semicolons (';').
* To include a literal semicolon, prefix it with a backslash ('\').
* Unicode Pattern_White_Space is ignored.
* If the first non-blank character on a line is '#',
* the entire line is ignored as a comment.
*
* <p>Each set of rules consists of two groups, one forward, and one
* reverse. This is a convention that is not enforced; rules for one
* direction may be omitted, with the result that translations in
* that direction will not modify the source text. In addition,
* bidirectional forward-reverse rules may be specified for
* symmetrical transformations.
*
* <p>Note: Another description of the Transliterator rule syntax is available in
* <a href="https://www.unicode.org/reports/tr35/tr35-general.html#Transform_Rules_Syntax">section
* Transform Rules Syntax of UTS #35: Unicode LDML</a>.
* The rules are shown there using arrow symbols ← and → and ↔.
* ICU supports both those and the equivalent ASCII symbols &lt; and &gt; and &lt;&gt;.
*
* <p>Rule statements take one of the following forms:
*
* <dl>
* <dt><code>$alefmadda=\\u0622;</code></dt>
* <dd><strong>Variable definition.</strong> The name on the
* left is assigned the text on the right. In this example,
* after this statement, instances of the left hand name,
* &quot;<code>$alefmadda</code>&quot;, will be replaced by
* the Unicode character U+0622. Variable names must begin
* with a letter and consist only of letters, digits, and
* underscores. Case is significant. Duplicate names cause
* an exception to be thrown, that is, variables cannot be
* redefined. The right hand side may contain well-formed
* text of any length, including no text at all (&quot;<code>$empty=;</code>&quot;).
* The right hand side may contain embedded <code>UnicodeSet</code>
* patterns, for example, &quot;<code>$softvowel=[eiyEIY]</code>&quot;.</dd>
* <dt><code>ai&gt;$alefmadda;</code></dt>
* <dd><strong>Forward translation rule.</strong> This rule
* states that the string on the left will be changed to the
* string on the right when performing forward
* transliteration.</dd>
* <dt><code>ai&lt;$alefmadda;</code></dt>
* <dd><strong>Reverse translation rule.</strong> This rule
* states that the string on the right will be changed to
* the string on the left when performing reverse
* transliteration.</dd>
* </dl>
*
* <dl>
* <dt><code>ai&lt;&gt;$alefmadda;</code></dt>
* <dd><strong>Bidirectional translation rule.</strong> This
* rule states that the string on the right will be changed
* to the string on the left when performing forward
* transliteration, and vice versa when performing reverse
* transliteration.</dd>
* </dl>
*
* <p>Translation rules consist of a <em>match pattern</em> and an <em>output
* string</em>. The match pattern consists of literal characters,
* optionally preceded by context, and optionally followed by
* context. Context characters, like literal pattern characters,
* must be matched in the text being transliterated. However, unlike
* literal pattern characters, they are not replaced by the output
* text. For example, the pattern &quot;<code>abc{def}</code>&quot;
* indicates the characters &quot;<code>def</code>&quot; must be
* preceded by &quot;<code>abc</code>&quot; for a successful match.
* If there is a successful match, &quot;<code>def</code>&quot; will
* be replaced, but not &quot;<code>abc</code>&quot;. The final '<code>}</code>'
* is optional, so &quot;<code>abc{def</code>&quot; is equivalent to
* &quot;<code>abc{def}</code>&quot;. Another example is &quot;<code>{123}456</code>&quot;
* (or &quot;<code>123}456</code>&quot;) in which the literal
* pattern &quot;<code>123</code>&quot; must be followed by &quot;<code>456</code>&quot;.
*
* <p>The output string of a forward or reverse rule consists of
* characters to replace the literal pattern characters. If the
* output string contains the character '<code>|</code>', this is
* taken to indicate the location of the <em>cursor</em> after
* replacement. The cursor is the point in the text at which the
* next replacement, if any, will be applied. The cursor is usually
* placed within the replacement text; however, it can actually be
* placed into the precending or following context by using the
* special character '@'. Examples:
*
* <pre>
* a {foo} z &gt; | @ bar; # foo -&gt; bar, move cursor before a
* {foo} xyz &gt; bar @@|; #&nbsp;foo -&gt; bar, cursor between y and z
* </pre>
*
* <p><b>UnicodeSet</b>
*
* <p><code>UnicodeSet</code> patterns may appear anywhere that
* makes sense. They may appear in variable definitions.
* Contrariwise, <code>UnicodeSet</code> patterns may themselves
* contain variable references, such as &quot;<code>$a=[a-z];$not_a=[^$a]</code>&quot;,
* or &quot;<code>$range=a-z;$ll=[$range]</code>&quot;.
*
* <p><code>UnicodeSet</code> patterns may also be embedded directly
* into rule strings. Thus, the following two rules are equivalent:
*
* <pre>
* $vowel=[aeiou]; $vowel&gt;'*'; # One way to do this
* [aeiou]&gt;'*'; # Another way
* </pre>
*
* <p>See {@link UnicodeSet} for more documentation and examples.
*
* <p><b>Segments</b>
*
* <p>Segments of the input string can be matched and copied to the
* output string. This makes certain sets of rules simpler and more
* general, and makes reordering possible. For example:
*
* <pre>
* ([a-z]) &gt; $1 $1; # double lowercase letters
* ([:Lu:]) ([:Ll:]) &gt; $2 $1; # reverse order of Lu-Ll pairs
* </pre>
*
* <p>The segment of the input string to be copied is delimited by
* &quot;<code>(</code>&quot; and &quot;<code>)</code>&quot;. Up to
* nine segments may be defined. Segments may not overlap. In the
* output string, &quot;<code>$1</code>&quot; through &quot;<code>$9</code>&quot;
* represent the input string segments, in left-to-right order of
* definition.
*
* <p><b>Anchors</b>
*
* <p>Patterns can be anchored to the beginning or the end of the text. This is done with the
* special characters '<code>^</code>' and '<code>$</code>'. For example:
*
* <pre>
* ^ a&nbsp;&nbsp; &gt; 'BEG_A'; &nbsp;&nbsp;# match 'a' at start of text
* &nbsp; a&nbsp;&nbsp; &gt; 'A'; # match other instances of 'a'
* &nbsp; z $ &gt; 'END_Z'; &nbsp;&nbsp;# match 'z' at end of text
* &nbsp; z&nbsp;&nbsp; &gt; 'Z';&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; # match other instances of 'z'
* </pre>
*
* <p>It is also possible to match the beginning or the end of the text using a <code>UnicodeSet</code>.
* This is done by including a virtual anchor character '<code>$</code>' at the end of the
* set pattern. Although this is usually the match chafacter for the end anchor, the set will
* match either the beginning or the end of the text, depending on its placement. For
* example:
*
* <pre>
* $x = [a-z$]; &nbsp;&nbsp;# match 'a' through 'z' OR anchor
* $x 1&nbsp;&nbsp;&nbsp; &gt; 2;&nbsp;&nbsp; # match '1' after a-z or at the start
* &nbsp;&nbsp; 3 $x &gt; 4; &nbsp;&nbsp;# match '3' before a-z or at the end
* </pre>
*
* <p><b>Example</b>
*
* <p>The following example rules illustrate many of the features of
* the rule language.
*
* <table border="0" cellpadding="4">
* <tr>
* <td style="vertical-align: top;">Rule 1.</td>
* <td style="vertical-align: top; write-space: nowrap;"><code>abc{def}&gt;x|y</code></td>
* </tr>
* <tr>
* <td style="vertical-align: top;">Rule 2.</td>
* <td style="vertical-align: top; write-space: nowrap;"><code>xyz&gt;r</code></td>
* </tr>
* <tr>
* <td style="vertical-align: top;">Rule 3.</td>
* <td style="vertical-align: top; write-space: nowrap;"><code>yz&gt;q</code></td>
* </tr>
* </table>
*
* <p>Applying these rules to the string &quot;<code>adefabcdefz</code>&quot;
* yields the following results:
*
* <table border="0" cellpadding="4">
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>|adefabcdefz</code></td>
* <td style="vertical-align: top;">Initial state, no rules match. Advance
* cursor.</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>a|defabcdefz</code></td>
* <td style="vertical-align: top;">Still no match. Rule 1 does not match
* because the preceding context is not present.</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>ad|efabcdefz</code></td>
* <td style="vertical-align: top;">Still no match. Keep advancing until
* there is a match...</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>ade|fabcdefz</code></td>
* <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>adef|abcdefz</code></td>
* <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>adefa|bcdefz</code></td>
* <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>adefab|cdefz</code></td>
* <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>adefabc|defz</code></td>
* <td style="vertical-align: top;">Rule 1 matches; replace &quot;<code>def</code>&quot;
* with &quot;<code>xy</code>&quot; and back up the cursor
* to before the '<code>y</code>'.</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>adefabcx|yz</code></td>
* <td style="vertical-align: top;">Although &quot;<code>xyz</code>&quot; is
* present, rule 2 does not match because the cursor is
* before the '<code>y</code>', not before the '<code>x</code>'.
* Rule 3 does match. Replace &quot;<code>yz</code>&quot;
* with &quot;<code>q</code>&quot;.</td>
* </tr>
* <tr>
* <td style="vertical-align: top; write-space: nowrap;"><code>adefabcxq|</code></td>
* <td style="vertical-align: top;">The cursor is at the end;
* transliteration is complete.</td>
* </tr>
* </table>
*
* <p>The order of rules is significant. If multiple rules may match
* at some point, the first matching rule is applied.
*
* <p>Forward and reverse rules may have an empty output string.
* Otherwise, an empty left or right hand side of any statement is a
* syntax error.
*
* <p>Single quotes are used to quote any character other than a
* digit or letter. To specify a single quote itself, inside or
* outside of quotes, use two single quotes in a row. For example,
* the rule &quot;<code>'&gt;'&gt;o''clock</code>&quot; changes the
* string &quot;<code>&gt;</code>&quot; to the string &quot;<code>o'clock</code>&quot;.
*
* <p><b>Notes</b>
*
* <p>While a Transliterator is being built from rules, it checks that
* the rules are added in proper order. For example, if the rule
* &quot;a&gt;x&quot; is followed by the rule &quot;ab&gt;y&quot;,
* then the second rule will throw an exception. The reason is that
* the second rule can never be triggered, since the first rule
* always matches anything it matches. In other words, the first
* rule <em>masks</em> the second rule.
*
* @author Alan Liu
* @stable ICU 2.0
*/
@ -499,9 +744,9 @@ public:
* for details.
* @param text the buffer holding transliterated and
* untransliterated text
* @param index an array of three integers. See {@link #transliterate(Replaceable&, UTransPosition&, const UnicodeString*, UErrorCode&) const }.
* @param index an array of three integers.
* @param status Output param to filled in with a success or an error.
* @see #transliterate(Replaceable, int[], String)
* @see #transliterate(Replaceable&, UTransPosition&, const UnicodeString&, UErrorCode &) const
* @stable ICU 2.0
*/
virtual void transliterate(Replaceable& text, UTransPosition& index,
@ -632,7 +877,7 @@ public:
/**
* Transliterate a substring of text, as specified by index, taking filters
* into account. This method is for subclasses that need to delegate to
* another transliterator, such as CompoundTransliterator.
* another transliterator.
* @param text the text to be transliterated
* @param index the position indices
* @param incremental if TRUE, then assume more characters may be inserted
@ -846,17 +1091,19 @@ public:
/**
* Returns a <code>Transliterator</code> object constructed from
* the given rule string. This will be a RuleBasedTransliterator,
* the given rule string. This will be a rule-based Transliterator,
* if the rule string contains only rules, or a
* CompoundTransliterator, if it contains ID blocks, or a
* NullTransliterator, if it contains ID blocks which parse as
* compound Transliterator, if it contains ID blocks, or a
* null Transliterator, if it contains ID blocks which parse as
* empty for the given direction.
*
* @param ID the id for the transliterator.
* @param rules rules, separated by ';'
* @param dir either FORWARD or REVERSE.
* @param parseError Struct to recieve information on position
* @param parseError Struct to receive information on position
* of error if an error is encountered
* @param status Output param set to success/failure code.
* @return a newly created Transliterator
* @stable ICU 2.0
*/
static Transliterator* U_EXPORT2 createFromRules(const UnicodeString& ID,
@ -1319,7 +1566,7 @@ inline int32_t Transliterator::getMaximumContextLength(void) const {
inline void Transliterator::setID(const UnicodeString& id) {
ID = id;
// NUL-terminate the ID string, which is a non-aliased copy.
ID.append((UChar)0);
ID.append((char16_t)0);
ID.truncate(ID.length()-1);
}