home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / esc.jar / com / extensibility / util / regexpr / CharPatternTerm.class (.txt) < prev    next >
Encoding:
Java Class File  |  2000-06-30  |  10.8 KB  |  399 lines
  1. package com.extensibility.util.regexpr;
  2.  
  3. import java.util.Enumeration;
  4. import java.util.Hashtable;
  5. import java.util.Vector;
  6.  
  7. public class CharPatternTerm implements PatternTerm {
  8.    public static final int TYPE_SEQ = 0;
  9.    public static final int TYPE_CHOICE = 1;
  10.    public static final int TYPE_LEAF_POSITIVE = 2;
  11.    public static final int TYPE_LEAF_NEGATIVE = 3;
  12.    public static final int TYPE_LEAF_WILDCARD = 4;
  13.    protected int minOccurrence = 1;
  14.    protected int maxOccurrence = 1;
  15.    protected int type;
  16.    protected int[] categories;
  17.    protected Vector subTermVector = new Vector();
  18.    protected Vector rangeVector = new Vector();
  19.    protected CharPatternTerm notTerm;
  20.    protected static Hashtable categoryMap = null;
  21.    protected static Hashtable blockMap;
  22.  
  23.    public CharPatternTerm(int var1) {
  24.       this.type = var1;
  25.    }
  26.  
  27.    public CharPatternTerm(char var1) {
  28.       this.type = 2;
  29.       this.rangeVector.addElement(new CharRange(var1));
  30.    }
  31.  
  32.    public void addSubTerm(CharPatternTerm var1) {
  33.       this.subTermVector.addElement(var1);
  34.    }
  35.  
  36.    public void addChar(char var1) {
  37.       this.rangeVector.addElement(new CharRange(var1));
  38.    }
  39.  
  40.    public void addChar(char var1, char var2) {
  41.       this.rangeVector.addElement(new CharRange(var1, var2));
  42.    }
  43.  
  44.    public void combineRanges() {
  45.       CharRange var1 = (CharRange)this.rangeVector.elementAt(this.rangeVector.size() - 2);
  46.       CharRange var2 = (CharRange)this.rangeVector.elementAt(this.rangeVector.size() - 1);
  47.       var1.setLast(var2.getLast());
  48.       this.rangeVector.removeElementAt(this.rangeVector.size() - 1);
  49.    }
  50.  
  51.    public void addNegativeTerm(CharPatternTerm var1) {
  52.       this.notTerm = var1;
  53.    }
  54.  
  55.    public void setCategory(String var1) {
  56.       if (categoryMap == null) {
  57.          categoryMap = new Hashtable();
  58.          categoryMap.put("L", new int[]{1, 2, 3, 4, 5});
  59.          categoryMap.put("Lu", new int[]{1});
  60.          categoryMap.put("Ll", new int[]{2});
  61.          categoryMap.put("Lt", new int[]{3});
  62.          categoryMap.put("Lm", new int[]{4});
  63.          categoryMap.put("Lo", new int[]{5});
  64.          categoryMap.put("M", new int[]{6, 8, 7});
  65.          categoryMap.put("Mn", new int[]{6});
  66.          categoryMap.put("Mc", new int[]{8});
  67.          categoryMap.put("Me", new int[]{7});
  68.          categoryMap.put("N", new int[]{9, 10, 11});
  69.          categoryMap.put("Nd", new int[]{9});
  70.          categoryMap.put("Nl", new int[]{10});
  71.          categoryMap.put("No", new int[]{11});
  72.          categoryMap.put("P", new int[]{23, 20, 21, 22, 24});
  73.          categoryMap.put("Pc", new int[]{23});
  74.          categoryMap.put("Pd", new int[]{20});
  75.          categoryMap.put("Ps", new int[]{21});
  76.          categoryMap.put("Pe", new int[]{22});
  77.          categoryMap.put("Pi", new int[]{24});
  78.          categoryMap.put("Pf", new int[]{24});
  79.          categoryMap.put("Po", new int[]{24});
  80.          categoryMap.put("Z", new int[]{12, 13, 14});
  81.          categoryMap.put("Zs", new int[]{12});
  82.          categoryMap.put("Zl", new int[]{13});
  83.          categoryMap.put("Zp", new int[]{14});
  84.          categoryMap.put("S", new int[]{25, 26, 27, 28});
  85.          categoryMap.put("Sm", new int[]{25});
  86.          categoryMap.put("Sc", new int[]{26});
  87.          categoryMap.put("Sk", new int[]{27});
  88.          categoryMap.put("So", new int[]{28});
  89.          categoryMap.put("C", new int[]{15, 16, 19, 18, 0});
  90.          categoryMap.put("Cc", new int[]{15});
  91.          categoryMap.put("Cf", new int[]{16});
  92.          categoryMap.put("Cs", new int[]{19});
  93.          categoryMap.put("Co", new int[]{18});
  94.          categoryMap.put("Cn", new int[]{0});
  95.       }
  96.  
  97.       this.categories = (int[])categoryMap.get(var1);
  98.       if (this.categories == null) {
  99.          throw new RuntimeException(String.valueOf(String.valueOf("invalid Unicode category \"").concat(String.valueOf(var1))).concat(String.valueOf("\"")));
  100.       }
  101.    }
  102.  
  103.    public void setBlock(String var1) {
  104.       if (blockMap == null) {
  105.          blockMap = new Hashtable();
  106.          blockMap.put("BasicLatin", new char[]{'\u0000', '\u007f'});
  107.          blockMap.put("Latin-1Supplement", new char[]{'\u0080', '√ø'});
  108.          blockMap.put("LatinExtended-A", new char[]{'ƒÄ', '≈ø'});
  109.          blockMap.put("LatinExtended-B", new char[]{'ΔÄ', '…è'});
  110.          blockMap.put("IPAExtensions", new char[]{'…ê', ' Ø'});
  111.          blockMap.put("SpacingModifierLetters", new char[]{' ∞', 'Àø'});
  112.          blockMap.put("CombiningDiacriticalMarks", new char[]{'ÃÄ', 'ÕØ'});
  113.          blockMap.put("Greek", new char[]{'Õ∞', 'œø'});
  114.          blockMap.put("Cyrillic", new char[]{'–Ä', '”ø'});
  115.          blockMap.put("Armenian", new char[]{'\u0530', '÷è'});
  116.          blockMap.put("Hebrew", new char[]{'\u0590', '\u05ff'});
  117.          blockMap.put("Arabic", new char[]{'\u0600', '€ø'});
  118.          blockMap.put("Syriac  ", new char[]{'‹Ä', '›è'});
  119.          blockMap.put("Thaana", new char[]{'fiÄ', '\u07bf'});
  120.          blockMap.put("Devanagari", new char[]{'‡§Ä', '‡•ø'});
  121.          blockMap.put("Bengali", new char[]{'‡¶Ä', '\u09ff'});
  122.          blockMap.put("Gurmukhi", new char[]{'\u0a00', '\u0a7f'});
  123.          blockMap.put("Gujarati", new char[]{'\u0a80', '‡´ø'});
  124.          blockMap.put("Oriya", new char[]{'\u0b00', '\u0b7f'});
  125.          blockMap.put("Tamil", new char[]{'\u0b80', '\u0bff'});
  126.          blockMap.put("Telugu", new char[]{'‡∞Ä', '‡±ø'});
  127.          blockMap.put("Kannada", new char[]{'‡≤Ä', '\u0cff'});
  128.          blockMap.put("Malayalam", new char[]{'‡¥Ä', '‡µø'});
  129.          blockMap.put("Sinhala", new char[]{'\u0d80', '\u0dff'});
  130.          blockMap.put("Thai", new char[]{'\u0e00', '\u0e7f'});
  131.          blockMap.put("Lao", new char[]{'\u0e80', '\u0eff'});
  132.          blockMap.put("Tibetan", new char[]{'‡ºÄ', '\u0fff'});
  133.          blockMap.put("Myanmar ", new char[]{'·ÄÄ', '·Çü'});
  134.          blockMap.put("Georgian", new char[]{'·Ç†', '·Éø'});
  135.          blockMap.put("Hangul Jamo", new char[]{'·ÑÄ', '·áø'});
  136.          blockMap.put("Ethiopic", new char[]{'·àÄ', '\u137f'});
  137.          blockMap.put("Cherokee", new char[]{'·é†', '\u13ff'});
  138.          blockMap.put("UnifiedCanadianAboriginalSyllabics", new char[]{'·êÄ', '·ôø'});
  139.          blockMap.put("Ogham", new char[]{'·öÄ', '\u169f'});
  140.          blockMap.put("Runic", new char[]{'·ö†', '\u16ff'});
  141.          blockMap.put("Khmer", new char[]{'·ûÄ', '\u17ff'});
  142.          blockMap.put("Mongolian", new char[]{'·†Ä', '\u18af'});
  143.          blockMap.put("LatinExtendedAdditional", new char[]{'·∏Ä', '·ªø'});
  144.          blockMap.put("GreekExtended", new char[]{'·ºÄ', '\u1fff'});
  145.          blockMap.put("GeneralPunctuation", new char[]{'‚ÄÄ', '\u206f'});
  146.          blockMap.put("SuperscriptsandSubscripts", new char[]{'‚Å∞', '\u209f'});
  147.          blockMap.put("CurrencySymbols", new char[]{'‚dž', '\u20cf'});
  148.          blockMap.put("CombiningMarksforSymbols", new char[]{'‚Éê', '\u20ff'});
  149.          blockMap.put("LetterlikeSymbols", new char[]{'‚ÑÄ', '‚Öè'});
  150.          blockMap.put("NumberForms", new char[]{'‚Öê', '\u218f'});
  151.          blockMap.put("Arrows", new char[]{'‚Üê', '‚áø'});
  152.          blockMap.put("MathematicalOperators", new char[]{'‚àÄ', '‚ãø'});
  153.          blockMap.put("MiscellaneousTechnical", new char[]{'‚åÄ', '‚èø'});
  154.          blockMap.put("ControlPictures", new char[]{'‚êÄ', '\u243f'});
  155.          blockMap.put("OpticalCharacterRecognition", new char[]{'‚ëÄ', '\u245f'});
  156.          blockMap.put("EnclosedAlphanumerics", new char[]{'‚ë†', '‚ìø'});
  157.          blockMap.put("BoxDrawing", new char[]{'‚îÄ', '‚ïø'});
  158.          blockMap.put("BlockElements", new char[]{'‚ñÄ', '‚ñü'});
  159.          blockMap.put("GeometricShapes", new char[]{'‚ñ†', '‚óø'});
  160.          blockMap.put("MiscellaneousSymbols", new char[]{'‚òÄ', '‚õø'});
  161.          blockMap.put("Dingbats", new char[]{'‚úÄ', '‚ûø'});
  162.          blockMap.put("BraillePatterns", new char[]{'‚†Ä', '‚£ø'});
  163.          blockMap.put("CJKRadicalsSupplement", new char[]{'‚∫Ä', '\u2eff'});
  164.          blockMap.put("KangxiRadicals", new char[]{'‚ºÄ', '\u2fdf'});
  165.          blockMap.put("IdeographicDescriptionCharacters", new char[]{'‚ø∞', '\u2fff'});
  166.          blockMap.put("CJKSymbolsandPunctuation", new char[]{'„ÄÄ', '„Äø'});
  167.          blockMap.put("Hiragana", new char[]{'\u3040', '„Çü'});
  168.          blockMap.put("Katakana", new char[]{'„dž', '„Éø'});
  169.          blockMap.put("Bopomofo", new char[]{'\u3100', '„ÑØ'});
  170.          blockMap.put("HangulCompatibilityJamo", new char[]{'\u3130', '\u318f'});
  171.          blockMap.put("Kanbun", new char[]{'„Üê', '„Üü'});
  172.          blockMap.put("BopomofoExtended", new char[]{'„܆', '„Üø'});
  173.          blockMap.put("EnclosedCJKLettersandMonths", new char[]{'„àÄ', '„ãø'});
  174.          blockMap.put("CJKCompatibility", new char[]{'„åÄ', '„èø'});
  175.          blockMap.put("CJKUnifiedIdeographsExtensionA", new char[]{'„êÄ', '‰∂µ'});
  176.          blockMap.put("CJKUnifiedIdeographs", new char[]{'‰∏Ä', 'Èøø'});
  177.          blockMap.put("YiSyllables", new char[]{'ÍÄÄ', '\ua48f'});
  178.          blockMap.put("YiRadicals", new char[]{'Ííê', '\ua4cf'});
  179.          blockMap.put("HangulSyllables", new char[]{'Í∞Ä', 'Ìû£'});
  180.          blockMap.put("HighSurrogates", new char[]{'\ud800', '\udb7f'});
  181.          blockMap.put("HighPrivateUseSurrogates", new char[]{'\udb80', '\udbff'});
  182.          blockMap.put("LowSurrogates", new char[]{'\udc00', '\udfff'});
  183.          blockMap.put("PrivateUse", new char[]{'\ue000', '\uf8ff'});
  184.          blockMap.put("CJKCompatibilityIdeographs", new char[]{'Ô§Ä', '\ufaff'});
  185.          blockMap.put("AlphabeticPresentationForms", new char[]{'Ô¨Ä', 'Ô≠è'});
  186.          blockMap.put("ArabicPresentationForms-A", new char[]{'Ô≠ê', 'Ô∑ø'});
  187.          blockMap.put("CombiningHalfMarks", new char[]{'Ô∏†', 'Ô∏Ø'});
  188.          blockMap.put("CJKCompatibilityForms", new char[]{'Ô∏∞', 'Ôπè'});
  189.          blockMap.put("SmallFormVariants", new char[]{'Ôπê', '\ufe6f'});
  190.          blockMap.put("ArabicPresentationForms-B", new char[]{'Ôπ∞', '\ufefe'});
  191.          blockMap.put("Specials", new char[]{'\ufeff', 'ÔøΩ'});
  192.          blockMap.put("HalfwidthandFullwidthForms", new char[]{'\uff00', '\uffef'});
  193.       }
  194.  
  195.       char[] var2 = (char[])blockMap.get(var1);
  196.       if (var2 == null) {
  197.          throw new RuntimeException(String.valueOf(String.valueOf("invalid Unicode block name \"").concat(String.valueOf(var1))).concat(String.valueOf("\"")));
  198.       } else {
  199.          this.addChar(var2[0], var2[1]);
  200.       }
  201.    }
  202.  
  203.    public void setOccurrence(int var1, int var2) {
  204.       this.minOccurrence = var1;
  205.       this.maxOccurrence = var2;
  206.    }
  207.  
  208.    public boolean isSeq() {
  209.       return this.type == 0;
  210.    }
  211.  
  212.    public boolean isChoice() {
  213.       return this.type == 1;
  214.    }
  215.  
  216.    public Enumeration getPatternTerms() {
  217.       return this.subTermVector.elements();
  218.    }
  219.  
  220.    public boolean matches(String var1) {
  221.       if (this.type == 4) {
  222.          return true;
  223.       } else {
  224.          boolean var2 = false;
  225.          if (this.categories != null) {
  226.             if (var1.length() > 0) {
  227.                for(int var3 = 0; var3 < this.categories.length && !var2; ++var3) {
  228.                   var2 = this.categories[var3] == Character.getType(var1.charAt(0));
  229.                }
  230.             }
  231.          } else {
  232.             for(Enumeration var5 = this.rangeVector.elements(); var5.hasMoreElements() && !var2; var2 = ((CharRange)var5.nextElement()).matches(var1)) {
  233.             }
  234.  
  235.             for(Enumeration var4 = this.subTermVector.elements(); var4.hasMoreElements() && !var2; var2 = ((PatternTerm)var4.nextElement()).matches(var1)) {
  236.             }
  237.          }
  238.  
  239.          if (this.type == 3) {
  240.             var2 = !var2;
  241.          }
  242.  
  243.          if (var2 && this.notTerm != null && this.notTerm.matches(var1)) {
  244.             var2 = false;
  245.          }
  246.  
  247.          return var2;
  248.       }
  249.    }
  250.  
  251.    public boolean intersects(PatternTerm var1) {
  252.       CharPatternTerm var2 = (CharPatternTerm)var1;
  253.       if (this.isLeaf() && var2.isLeaf()) {
  254.          if (this.type == 4 || var2.type == 4) {
  255.             return true;
  256.          }
  257.  
  258.          if (this.type == 3) {
  259.             if (var2.type == 2) {
  260.                return var2.intersects(this);
  261.             }
  262.  
  263.             return false;
  264.          }
  265.  
  266.          if (this.categories != null) {
  267.             if (var2.categories == null) {
  268.                return var2.intersects(this);
  269.             }
  270.  
  271.             for(int var6 = 0; var6 < this.categories.length; ++var6) {
  272.                for(int var8 = 0; var8 < var2.categories.length; ++var8) {
  273.                   if (this.categories[var6] == var2.categories[var8]) {
  274.                      return true;
  275.                   }
  276.                }
  277.             }
  278.  
  279.             return false;
  280.          }
  281.  
  282.          Enumeration var3 = this.rangeVector.elements();
  283.  
  284.          while(var3.hasMoreElements()) {
  285.             CharRange var4 = (CharRange)var3.nextElement();
  286.  
  287.             for(char var5 = var4.getFirst(); var5 <= var4.getLast(); ++var5) {
  288.                if ((this.notTerm == null || !this.notTerm.matches(String.valueOf(var5))) && var2.matches(String.valueOf(var5))) {
  289.                   return true;
  290.                }
  291.             }
  292.          }
  293.  
  294.          Enumeration var7 = this.subTermVector.elements();
  295.  
  296.          while(var7.hasMoreElements()) {
  297.             if (((PatternTerm)var7.nextElement()).intersects(var2)) {
  298.                return true;
  299.             }
  300.          }
  301.       }
  302.  
  303.       return false;
  304.    }
  305.  
  306.    protected boolean isLeaf() {
  307.       return this.type == 4 || this.type == 2 || this.type == 3;
  308.    }
  309.  
  310.    public int getMinOccurrence() {
  311.       return this.minOccurrence;
  312.    }
  313.  
  314.    public int getMaxOccurrence() {
  315.       return this.maxOccurrence;
  316.    }
  317.  
  318.    public String toString() {
  319.       String var1 = "";
  320.       if (this.isChoice()) {
  321.          var1 = String.valueOf(var1).concat(String.valueOf("("));
  322.  
  323.          for(int var2 = 0; var2 < this.subTermVector.size(); ++var2) {
  324.             if (var2 > 0) {
  325.                var1 = String.valueOf(var1).concat(String.valueOf(" | "));
  326.             }
  327.  
  328.             var1 = String.valueOf(var1).concat(String.valueOf(this.subTermVector.elementAt(var2).toString()));
  329.          }
  330.  
  331.          var1 = String.valueOf(var1).concat(String.valueOf(")"));
  332.       } else if (this.isSeq()) {
  333.          var1 = String.valueOf(var1).concat(String.valueOf("("));
  334.  
  335.          for(int var10 = 0; var10 < this.subTermVector.size(); ++var10) {
  336.             if (var10 > 0) {
  337.                var1 = String.valueOf(var1).concat(String.valueOf(", "));
  338.             }
  339.  
  340.             var1 = String.valueOf(var1).concat(String.valueOf(this.subTermVector.elementAt(var10).toString()));
  341.          }
  342.  
  343.          var1 = String.valueOf(var1).concat(String.valueOf(")"));
  344.       } else if (this.type == 4) {
  345.          var1 = "WILDCARD";
  346.       } else if (this.type == 2 && this.subTermVector.size() == 0 && this.rangeVector.size() == 1 && this.rangeVector.elementAt(0).toString().length() == 1) {
  347.          var1 = this.rangeVector.elementAt(0).toString();
  348.       } else {
  349.          var1 = String.valueOf(var1).concat(String.valueOf("["));
  350.          if (this.type == 3) {
  351.             var1 = String.valueOf(var1).concat(String.valueOf("^"));
  352.          }
  353.  
  354.          if (this.categories != null) {
  355.             var1 = String.valueOf(var1).concat(String.valueOf("UnicodeProperty("));
  356.  
  357.             for(int var11 = 0; var11 < this.categories.length; ++var11) {
  358.                var1 = String.valueOf(var1).concat(String.valueOf(String.valueOf(var11 == 0 ? "" : ",").concat(String.valueOf(this.categories[var11]))));
  359.             }
  360.  
  361.             var1 = String.valueOf(var1).concat(String.valueOf(")"));
  362.          }
  363.  
  364.          for(int var12 = 0; var12 < this.rangeVector.size(); ++var12) {
  365.             var1 = String.valueOf(var1).concat(String.valueOf(this.rangeVector.elementAt(var12).toString()));
  366.          }
  367.  
  368.          for(int var3 = 0; var3 < this.subTermVector.size(); ++var3) {
  369.             var1 = String.valueOf(var1).concat(String.valueOf(this.subTermVector.elementAt(var3).toString()));
  370.          }
  371.  
  372.          if (this.notTerm != null) {
  373.             var1 = String.valueOf(var1).concat(String.valueOf(String.valueOf("-").concat(String.valueOf(this.notTerm.toString()))));
  374.          }
  375.  
  376.          var1 = String.valueOf(var1).concat(String.valueOf("]"));
  377.       }
  378.  
  379.       if (this.minOccurrence != 1 || this.maxOccurrence != 1) {
  380.          if (this.minOccurrence == 0 && this.maxOccurrence == 1) {
  381.             var1 = String.valueOf(var1).concat(String.valueOf("?"));
  382.          } else if (this.minOccurrence == 0 && this.maxOccurrence == Integer.MAX_VALUE) {
  383.             var1 = String.valueOf(var1).concat(String.valueOf("*"));
  384.          } else if (this.minOccurrence == 1 && this.maxOccurrence == Integer.MAX_VALUE) {
  385.             var1 = String.valueOf(var1).concat(String.valueOf("+"));
  386.          } else {
  387.             var1 = String.valueOf(var1).concat(String.valueOf(String.valueOf(String.valueOf("{").concat(String.valueOf(this.minOccurrence))).concat(String.valueOf(","))));
  388.             if (this.maxOccurrence != Integer.MAX_VALUE) {
  389.                var1 = String.valueOf(var1).concat(String.valueOf(this.maxOccurrence));
  390.             }
  391.  
  392.             var1 = String.valueOf(var1).concat(String.valueOf("}"));
  393.          }
  394.       }
  395.  
  396.       return var1;
  397.    }
  398. }
  399.