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 / RegExpr.class (.txt) < prev   
Encoding:
Java Class File  |  2000-06-30  |  9.3 KB  |  462 lines
  1. package com.extensibility.util.regexpr;
  2.  
  3. import com.extensibility.util.Debug;
  4.  
  5. public class RegExpr {
  6.    static final char NEWLINE = '\n';
  7.    static final char RETURN = '\r';
  8.    static final char TAB = '\t';
  9.    static final char ESCAPE = '\\';
  10.    static final char WILDCARD = '.';
  11.    static final char RANGE = '-';
  12.    // $FF: renamed from: OR char
  13.    static final char field_0 = '|';
  14.    static final char NOT = '^';
  15.    static final char ZERO_OR_ONE = '?';
  16.    static final char ZERO_OR_MORE = '*';
  17.    static final char ONE_OR_MORE = '+';
  18.    static final char LBRACE = '{';
  19.    static final char RBRACE = '}';
  20.    static final char LPAREN = '(';
  21.    static final char RPAREN = ')';
  22.    static final char LBRACKET = '[';
  23.    static final char RBRACKET = ']';
  24.    static final char MINUS = '-';
  25.    static final char REFERENCE = '&';
  26.  
  27.    public static PatternTerm parse(String var0) {
  28.       return parse((PatternInput)(new CharPatternInput(var0)));
  29.    }
  30.  
  31.    public static PatternTerm parse(PatternInput var0) {
  32.       if (!var0.hasNext()) {
  33.          return null;
  34.       } else {
  35.          CharPatternTerm var1 = parseExpr(var0);
  36.          if (var0.hasNext()) {
  37.             throw new RuntimeException("invalid pattern: unused input remaining");
  38.          } else {
  39.             return var1;
  40.          }
  41.       }
  42.    }
  43.  
  44.    protected static CharPatternTerm parseExpr(PatternInput var0) {
  45.       CharPatternTerm var1 = null;
  46.       CharPatternTerm var2 = parseBranch(var0);
  47.       if (var2 != null && peekIs(var0, '|')) {
  48.          if (var1 == null) {
  49.             var1 = new CharPatternTerm(1);
  50.          }
  51.  
  52.          var1.addSubTerm(var2);
  53.  
  54.          while(peekIs(var0, '|')) {
  55.             var0.next();
  56.             var2 = parseBranch(var0);
  57.             if (var2 == null) {
  58.                throw new RuntimeException("invalid pattern: empty branch");
  59.             }
  60.  
  61.             var1.addSubTerm(var2);
  62.          }
  63.       } else {
  64.          var1 = var2;
  65.       }
  66.  
  67.       return var1;
  68.    }
  69.  
  70.    protected static CharPatternTerm parseBranch(PatternInput var0) {
  71.       CharPatternTerm var1 = null;
  72.       CharPatternTerm var2 = parsePiece(var0);
  73.       if (var2 != null && var0.hasNext() && !peekIs(var0, '|') && !peekIs(var0, ')')) {
  74.          if (var1 == null) {
  75.             var1 = new CharPatternTerm(0);
  76.          }
  77.  
  78.          var1.addSubTerm(var2);
  79.  
  80.          while(var0.hasNext() && !peekIs(var0, '|') && !peekIs(var0, ')')) {
  81.             var2 = parsePiece(var0);
  82.             var1.addSubTerm(var2);
  83.          }
  84.       } else {
  85.          var1 = var2;
  86.       }
  87.  
  88.       return var1;
  89.    }
  90.  
  91.    protected static CharPatternTerm parsePiece(PatternInput var0) {
  92.       CharPatternTerm var1 = parseAtom(var0);
  93.       if (var1 == null) {
  94.          throw new RuntimeException("invalid pattern: empty atom");
  95.       } else {
  96.          if (var0.hasNext()) {
  97.             String var2 = var0.peekNext();
  98.             char var3 = var2.charAt(0);
  99.             if (var3 == '?') {
  100.                var1.setOccurrence(0, 1);
  101.                var0.next();
  102.             } else if (var3 == '*') {
  103.                var1.setOccurrence(0, Integer.MAX_VALUE);
  104.                var0.next();
  105.             } else if (var3 == '+') {
  106.                var1.setOccurrence(1, Integer.MAX_VALUE);
  107.                var0.next();
  108.             } else if (var3 == '{') {
  109.                var0.next();
  110.                int var4 = parseInt(var0);
  111.                if (!peekIs(var0, ',')) {
  112.                   throw new RuntimeException("invalid qualifier: no comma");
  113.                }
  114.  
  115.                var0.next();
  116.                int var5;
  117.                if (peekIs(var0, '}')) {
  118.                   var5 = Integer.MAX_VALUE;
  119.                } else {
  120.                   var5 = parseInt(var0);
  121.                }
  122.  
  123.                if (var5 > var4 || var4 < 0) {
  124.                   throw new RuntimeException("invalid qualifier: bad range");
  125.                }
  126.  
  127.                if (!peekIs(var0, '}')) {
  128.                   throw new RuntimeException("invalid qualifier: missing closure");
  129.                }
  130.  
  131.                var0.next();
  132.             }
  133.          }
  134.  
  135.          return var1;
  136.       }
  137.    }
  138.  
  139.    protected static CharPatternTerm parseAtom(PatternInput var0) {
  140.       if (peekIs(var0, '(')) {
  141.          var0.next();
  142.          CharPatternTerm var6 = parseExpr(var0);
  143.          if (!peekIs(var0, ')')) {
  144.             throw new RuntimeException("invalid atom: missing closure");
  145.          } else {
  146.             var0.next();
  147.             return var6;
  148.          }
  149.       } else if (peekIs(var0, '[')) {
  150.          return parseCharExpr(var0);
  151.       } else if (!peekIs(var0, '&')) {
  152.          if (!var0.hasNext()) {
  153.             throw new RuntimeException("invalid atom: empty");
  154.          } else {
  155.             CharPatternTerm var5 = new CharPatternTerm(2);
  156.             parseChar(var0, var5);
  157.             return var5;
  158.          }
  159.       } else {
  160.          var0.next();
  161.          if (!peekIs(var0, '#')) {
  162.             throw new RuntimeException("invalid character reference: missing #");
  163.          } else {
  164.             var0.next();
  165.             int var1 = 0;
  166.             byte var2 = 10;
  167.             if (peekIs(var0, 'x')) {
  168.                var0.next();
  169.                var2 = 16;
  170.             }
  171.  
  172.             while(var0.hasNext() && !peekIs(var0, ';')) {
  173.                String var3 = var0.next();
  174.                char var4 = var3.charAt(0);
  175.                var1 = var1 * var2 + Character.digit(var4, var2);
  176.             }
  177.  
  178.             if (!peekIs(var0, ';')) {
  179.                throw new RuntimeException("invalid character reference: missing ;");
  180.             } else {
  181.                var0.next();
  182.                CharPatternTerm var7 = new CharPatternTerm(2);
  183.                var7.addChar((char)var1);
  184.                return var7;
  185.             }
  186.          }
  187.       }
  188.    }
  189.  
  190.    protected static CharPatternTerm parseCharExpr(PatternInput var0) {
  191.       var0.next();
  192.       boolean var1 = peekIs(var0, '^');
  193.       if (var1) {
  194.          var0.next();
  195.       }
  196.  
  197.       int var2 = var1 ? 3 : 2;
  198.       CharPatternTerm var3 = new CharPatternTerm(var2);
  199.       if (peekIs(var0, '[')) {
  200.          CharPatternTerm var4 = parseCharExpr(var0);
  201.          var3.addSubTerm(var4);
  202.          if (peekIs(var0, '-')) {
  203.             var0.next();
  204.             CharPatternTerm var5 = parseCharExpr(var0);
  205.             var3.addNegativeTerm(var5);
  206.          }
  207.  
  208.          if (!peekIs(var0, ']')) {
  209.             throw new RuntimeException("invalid subtraction expr: missing closure");
  210.          }
  211.       } else {
  212.          do {
  213.             char var6 = 0;
  214.             if (peekIs(var0, '-')) {
  215.                var0.next();
  216.                if (peekIs(var0, '[')) {
  217.                   var3.addNegativeTerm(parseCharExpr(var0));
  218.                   if (!peekIs(var0, ']')) {
  219.                      throw new RuntimeException("invalid expr: expected ']'");
  220.                   }
  221.                } else {
  222.                   var3.addChar('-');
  223.                   var6 = '-';
  224.                }
  225.             } else {
  226.                var6 = parseChar(var0, var3);
  227.             }
  228.  
  229.             if (var6 != 0 && peekIs(var0, '-')) {
  230.                var0.next();
  231.                char var7 = parseChar(var0, var3);
  232.                if (var7 == 0 || var6 > var7) {
  233.                   throw new RuntimeException("invalid character range");
  234.                }
  235.  
  236.                var3.combineRanges();
  237.             }
  238.          } while(!peekIs(var0, ']'));
  239.       }
  240.  
  241.       var0.next();
  242.       return var3;
  243.    }
  244.  
  245.    protected static void parseCharRange(PatternInput var0, CharPatternTerm var1) {
  246.       parseChar(var0, var1);
  247.    }
  248.  
  249.    protected static char parseChar(PatternInput var0, CharPatternTerm var1) {
  250.       String var2 = var0.next();
  251.       char var3 = var2.charAt(0);
  252.       if (var3 == '\\' && var0.hasNext()) {
  253.          var2 = var0.next();
  254.          var3 = var2.charAt(0);
  255.          switch (var3) {
  256.             case '(':
  257.             case ')':
  258.             case '*':
  259.             case '+':
  260.             case '-':
  261.             case '.':
  262.             case '?':
  263.             case '[':
  264.             case '\\':
  265.             case ']':
  266.             case '^':
  267.             case '{':
  268.             case '|':
  269.             case '}':
  270.                var1.addChar(var3);
  271.                break;
  272.             case 'P':
  273.             case 'p':
  274.                var1.addSubTerm(createUnicodeBlockTerm(var3, var0));
  275.                return '\u0000';
  276.             case 'n':
  277.                var1.addChar('\n');
  278.                break;
  279.             case 'r':
  280.                var1.addChar('\r');
  281.                break;
  282.             case 't':
  283.                var1.addChar('\t');
  284.                break;
  285.             default:
  286.                var1.addSubTerm(createXMLTerm(var3));
  287.                return '\u0000';
  288.          }
  289.  
  290.          return var3;
  291.       } else if (var3 == '.') {
  292.          CharPatternTerm var4 = new CharPatternTerm(3);
  293.          var4.addChar('\n');
  294.          var4.addChar('\r');
  295.          var1.addSubTerm(var4);
  296.          return '\u0000';
  297.       } else {
  298.          var1.addChar(var3);
  299.          return var3;
  300.       }
  301.    }
  302.  
  303.    protected static CharPatternTerm createXMLTerm(char var0) {
  304.       Object var1 = null;
  305.       CharPatternTerm var4;
  306.       if (var0 != 's' && var0 != 'i' && var0 != 'c' && var0 != 'd' && var0 != 'W') {
  307.          var4 = new CharPatternTerm(3);
  308.       } else {
  309.          var4 = new CharPatternTerm(2);
  310.       }
  311.  
  312.       var0 = Character.toLowerCase(var0);
  313.       if (var0 == 's') {
  314.          var4.addChar(' ');
  315.          var4.addChar('\n');
  316.          var4.addChar('\r');
  317.          var4.addChar('\t');
  318.       } else if (var0 == 'i') {
  319.          CharPatternTerm var2 = createUnicodePropertyTerm("L");
  320.          var4.addSubTerm(var2);
  321.          var2 = createUnicodePropertyTerm("Nl");
  322.          var4.addSubTerm(var2);
  323.          var4.addChar(':');
  324.          var4.addChar('_');
  325.       } else if (var0 == 'c') {
  326.          CharPatternTerm var6 = createUnicodePropertyTerm("L");
  327.          var4.addSubTerm(var6);
  328.          var6 = createUnicodePropertyTerm("Nl");
  329.          var4.addSubTerm(var6);
  330.          var6 = createUnicodePropertyTerm("Nd");
  331.          var4.addSubTerm(var6);
  332.          var6 = createUnicodePropertyTerm("Mc");
  333.          var4.addSubTerm(var6);
  334.          var6 = createUnicodePropertyTerm("Me");
  335.          var4.addSubTerm(var6);
  336.          var6 = createUnicodePropertyTerm("Mn");
  337.          var4.addSubTerm(var6);
  338.          var6 = createUnicodePropertyTerm("Lm");
  339.          var4.addSubTerm(var6);
  340.          var4.addSubTerm(var6);
  341.          var4.addChar(':');
  342.          var4.addChar('_');
  343.          var4.addChar('-');
  344.          var4.addChar('.');
  345.       } else if (var0 == 'd') {
  346.          CharPatternTerm var13 = createUnicodePropertyTerm("Nd");
  347.          var4.addSubTerm(var13);
  348.       } else {
  349.          if (var0 != 'w') {
  350.             throw new RuntimeException(String.valueOf(String.valueOf("unrecognized escape char: \"").concat(String.valueOf(var0))).concat(String.valueOf("\"")));
  351.          }
  352.  
  353.          CharPatternTerm var14 = createUnicodePropertyTerm("P");
  354.          var4.addSubTerm(var14);
  355.          var14 = createUnicodePropertyTerm("S");
  356.          var4.addSubTerm(var14);
  357.          var14 = createUnicodePropertyTerm("C");
  358.          var4.addSubTerm(var14);
  359.       }
  360.  
  361.       Debug.assert(var4 != null);
  362.       return var4;
  363.    }
  364.  
  365.    protected static CharPatternTerm createUnicodeBlockTerm(char var0, PatternInput var1) {
  366.       if (!peekIs(var1, '{')) {
  367.          throw new RuntimeException(String.valueOf(String.valueOf("expected \"{\" after \"\\").concat(String.valueOf(var0))).concat(String.valueOf("\"")));
  368.       } else {
  369.          var1.next();
  370.          if (!peekIs(var1, 'I')) {
  371.             throw new RuntimeException("block escape must begin with \"Is\"");
  372.          } else {
  373.             var1.next();
  374.             if (!peekIs(var1, 's')) {
  375.                throw new RuntimeException("block escape must begin with \"Is\"");
  376.             } else {
  377.                var1.next();
  378.  
  379.                String var2;
  380.                for(var2 = ""; !peekIs(var1, '}'); var2 = String.valueOf(var2).concat(String.valueOf(var1.next()))) {
  381.                }
  382.  
  383.                if (peekIs(var1, '}')) {
  384.                   var1.next();
  385.                   CharPatternTerm var3 = new CharPatternTerm(var0 == 'p' ? 2 : 3);
  386.                   var3.setBlock(var2);
  387.                   return var3;
  388.                } else {
  389.                   throw new RuntimeException("block escape must end with closing brace");
  390.                }
  391.             }
  392.          }
  393.       }
  394.    }
  395.  
  396.    protected static CharPatternTerm createUnicodePropertyTerm(String var0) {
  397.       CharPatternTerm var1 = new CharPatternTerm(2);
  398.       var1.setCategory(var0);
  399.       return var1;
  400.    }
  401.  
  402.    protected static int parseInt(PatternInput var0) {
  403.       int var1 = 0;
  404.  
  405.       while(var0.hasNext()) {
  406.          char var2 = var0.peekNext().charAt(0);
  407.          if (var2 >= '0' && var2 <= '9') {
  408.             var0.next();
  409.             var1 = 10 * var1 + var2 - 48;
  410.          }
  411.       }
  412.  
  413.       return var1;
  414.    }
  415.  
  416.    static boolean peekIs(PatternInput var0, char var1) {
  417.       return var0.hasNext() && var0.peekNext().charAt(0) == var1;
  418.    }
  419.  
  420.    static void test(String var0, String[] var1) {
  421.       Pattern var2 = new Pattern(var0);
  422.       PatternTerm var4 = parse(var0);
  423.       System.out.println(String.valueOf(String.valueOf(String.valueOf(String.valueOf(String.valueOf("pattern='").concat(String.valueOf(var0))).concat(String.valueOf("' parsed = '"))).concat(String.valueOf(var4 == null ? "" : var4.toString()))).concat(String.valueOf("'"))).concat(String.valueOf(var2.isDeterministic() ? "" : "  non-deterministic")));
  424.  
  425.       for(int var5 = 0; var5 < var1.length; ++var5) {
  426.          boolean var3 = var2.matches(var1[var5]);
  427.          System.out.println(String.valueOf(String.valueOf(String.valueOf("   text='").concat(String.valueOf(var1[var5]))).concat(String.valueOf("' => "))).concat(String.valueOf(var3)));
  428.       }
  429.  
  430.    }
  431.  
  432.    public static void main(String[] var0) {
  433.       test("a|b", new String[]{"ab", "aa", "b"});
  434.       test("ab|ac", new String[]{"ab", "b", "a", "abc", "bc"});
  435.       test("abc", new String[]{"x", "ab", "abc", "abcd"});
  436.       test("a*b", new String[]{"ab", "aa", "b"});
  437.       test("a+b", new String[]{"ab", "aa", "b"});
  438.       test("a+b?", new String[]{"ab", "aa", "b"});
  439.       test("a.b", new String[]{"ab", "aab", "aub"});
  440.       test("a.*b", new String[]{"ab", "baab", "aub", "aaaab", "abacab"});
  441.       test("[0-3]*", new String[]{"121", "a12", "12q", "12301230", "0-2"});
  442.       test("[0-9a-fA-F]+", new String[]{"121", "E12", "12q", "12301230", ""});
  443.       test("0x[0-9a-fA-F]+", new String[]{"0x121", "0b12", "0x12q", "x12301230", ""});
  444.       test("((cat)*(dog)*)*", new String[]{"catcat", "dogdogcat", "catat", "dat", "dogcatdogcatcatdog"});
  445.       test("0|((\\+|\\-)?[1-9][0-9]*)", new String[]{"+0", "012", "-43", "314", "abacab", "+400"});
  446.       test("", new String[]{"ab", ""});
  447.       test("a?.", new String[]{"ab", "", "a", "bb"});
  448.       test("a?.?", new String[]{"ab", "", "a", "bb"});
  449.       test("ab|ac", new String[]{"ab", "b", "a", "abc", "bc"});
  450.       test("([a-z])+", new String[]{"ab", "b", "a", "abc", "bc"});
  451.       test("([a-z-[aeiou]])+", new String[]{"ab", "b", "a", "abc", "bc"});
  452.       test("(AB)+", new String[]{"AB", "ab", "ABA", "ABC", "ABAB"});
  453.       test("a[^a-c]*b", new String[]{"ab", "b", "acb", "awb", "aqweb"});
  454.       test("\\i\\c*", new String[]{"ab", "", "_a1", "1z", "abc:X-1"});
  455.       test("[\\i-[:]][\\c-[:]]*", new String[]{"ab", "", "_a1", "1z", "abc:X-1"});
  456.       test("\\W\\s\\d", new String[]{"; 2", ".\t1", "...", "=2"});
  457.       test("\\p{IsBasicLatin}+", new String[]{"ab", "q¬Æw"});
  458.       test("\\p{IsGreek}\\d", new String[]{"Õ≥5", "Õ¥", "a1"});
  459.       System.out.println("done");
  460.    }
  461. }
  462.