1. /*

  2.  * @(#)PatternEntry.java	1.21 00/01/19

  3.  *

  4.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. /*

  12.  * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved

  13.  * (C) Copyright IBM Corp. 1996, 1997 - All Rights Reserved

  14.  *

  15.  *   The original version of this source code and documentation is copyrighted

  16.  * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These

  17.  * materials are provided under terms of a License Agreement between Taligent

  18.  * and Sun. This technology is protected by multiple US and International

  19.  * patents. This notice and attribution to Taligent may not be removed.

  20.  *   Taligent is a registered trademark of Taligent, Inc.

  21.  *

  22.  */

  23. 

  24. package java.text;

  25. 

  26. import java.lang.Character;

  27. 

  28. /**

  29.  * Utility class for normalizing and merging patterns for collation.

  30.  * This is to be used with MergeCollation for adding patterns to an

  31.  * existing rule table.

  32.  * @see        MergeCollation

  33.  * @version    1.21 01/19/00

  34.  * @author     Mark Davis, Helena Shih

  35.  */

  36. 

  37. class PatternEntry {

  38.     /**

  39.      * Gets the current extension, quoted

  40.      */

  41.     public void appendQuotedExtension(StringBuffer toAddTo) {

  42.         appendQuoted(extension,toAddTo);

  43.     }

  44. 

  45.     /**

  46.      * Gets the current chars, quoted

  47.      */

  48.     public void appendQuotedChars(StringBuffer toAddTo) {

  49.         appendQuoted(chars,toAddTo);

  50.     }

  51. 

  52.     /**

  53.      * WARNING this is used for searching in a Vector.

  54.      * Because Vector.indexOf doesn't take a comparator,

  55.      * this method is ill-defined and ignores strength.

  56.      */

  57.     public boolean equals(Object obj) {

  58.         if (obj == null) return false;

  59.         PatternEntry other = (PatternEntry) obj;

  60.         boolean result = chars.equals(other.chars);

  61.         return result;

  62.     }

  63. 

  64.     public int hashCode() {

  65.         return chars.hashCode();

  66.     }

  67. 

  68.     /**

  69.      * For debugging.

  70.      */

  71.     public String toString() {

  72.         StringBuffer result = new StringBuffer();

  73.         addToBuffer(result, true, false, null);

  74.         return result.toString();

  75.     }

  76. 

  77.     /**

  78.      * Gets the strength of the entry.

  79.      */

  80.     final int getStrength() {

  81.         return strength;

  82.     }

  83. 

  84.     /**

  85.      * Gets the expanding characters of the entry.

  86.      */

  87.     final String getExtension() {

  88.         return extension;

  89.     }

  90. 

  91.     /**

  92.      * Gets the core characters of the entry.

  93.      */

  94.     final String getChars() {

  95.         return chars;

  96.     }

  97. 

  98.     // ===== privates =====

  99. 

  100.     void addToBuffer(StringBuffer toAddTo,

  101.                      boolean showExtension,

  102.                      boolean showWhiteSpace,

  103.                      PatternEntry lastEntry)

  104.     {

  105.         if (showWhiteSpace && toAddTo.length() > 0)

  106.             if (strength == Collator.PRIMARY || lastEntry != null)

  107.                 toAddTo.append('\n');

  108.             else

  109.                 toAddTo.append(' ');

  110.         if (lastEntry != null) {

  111.             toAddTo.append('&');

  112.             if (showWhiteSpace)

  113.                 toAddTo.append(' ');

  114.             lastEntry.appendQuotedChars(toAddTo);

  115.             appendQuotedExtension(toAddTo);

  116.             if (showWhiteSpace)

  117.                 toAddTo.append(' ');

  118.         }

  119.         switch (strength) {

  120.         case Collator.IDENTICAL: toAddTo.append('='); break;

  121.         case Collator.TERTIARY:  toAddTo.append(','); break;

  122.         case Collator.SECONDARY: toAddTo.append(';'); break;

  123.         case Collator.PRIMARY:   toAddTo.append('<'); break;

  124.         case RESET: toAddTo.append('&'); break;

  125.         case UNSET: toAddTo.append('?'); break;

  126.         }

  127.         if (showWhiteSpace)

  128.             toAddTo.append(' ');

  129.         appendQuoted(chars,toAddTo);

  130.         if (showExtension && extension.length() != 0) {

  131.             toAddTo.append('/');

  132.             appendQuoted(extension,toAddTo);

  133.         }

  134.     }

  135. 

  136.     static void appendQuoted(String chars, StringBuffer toAddTo) {

  137.         boolean inQuote = false;

  138.         char ch = chars.charAt(0);

  139.         if (Character.isSpaceChar(ch)) {

  140.             inQuote = true;

  141.             toAddTo.append('\'');

  142.         } else {

  143.           if (PatternEntry.isSpecialChar(ch)) {

  144.                 inQuote = true;

  145.                 toAddTo.append('\'');

  146.             } else {

  147.                 switch (ch) {

  148.                     case 0x0010: case '\f': case '\r':

  149.                     case '\t': case '\n':  case '@':

  150.                     inQuote = true;

  151.                     toAddTo.append('\'');

  152.                     break;

  153.                 case '\'':

  154.                     inQuote = true;

  155.                     toAddTo.append('\'');

  156.                     break;

  157.                 default:

  158.                     if (inQuote) {

  159.                         inQuote = false; toAddTo.append('\'');

  160.                     }

  161.                     break;

  162.                 }

  163.            }

  164.         }

  165.         toAddTo.append(chars);

  166.         if (inQuote)

  167.             toAddTo.append('\'');

  168.     }

  169. 

  170.     //========================================================================

  171.     // Parsing a pattern into a list of PatternEntries....

  172.     //========================================================================

  173. 

  174.     PatternEntry(int strength,

  175.                  StringBuffer chars,

  176.                  StringBuffer extension)

  177.     {

  178.         this.strength = strength;

  179.         this.chars = chars.toString();

  180.         this.extension = (extension.length() > 0) ? extension.toString()

  181.                                                   : "";

  182.     }

  183. 

  184.     static class Parser {

  185.         private String pattern;

  186.         private int i;

  187.         

  188.         public Parser(String pattern) {

  189.             this.pattern = pattern;

  190.             this.i = 0;

  191.         }

  192.         

  193.         public PatternEntry next() throws ParseException {

  194.             int newStrength = UNSET;

  195.             

  196.             newChars.setLength(0);

  197.             newExtension.setLength(0);

  198.             

  199.             boolean inChars = true;

  200.             boolean inQuote = false;

  201.         mainLoop:

  202.             while (i < pattern.length()) {

  203.                 char ch = pattern.charAt(i);

  204.                 if (inQuote) {

  205.                     if (ch == '\'') {

  206.                         inQuote = false;

  207.                     } else {

  208.                         if (newChars.length() == 0) newChars.append(ch);

  209.                         else if (inChars) newChars.append(ch);

  210.                         else newExtension.append(ch);

  211.                     }

  212.                 } else switch (ch) {

  213.                 case '=': if (newStrength != UNSET) break mainLoop;

  214.                     newStrength = Collator.IDENTICAL; break;

  215.                 case ',': if (newStrength != UNSET) break mainLoop;

  216.                     newStrength = Collator.TERTIARY; break;

  217.                 case ';': if (newStrength != UNSET) break mainLoop;

  218.                     newStrength = Collator.SECONDARY; break;

  219.                 case '<': if (newStrength != UNSET) break mainLoop;

  220.                     newStrength = Collator.PRIMARY; break;

  221.                 case '&': if (newStrength != UNSET) break mainLoop;

  222.                     newStrength = RESET; break;

  223.                 case '\t':

  224.                 case '\n':

  225.                 case '\f':

  226.                 case '\r':

  227.                 case ' ': break; // skip whitespace TODO use Character

  228.                 case '/': inChars = false; break;

  229.                 case '\'':

  230.                     inQuote = true;

  231.                     ch = pattern.charAt(++i);

  232.                     if (newChars.length() == 0) newChars.append(ch);

  233.                     else if (inChars) newChars.append(ch);

  234.                     else newExtension.append(ch);

  235.                     break;

  236.                 default:

  237.                     if (newStrength == UNSET) {

  238.                         throw new ParseException

  239.                             ("missing char (=,;<&) : " +

  240.                              pattern.substring(i,

  241.                                 (i+10 < pattern.length()) ?

  242.                                  i+10 : pattern.length()),

  243.                              i);

  244.                     }

  245.                     if (PatternEntry.isSpecialChar(ch) && (inQuote == false))

  246.                         throw new ParseException

  247.                             ("Unquoted punctuation character : " + Integer.toString(ch, 16), i);

  248.                     if (inChars) {

  249.                         newChars.append(ch);

  250.                     } else {

  251.                         newExtension.append(ch);

  252.                     }

  253.                     break;

  254.                 }

  255.                 i++;

  256.             }

  257.             if (newStrength == UNSET)

  258.                 return null;

  259.             if (newChars.length() == 0) {

  260.                 throw new ParseException

  261.                     ("missing chars (=,;<&): " +

  262.                       pattern.substring(i,

  263.                           (i+10 < pattern.length()) ?

  264.                            i+10 : pattern.length()),

  265.                      i);

  266.             }

  267.             

  268.             return new PatternEntry(newStrength, newChars, newExtension);

  269.         }

  270. 

  271.         // We re-use these objects in order to improve performance

  272.         private StringBuffer newChars = new StringBuffer();

  273.         private StringBuffer newExtension = new StringBuffer();

  274.         

  275.     }

  276.         

  277.     static boolean isSpecialChar(char ch) {

  278.         return (((ch <= '\u002F') && (ch >= '\u0020')) ||

  279.                 ((ch <= '\u003F') && (ch >= '\u003A')) ||

  280.                 ((ch <= '\u0060') && (ch >= '\u005B')) ||

  281.                 ((ch <= '\u007E') && (ch >= '\u007B')));

  282.     }

  283.     

  284. 

  285.     static final int RESET = -2;

  286.     static final int UNSET = -1;

  287. 

  288.     int strength = UNSET;

  289.     String chars = "";

  290.     String extension = "";

  291. }