1. /*

  2.  * @(#)PatternEntry.java	1.20 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. /*

  9.  * @(#)PatternEntry.java	1.20 01/11/29

  10.  *

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

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

  13.  *

  14.  * Portions copyright (c) 1996-1998 Sun Microsystems, Inc. All Rights Reserved.

  15.  *

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

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

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

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

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

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

  22.  *

  23.  * Permission to use, copy, modify, and distribute this software

  24.  * and its documentation for NON-COMMERCIAL purposes and without

  25.  * fee is hereby granted provided that this copyright notice

  26.  * appears in all copies. Please refer to the file "copyright.html"

  27.  * for further important copyright and licensing information.

  28.  *

  29.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF

  30.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

  31.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

  32.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR

  33.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR

  34.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.

  35.  *

  36.  */

  37. package java.text;

  38. 

  39. import java.lang.Character;

  40. 

  41. /**

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

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

  44.  * existing rule table.

  45.  * @see        MergeCollation

  46.  * @version    1.20 11/29/01

  47.  * @author     Mark Davis, Helena Shih

  48.  */

  49. 

  50. class PatternEntry {

  51.     /**

  52.      * Gets the current extension, quoted

  53.      */

  54.     public void appendQuotedExtension(StringBuffer toAddTo) {

  55.         appendQuoted(extension,toAddTo);

  56.     }

  57. 

  58.     /**

  59.      * Gets the current chars, quoted

  60.      */

  61.     public void appendQuotedChars(StringBuffer toAddTo) {

  62.         appendQuoted(chars,toAddTo);

  63.     }

  64. 

  65.     /**

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

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

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

  69.      */

  70.     public boolean equals(Object obj) {

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

  72.         PatternEntry other = (PatternEntry) obj;

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

  74.         return result;

  75.     }

  76. 

  77.     /**

  78.      * For debugging.

  79.      */

  80.     public String toString() {

  81.         StringBuffer result = new StringBuffer();

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

  83.         return result.toString();

  84.     }

  85. 

  86.     /**

  87.      * Gets the strength of the entry.

  88.      */

  89.     final int getStrength() {

  90.         return strength;

  91.     }

  92. 

  93.     /**

  94.      * Gets the expanding characters of the entry.

  95.      */

  96.     final String getExtension() {

  97.         return extension;

  98.     }

  99. 

  100.     /**

  101.      * Gets the core characters of the entry.

  102.      */

  103.     final String getChars() {

  104.         return chars;

  105.     }

  106. 

  107.     // ===== privates =====

  108. 

  109.     void addToBuffer(StringBuffer toAddTo,

  110.                      boolean showExtension,

  111.                      boolean showWhiteSpace,

  112.                      PatternEntry lastEntry)

  113.     {

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

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

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

  117.             else

  118.                 toAddTo.append(' ');

  119.         if (lastEntry != null) {

  120.             toAddTo.append('&');

  121.             if (showWhiteSpace)

  122.                 toAddTo.append(' ');

  123.             lastEntry.appendQuotedChars(toAddTo);

  124.             appendQuotedExtension(toAddTo);

  125.             if (showWhiteSpace)

  126.                 toAddTo.append(' ');

  127.         }

  128.         switch (strength) {

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

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

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

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

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

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

  135.         }

  136.         if (showWhiteSpace)

  137.             toAddTo.append(' ');

  138.         appendQuoted(chars,toAddTo);

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

  140.             toAddTo.append('/');

  141.             appendQuoted(extension,toAddTo);

  142.         }

  143.     }

  144. 

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

  146.         boolean inQuote = false;

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

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

  149.             inQuote = true;

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

  151.         } else {

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

  153.                 inQuote = true;

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

  155.             } else {

  156.                 switch (ch) {

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

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

  159.                     inQuote = true;

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

  161.                     break;

  162.                 case '\'':

  163.                     inQuote = true;

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

  165.                     break;

  166.                 default:

  167.                     if (inQuote) {

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

  169.                     }

  170.                     break;

  171.                 }

  172.            }

  173.         }

  174.         toAddTo.append(chars);

  175.         if (inQuote)

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

  177.     }

  178. 

  179.     //========================================================================

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

  181.     //========================================================================

  182. 

  183.     PatternEntry(int strength,

  184.                  StringBuffer chars,

  185.                  StringBuffer extension)

  186.     {

  187.         this.strength = strength;

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

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

  190.                                                   : "";

  191.     }

  192. 

  193.     static class Parser {

  194.         private String pattern;

  195.         private int i;

  196.         

  197.         public Parser(String pattern) {

  198.             this.pattern = pattern;

  199.             this.i = 0;

  200.         }

  201.         

  202.         public PatternEntry next() throws ParseException {

  203.             int newStrength = UNSET;

  204.             

  205.             newChars.setLength(0);

  206.             newExtension.setLength(0);

  207.             

  208.             boolean inChars = true;

  209.             boolean inQuote = false;

  210.         mainLoop:

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

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

  213.                 if (inQuote) {

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

  215.                         inQuote = false;

  216.                     } else {

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

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

  219.                         else newExtension.append(ch);

  220.                     }

  221.                 } else switch (ch) {

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

  223.                     newStrength = Collator.IDENTICAL; break;

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

  225.                     newStrength = Collator.TERTIARY; break;

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

  227.                     newStrength = Collator.SECONDARY; break;

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

  229.                     newStrength = Collator.PRIMARY; break;

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

  231.                     newStrength = RESET; break;

  232.                 case '\t':

  233.                 case '\n':

  234.                 case '\f':

  235.                 case '\r':

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

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

  238.                 case '\'':

  239.                     inQuote = true;

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

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

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

  243.                     else newExtension.append(ch);

  244.                     break;

  245.                 default:

  246.                     if (newStrength == UNSET) {

  247.                         throw new ParseException

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

  249.                              pattern.substring(i,

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

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

  252.                              i);

  253.                     }

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

  255.                         throw new ParseException

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

  257.                     if (inChars) {

  258.                         newChars.append(ch);

  259.                     } else {

  260.                         newExtension.append(ch);

  261.                     }

  262.                     break;

  263.                 }

  264.                 i++;

  265.             }

  266.             if (newStrength == UNSET)

  267.                 return null;

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

  269.                 throw new ParseException

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

  271.                       pattern.substring(i,

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

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

  274.                      i);

  275.             }

  276.             

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

  278.         }

  279. 

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

  281.         private StringBuffer newChars = new StringBuffer();

  282.         private StringBuffer newExtension = new StringBuffer();

  283.         

  284.     }

  285.         

  286.     static boolean isSpecialChar(char ch) {

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

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

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

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

  291.     }

  292.     

  293. 

  294.     static final int RESET = -2;

  295.     static final int UNSET = -1;

  296. 

  297.     int strength = UNSET;

  298.     String chars = "";

  299.     String extension = "";

  300. }