| /** |
| ******************************************************************************* |
| * Copyright (C) 1996-2001, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| * |
| * $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/GenerateLineBreakTest.java,v $ |
| * $Date: 2004/04/17 18:21:39 $ |
| * $Revision: 1.5 $ |
| * |
| ******************************************************************************* |
| */ |
| |
| package com.ibm.text.UCD; |
| |
| import java.util.*; |
| import java.io.*; |
| |
| import com.ibm.text.utility.*; |
| import com.ibm.icu.text.UTF16; |
| import com.ibm.icu.text.UnicodeSet; |
| |
| public class GenerateLineBreakTest implements UCD_Types { |
| |
| // COMMON STUFF for Hangul |
| static final byte hNot = -1, hL = 0, hV = 1, hT = 2, hLV = 3, hLVT = 4, hLIMIT = 5; |
| static final String[] hNames = {"L", "V", "T", "LV", "LVT"}; |
| |
| static byte getHangulType(int cp) { |
| if (Default.ucd().isLeadingJamo(cp)) return hL; |
| if (Default.ucd().isVowelJamo(cp)) return hV; |
| if (Default.ucd().isTrailingJamo(cp)) return hT; |
| if (Default.ucd().isHangulSyllable(cp)) { |
| if (Default.ucd().isDoubleHangul(cp)) return hLV; |
| return hLVT; |
| } |
| return hNot; |
| } |
| |
| //============================ |
| |
| protected String rule; |
| protected String fileName = "Line"; |
| |
| // all the other items are supplied in UCD_TYPES |
| static byte LB_L = LB_LIMIT + hL, LB_V = LB_LIMIT + hV, LB_T = LB_LIMIT + hT, |
| LB_LV = LB_LIMIT + hLV, LB_LVT = LB_LIMIT + hLVT, LB_SUP = LB_LIMIT + hLIMIT, |
| LB2_LIMIT = (byte)(LB_SUP + 1); |
| |
| String[] samples = new String[100]; |
| |
| |
| byte[] TypeOrder = { |
| LB_OP, LB_CL, LB_QU, LB_GL, LB_NS, LB_EX, LB_SY, LB_IS, LB_PR, LB_PO, |
| LB_NU, LB_AL, LB_ID, LB_IN, LB_HY, LB_BA, LB_BB, LB_B2, LB_ZW, LB_CM, |
| // missing from Pair Table |
| LB_SP, LB_BK, LB_CR, LB_LF, |
| // resolved types below |
| LB_CB, LB_AI, LB_SA, LB_SG, LB_XX, |
| // 3 JAMO CLASSES, plus supplementary |
| LB_L, LB_V, LB_T, LB_LV, LB_LVT, LB_SUP |
| }; |
| |
| public static void main(String[] args) throws IOException { |
| |
| new GenerateLineBreakTest().run(); |
| |
| new GenerateWordBreakTest().run(); |
| } |
| |
| // stuff that subclasses need to override |
| public void run() throws IOException { |
| findSamples(); |
| |
| // test individual cases |
| //printLine(out, samples[LB_ZW], "", samples[LB_CL]); |
| //printLine(out, samples[LB_ZW], " ", samples[LB_CL]); |
| |
| PrintWriter out = Utility.openPrintWriter(fileName + "BreakTest.html", Utility.UTF8_WINDOWS); |
| out.println("<html><head><meta http-equiv='Content-Type' content='text/html; charset=utf-8'><title>" |
| + fileName + "</title></head>"); |
| out.println("<body bgcolor='#FFFFFF'><h3>Current (fixed only for consistency):</h3>"); |
| |
| |
| |
| generateTable(out, false); |
| out.println("<h3>Recommended:</h3>"); |
| generateTable(out, true); |
| out.println("</body></html>"); |
| out.close(); |
| |
| String[] testCase = new String[50]; |
| // do main test |
| |
| for (int k = 0; k < 2; ++k) { |
| out = Utility.openPrintWriter(fileName + (k == 0 ? "Test_SHORT.txt" : "Test.txt"), Utility.LATIN1_WINDOWS); |
| int counter = 0; |
| |
| out.println("# Default " + fileName + " Break Test"); |
| out.println("# Generated: " + Default.getDate() + ", MED"); |
| out.println("#"); |
| out.println("# Format:"); |
| out.println("# <string> (# <comment>)? "); |
| out.println("# <string> contains hex Unicode code points, with "); |
| out.println("#\t" + BREAK + " wherever there is a break opportunity, and "); |
| out.println("#\t" + NOBREAK + " wherever there is not."); |
| out.println("# <comment> the format can change, but currently it shows:"); |
| out.println("#\t- the sample character name"); |
| out.println("#\t- (x) the line_break property* for the sample character"); |
| out.println("#\t- [x] the rule that determines whether there is a break or not"); |
| out.println("#"); |
| out.println("# Samples:"); |
| out.println("# The test currently takes all pairs of linebreak types*,"); |
| out.println("# picks a sample for each type, and generates three strings: "); |
| out.println("#\t- the pair alone"); |
| out.println("#\t- the pair alone with an imbeded space"); |
| out.println("#\t- the pair alone with embedded combining marks"); |
| out.println("# The sample for each type is simply the first code point (above NULL)"); |
| out.println("# with that property."); |
| out.println("# * Note:"); |
| out.println("#\t- SG is omitted"); |
| out.println("#\t- 3 different Jamo characters and a supplementary character are added"); |
| out.println("#\t The syllable types for the Jamo (L, V, T) are displayed in comments"); |
| out.println("#\t instead of the linebreak property"); |
| out.println("# These samples may be extended in the future."); |
| out.println("#"); |
| |
| for (int ii = 0; ii < getLimit(); ++ii) { |
| int i = TypeOrder[ii]; |
| if (i == LB_SG) continue; |
| String before = samples[i]; |
| |
| for (int jj = 0; jj < getLimit(); ++jj) { |
| Utility.dot(counter); |
| int j = TypeOrder[jj]; |
| if (j == LB_SG) continue; |
| String after = samples[j]; |
| // do line straight |
| int len = genTestItems(before, after, testCase); |
| for (int q = 0; q < len; ++q) { |
| printLine(out, testCase[q], k != 0 && q == 0, false); |
| ++counter; |
| } |
| } |
| } |
| out.println("# Lines: " + counter); |
| out.close(); |
| } |
| } |
| |
| // stuff that subclasses need to override |
| public int genTestItems(String before, String after, String[] results) { |
| results[0] = before + after; |
| results[1] = before + " " + after; |
| results[2] = before + "\u0301\u0308" + after; |
| return 3; |
| } |
| |
| // stuff that subclasses need to override |
| boolean skipType(byte type) { |
| return type == LB_AI || type == LB_SA || type == LB_SG || type == LB_XX; |
| } |
| |
| // stuff that subclasses need to override |
| public String getTypeID(int cp) { |
| byte result = getType(cp); |
| if (result == LB_SUP) return "SUP"; |
| if (result >= LB_LIMIT) return hNames[result - LB_LIMIT]; |
| return Default.ucd().getLineBreakID_fromIndex(result); |
| } |
| |
| // stuff that subclasses need to override |
| public byte getType(int cp) { |
| if (cp > 0xFFFF) return LB_SUP; |
| byte result = getHangulType(cp); |
| if (result != hNot) return (byte)(result + LB_LIMIT); |
| return Default.ucd().getLineBreak(cp); |
| } |
| |
| public int getLimit() { |
| return LB2_LIMIT; |
| } |
| |
| public int getTableLimit() { |
| return LB_SUP; // skip last; |
| } |
| |
| |
| public void generateTable(PrintWriter out, boolean recommended) { |
| String width = "width='" + (100 / (getTableLimit() + 1)) + "%'"; |
| out.print("<table border='1' cellspacing='0'><tr><th " + width + "></th>"); |
| byte type; |
| for (int i = 0; i < getTableLimit(); ++i) { |
| type = TypeOrder[i]; |
| if (skipType(type)) continue; |
| |
| String h = getTypeID(samples[TypeOrder[i]]); |
| out.print("<th " + width + ">" + h + "</th>"); |
| } |
| out.print("</tr>"); |
| String[] rule = new String[1]; |
| String[] rule2 = new String[1]; |
| for (int i = 0; i < getTableLimit(); ++i) { |
| type = TypeOrder[i]; |
| if (skipType(type)) continue; |
| |
| String before = samples[type]; |
| String line = "<tr><th>" + getTypeID(before) + "</th>"; |
| for (int j = 0; j < getTableLimit(); ++j) { |
| type = TypeOrder[j]; |
| if (skipType(type)) continue; |
| |
| String after = samples[type]; |
| String t = getTableEntry(before, after, recommended, rule); |
| String background = ""; |
| String t2 = getTableEntry(before, after, !recommended, rule2); |
| if (!t.equals(t2)) { |
| if (t.equals(NOBREAK)) { |
| background = " bgcolor='#CCFFFF'"; |
| } else { |
| background = " bgcolor='#FFFF00'"; |
| } |
| } else if (t.equals(NOBREAK)) { |
| background = " bgcolor='#CCCCFF'"; |
| } |
| line += "<th title='" + rule[0] + "'" + background + ">" + t + "</th>"; |
| } |
| out.println(line + "</tr>"); |
| } |
| out.println("</table>"); |
| } |
| |
| public String getTableEntry(String before, String after, boolean recommended, String[] ruleOut) { |
| String t = "_"; |
| boolean spaceBreak = isBreak(before + " " + after, before.length() + 1, recommended); |
| String spaceRule = rule; |
| |
| boolean spaceBreak2 = isBreak(before + " " + after, before.length(), recommended); |
| String spaceRule2 = rule; |
| |
| boolean normalBreak = isBreak(before + after, before.length(), recommended); |
| String normalRule = rule; |
| |
| if (!normalBreak) { |
| if (!spaceBreak && !spaceBreak2) { |
| t = "^"; |
| rule = spaceRule.equals(normalRule) ? normalRule : spaceRule + "/" + normalRule; |
| if (!spaceRule2.equals(normalRule) && !spaceRule2.equals(spaceRule)) { |
| rule += "/" + spaceRule2; |
| } |
| } else { |
| t = "%"; |
| rule = normalRule; |
| } |
| } |
| ruleOut[0] = rule; |
| return t; |
| } |
| |
| static final String BREAK = "\u00F7"; |
| static final String NOBREAK = "\u00D7"; |
| |
| public void printLine(PrintWriter out, String source, boolean comments, boolean recommended) { |
| int cp; |
| StringBuffer string = new StringBuffer(); |
| StringBuffer comment = new StringBuffer("\t# "); |
| String status = isBreak(source, 0, recommended) ? BREAK : NOBREAK; |
| string.append(status); |
| comment.append(' ').append(status).append(" [").append(rule).append(']'); |
| |
| for (int offset = 0; offset < source.length(); offset += UTF16.getCharCount(cp)) { |
| |
| cp = UTF16.charAt(source, offset); |
| if (string.length() > 0) { |
| string.append(' '); |
| comment.append(' '); |
| } |
| |
| string.append(Utility.hex(cp)); |
| comment.append(Default.ucd().getName(cp) + " (" + getTypeID(cp) + ")"); |
| |
| status = isBreak(source, offset + UTF16.getCharCount(cp), recommended) ? BREAK : NOBREAK; |
| string.append(' ').append(status); |
| comment.append(' ').append(status).append(" [").append(rule).append(']'); |
| } |
| |
| if (comments) string.append(comment); |
| out.println(string); |
| } |
| |
| public void findSamples() { |
| for (int i = 1; i <= 0x10FFFF; ++i) { |
| if (!Default.ucd().isAllocated(i)) continue; |
| if (0xD800 <= i && i <= 0xDFFF) continue; |
| if(i == 0x1100) { |
| System.out.print("here"); |
| } |
| byte lb = getType(i); |
| if (samples[lb] == null) { |
| samples[lb] = UTF16.valueOf(i); |
| } |
| } |
| for (int i = 0; i < TypeOrder.length; ++i) { |
| String sample = samples[i]; |
| System.out.println(getTypeID(sample) + ":\t" + Default.ucd().getCodeAndName(sample)); |
| } |
| } |
| |
| |
| public String getTypeID(String s) { |
| if (s == null) return "<null>"; |
| if (s.length() == 1) return getTypeID(s.charAt(0)); |
| StringBuffer result = new StringBuffer(); |
| int cp; |
| for (int i = 0; i < s.length(); i += UTF32.count16(cp)) { |
| cp = UTF32.char32At(s, i); |
| if (i > 0) result.append(" "); |
| result.append(getTypeID(cp)); |
| } |
| return result.toString(); |
| } |
| |
| public int findLastNon(String source, int offset, byte notLBType, boolean recommended) { |
| int cp; |
| for (int i = offset-1; i >= 0; i -= UTF16.getCharCount(cp)) { |
| cp = UTF16.charAt(source, i); |
| byte f = getResolvedType(cp, recommended); |
| if (f != notLBType) return i; |
| } |
| return -1; |
| } |
| |
| public byte getResolvedType (int cp, boolean recommended) { |
| // LB 1 Assign a line break category to each character of the input. |
| // Resolve AI, CB, SA, SG, XX into other line break classes depending on criteria outside this algorithm. |
| byte result = getType(cp); |
| switch (result) { |
| case LB_AI: result = LB_AI; break; |
| // case LB_CB: result = LB_ID; break; |
| case LB_SA: result = LB_AL; break; |
| // case LB_SG: result = LB_XX; break; Surrogates; will never occur |
| case LB_XX: result = LB_AL; break; |
| } |
| if (recommended) { |
| if (getHangulType(cp) != hNot) { |
| result = LB_ID; |
| } |
| } |
| |
| return result; |
| } |
| |
| public boolean onCodepointBoundary(String s, int offset) { |
| if (offset < 0 || offset > s.length()) return false; |
| if (offset == 0 || offset == s.length()) return true; |
| if (UTF16.isLeadSurrogate(s.charAt(offset-1)) |
| && UTF16.isTrailSurrogate(s.charAt(offset))) return false; |
| return true; |
| } |
| |
| // find out whether there is a break at offset |
| // WARNING: as a side effect, sets "rule" |
| |
| public boolean isBreak(String source, int offset, boolean recommended) { |
| |
| // LB 1 Assign a line break category to each character of the input. |
| // Resolve AI, CB, SA, SG, XX into other line break classes depending on criteria outside this algorithm. |
| // this is taken care of in the getResolvedType function |
| |
| // LB 2a Never break at the start of text |
| |
| rule="2a"; |
| if (offset <= 0) return false; |
| |
| // LB 2b Always break at the end of text |
| |
| rule="2b"; |
| if (offset >= source.length()) return true; |
| |
| |
| // UTF-16: never break in the middle of a code point |
| if (!onCodepointBoundary(source, offset)) return false; |
| |
| |
| // now get the character before and after, and their types |
| |
| |
| int cpBefore = UTF16.charAt(source, offset-1); |
| int cpAfter = UTF16.charAt(source, offset); |
| |
| byte before = getResolvedType(cpBefore, recommended); |
| byte after = getResolvedType(cpAfter, recommended); |
| |
| |
| rule="3a"; |
| // Always break after hard line breaks (but never between CR and LF). |
| // CR ^ LF |
| if (before == LB_CR && after == LB_LF) return false; |
| if (before == LB_BK || before == LB_LF || before == LB_CR) return true; |
| |
| //LB 3b Don’t break before hard line breaks. |
| rule="3b"; |
| if (after == LB_BK || after == LB_LF | after == LB_CR) return false; |
| |
| // LB 4 Don’t break before spaces or zero-width space. |
| // × SP |
| // × ZW |
| |
| rule="4"; |
| if (after == LB_SP || after == LB_ZW) return false; |
| |
| // LB 5 Break after zero-width space. |
| // ZW ÷ |
| rule="5"; |
| if (before == LB_ZW) return true; |
| |
| // LB 6 Don’t break graphemes (before combining marks, around virama or on sequences of conjoining Jamos. |
| rule="6"; |
| if (after == LB_CM) return false; |
| |
| if (before == LB_L && (after == LB_L || after == LB_V || after == LB_LV || after == LB_LVT)) return false; |
| |
| if ((before == LB_LV || before == LB_V) && (after == LB_V || after == LB_T)) return false; |
| |
| if ((before == LB_LVT || before == LB_T) && (after == LB_T)) return false; |
| |
| boolean setBase = false; |
| if (before == LB_CM) { |
| setBase = true; |
| int backOffset = findLastNon(source, offset, LB_CM, recommended); |
| if (backOffset < 0) { |
| before = LB_ID; |
| } else { |
| before = getResolvedType(UTF16.charAt(source, backOffset), recommended); |
| } |
| } |
| |
| // LB 7 In all of the following rules, if a space is the base character for a combining mark, |
| // the space is changed to type ID. In other words, break before SP CM* in the same cases as |
| // one would break before an ID. |
| rule="7"; |
| if (setBase && before == LB_SP) before = LB_ID; |
| |
| // LB 8 Don’t break before ‘]’ or ‘!’ or ‘;’ or ‘/’, even after spaces. |
| // × CL, × EX, × IS, × SY |
| rule="8"; |
| if (after == LB_CL || after == LB_EX || after == LB_SY | after == LB_IS) return false; |
| |
| |
| // find the last non-space character; we will need it |
| byte lastNonSpace = before; |
| if (lastNonSpace == LB_SP) { |
| int backOffset = findLastNon(source, offset, LB_CM, recommended); |
| if (backOffset >= 0) { |
| lastNonSpace = getResolvedType(UTF16.charAt(source, backOffset), recommended); |
| } |
| } |
| |
| // LB 9 Don’t break after ‘[’, even after spaces. |
| // OP SP* × |
| rule="9"; |
| if (lastNonSpace == LB_OP) return false; |
| |
| // LB 10 Don’t break within ‘”[’, , even with intervening spaces. |
| // QU SP* × OP |
| rule="10"; |
| if (lastNonSpace == LB_QU && after == LB_OP) return false; |
| |
| // LB 11 Don’t break within ‘]h’, even with intervening spaces. |
| // CL SP* × NS |
| rule="11"; |
| if (lastNonSpace == LB_CL && after == LB_NS) return false; |
| |
| // LB 11a Don’t break within ‘——’, even with intervening spaces. |
| // B2 × B2 |
| rule="11a"; |
| if (lastNonSpace == LB_B2 && after == LB_B2) return false; |
| |
| |
| if (recommended) { |
| // LB 13 Don’t break before or after NBSP or WORD JOINER |
| // × GL |
| // GL × |
| |
| rule="11b"; |
| if (after == LB_GL || before == LB_GL) return false; |
| } |
| |
| // [Note: by this time, all of the "X" in the table are accounted for. We can safely break after spaces.] |
| |
| rule="12"; |
| // LB 12 Break after spaces |
| // SP ÷ |
| |
| if (before == LB_SP) return true; |
| |
| if (!recommended) { |
| // LB 13 Don’t break before or after NBSP or WORD JOINER |
| // × GL |
| // GL × |
| |
| rule="13"; |
| if (after == LB_GL || before == LB_GL) return false; |
| } |
| |
| rule="14"; |
| // LB 14 Don’t break before or after ‘”’ |
| // × QU |
| // QU × |
| if (before == LB_QU || after == LB_QU) return false; |
| |
| // LB 15 Don’t break before hyphen-minus, other hyphens, fixed-width spaces, |
| // small kana and other non- starters, or after acute accents: |
| // × BA |
| // × HY |
| // × NS |
| // BB × |
| |
| if (recommended) { |
| // LB 14a Break before and after CB |
| // CB ÷ |
| // ÷ CB |
| if (before == LB_CB || after == LB_CB) return true; |
| |
| } |
| |
| rule="15"; |
| if (after == LB_NS) return false; |
| if (after == LB_HY) return false; |
| if (after == LB_BA) return false; |
| if (before == LB_BB) return false; |
| |
| if (!recommended) { |
| // LB 15b Break after hyphen-minus, and before acute accents: |
| // HY ÷ |
| // ÷ BB |
| |
| rule="15b"; |
| if (before == LB_HY) return true; |
| if (after == LB_BB) return true; |
| } |
| |
| // LB 16 Don’t break between two ellipses, or between letters or numbers and ellipsis: |
| // AL × IN |
| // ID × IN |
| // IN × IN |
| // NU × IN |
| // Examples: ’9...’, ‘a...’, ‘H...’ |
| rule="16"; |
| if ((before == LB_NU || before == LB_AL || before == LB_ID) && after == LB_IN) return false; |
| if (before == LB_IN && after == LB_IN) return false; |
| |
| // Don't break alphanumerics. |
| // LB 17 Don’t break within ‘a9’, ‘3a’, or ‘H%’ |
| // ID × PO |
| // AL × NU |
| // NU × AL |
| // Numbers are of the form PR ? ( OP | HY ) ? NU (NU | IS) * CL ? PO ? |
| // Examples: $(12.35) 2,1234 (12)¢ 12.54¢ |
| // This is approximated with the following rules. (Some cases already handled above, |
| // like ‘9,’, ‘[9’.) |
| rule="17"; |
| if (before == LB_ID && after == LB_PO) return false; |
| if (before == LB_AL && after == LB_NU) return false; |
| if (before == LB_NU && after == LB_AL) return false; |
| |
| // LB 18 Don’t break between the following pairs of classes. |
| // CL × PO |
| // HY × NU |
| // IS × NU |
| // NU × NU |
| // NU × PO |
| // PR × AL |
| // PR × HY |
| // PR × ID |
| // PR × NU |
| // PR × OP |
| // SY × NU |
| // Example pairs: ‘$9’, ‘$[’, ‘$-‘, ‘-9’, ‘/9’, ‘99’, ‘,9’, ‘9%’ ‘]%’ |
| |
| rule="18"; |
| if (before == LB_CL && after == LB_PO) return false; |
| if (before == LB_HY && after == LB_NU) return false; |
| if (before == LB_IS && after == LB_NU) return false; |
| if (before == LB_NU && after == LB_NU) return false; |
| if (before == LB_NU && after == LB_PO) return false; |
| |
| if (before == LB_PR && after == LB_AL) return false; |
| if (before == LB_PR && after == LB_HY) return false; |
| if (before == LB_PR && after == LB_ID) return false; |
| if (before == LB_PR && after == LB_NU) return false; |
| if (before == LB_PR && after == LB_OP) return false; |
| |
| if (before == LB_SY && after == LB_NU) return false; |
| |
| if (recommended) { |
| // LB 15b Break after hyphen-minus, and before acute accents: |
| // HY ÷ |
| // ÷ BB |
| |
| rule="18b"; |
| if (before == LB_HY) return true; |
| if (after == LB_BB) return true; |
| } |
| |
| // LB 19 Don’t break between alphabetics (“at”) |
| // AL × AL |
| |
| rule="19"; |
| if (before == LB_AL && after == LB_AL) return false; |
| |
| // LB 20 Break everywhere else |
| // ALL ÷ |
| // ÷ ALL |
| |
| rule="20"; |
| return true; |
| } |
| |
| static class GenerateWordBreakTest extends GenerateLineBreakTest { |
| |
| static final byte CR = 0, LF = 1, Control = 2, Extend = 3, Link = 4, CGJ = 5, Base = 6, LetterBase = 7, Other = 8, |
| oLIMIT = 9, // RESET THIS IF LIST ABOVE CHANGES! |
| L = oLIMIT + hL, V = oLIMIT + hV, T = oLIMIT + hT, LV = oLIMIT + hLV, LVT = oLIMIT + hLVT, |
| LIMIT = LVT + 1; |
| |
| static final String[] Names = {"CR", "LF", "CTL", "Extend", "Link", "CGJ", "Base", "LetterBase", "Other" }; |
| |
| static UCDProperty extendProp = UnifiedBinaryProperty.make(DERIVED | GraphemeExtend); |
| static UCDProperty baseProp = UnifiedBinaryProperty.make(DERIVED | GraphemeBase); |
| static UCDProperty linkProp = UnifiedBinaryProperty.make(BINARY_PROPERTIES | GraphemeLink); |
| |
| { |
| fileName = "Word"; |
| TypeOrder = new byte[LIMIT]; |
| for (byte i = 0; i < TypeOrder.length; ++i) { |
| TypeOrder[i] = i; |
| } |
| } |
| |
| boolean skipType(byte type) { |
| return false; |
| } |
| |
| public int getLimit() { |
| return LIMIT; |
| } |
| |
| public int getTableLimit() { |
| return LIMIT; |
| } |
| |
| // stuff that subclasses need to override |
| public int genTestItems(String before, String after, String[] results) { |
| results[0] = before + after; |
| return 1; |
| } |
| |
| public String getTableEntry(String before, String after, boolean recommended, String[] ruleOut) { |
| boolean normalBreak = isBreak(before + after, before.length(), recommended); |
| String normalRule = rule; |
| ruleOut[0] = rule; |
| return normalBreak ? BREAK : NOBREAK; |
| } |
| |
| // stuff that subclasses need to override |
| public String getTypeID(int cp) { |
| byte type = getType(cp); |
| if (type >= oLIMIT) return hNames[type - oLIMIT]; |
| return Names[type]; |
| } |
| |
| // stuff that subclasses need to override |
| public byte getType(int cp) { |
| // single characters |
| if (cp == 0xA) return LF; |
| if (cp == 0xD) return CR; |
| if (cp == 0x034F) return CGJ; |
| if (cp == 0x2028 || cp == 0x2029) return Control; |
| |
| // Hangul |
| byte result = getHangulType(cp); |
| if (result != hNot) return (byte)(result + oLIMIT); |
| |
| // other properties |
| // category based |
| byte cat = Default.ucd().getCategory(cp); |
| if (cat == Cc) return Control; |
| if (cat == Cf) return Extend; |
| if (((1<<cat) & LETTER_MASK) != 0) return LetterBase; |
| |
| // other binary properties |
| if (linkProp.hasValue(cp)) return Link; |
| if (extendProp.hasValue(cp)) return Extend; |
| if (baseProp.hasValue(cp)) return Base; |
| |
| return Other; |
| } |
| |
| public byte getResolvedType(int cp, boolean recommended) { |
| return getType(cp); |
| } |
| |
| public boolean isBreak(String source, int offset, boolean recommended) { |
| rule="1"; |
| if (offset < 0 || offset > source.length()) return false; |
| if (offset == 0) return true; |
| |
| rule = "2"; |
| if (offset == source.length()) return true; |
| |
| // UTF-16: never break in the middle of a code point |
| if (!onCodepointBoundary(source, offset)) return false; |
| |
| // now get the character before and after, and their types |
| |
| |
| int cpBefore = UTF16.charAt(source, offset-1); |
| int cpAfter = UTF16.charAt(source, offset); |
| |
| byte before = getResolvedType(cpBefore, recommended); |
| byte after = getResolvedType(cpAfter, recommended); |
| |
| rule = "3"; |
| if (before == CR && after == LF) return false; |
| |
| rule = "4"; |
| if (before == CR || before == LF || before == Control |
| || after == Control || after == LF || after == CR) return true; |
| |
| rule = "6"; |
| if (before == L && (after == L || after == V || after == LV || after == LVT)) return false; |
| |
| rule = "7"; |
| if ((before == LV || before == V) && (after == V || after == T)) return false; |
| |
| rule = "8"; |
| if ((before == LVT || before == T) && (after == T)) return false; |
| |
| rule = "9"; |
| if (after == Extend) return false; |
| |
| if (recommended) { |
| if (after == Link || after == CGJ) return false; |
| } else { |
| |
| // Do not break around a CGJ. |
| rule = "10"; |
| if (before == CGJ && (after == Base |
| || after == LetterBase || after == L || after == V || after == T || after == LV || after == LVT)) return false; |
| rule = "11"; |
| if (after == CGJ) return false; |
| |
| // Do not break between linking characters and letters, or before linking characters. This provides for Indic graphemes, where virama (halant) will link character clusters together. |
| |
| rule = "12"; |
| //Link Extend* × LetterBase (12) |
| if (after == LetterBase || after == L || after == V || after == T || after == LV || after == LVT) { |
| int backOffset = findLastNon(source, offset, Extend, recommended); |
| if (backOffset >= 0) { |
| byte last = getResolvedType(UTF16.charAt(source, backOffset), recommended); |
| if (last == Link) return false; |
| } |
| } |
| |
| rule = "13"; |
| if (after == Link) return false; |
| } |
| |
| // Otherwise break after all characters. |
| rule = "14"; |
| return true; |
| |
| } |
| |
| } |
| } |
