rcharacterlist.java

java 编译器java复杂编译器,可以编译java文件的类库

           System.out.println("Before:");
           for (i = 0; i < descriptors.size(); i++)
           {
              if (descriptors.elementAt(i) instanceof SingleCharacter)
              {
                 char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
                 System.out.print((int)c + " ");
              }
              else
              {
                 char l = ((CharacterRange)descriptors.elementAt(i)).left;
                 char r = ((CharacterRange)descriptors.elementAt(i)).right;
      
                 System.out.print((int)l + "-" + (int)r + " ");
              }
              if ((i + 1) % 6 == 0)
                 System.out.println("");
           }
           System.out.println("");
*/

           ToCaseNeutral();
           SortDescriptors();

/*
           System.out.println("After:");
           for (i = 0; i < descriptors.size(); i++)
           {
              if (descriptors.elementAt(i) instanceof SingleCharacter)
              {
                 char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
                 System.out.print((int)c + " ");
              }
              else
              {
                 char l = ((CharacterRange)descriptors.elementAt(i)).left;
                 char r = ((CharacterRange)descriptors.elementAt(i)).right;
      
                 System.out.print((int)l + "-" + (int)r + " ");
              }
              if ((i + 1) % 6 == 0)
                 System.out.println("");
           }
           System.out.println("");
*/
        }

        if (negated_list)
           RemoveNegation();  // This also sorts the list
        else
           SortDescriptors();
     }

     transformed = true;
     Nfa retVal = new Nfa();
     NfaState startState = retVal.start;
     NfaState finalState = retVal.end;
     int i;

     for (i = 0; i < descriptors.size(); i++)
     {
        if (descriptors.elementAt(i) instanceof SingleCharacter)
           startState.AddChar(((SingleCharacter)descriptors.elementAt(i)).ch);
        else // if (descriptors.elementAt(i) instanceof CharacterRange)
        {
           CharacterRange cr = (CharacterRange)descriptors.elementAt(i);

           if (cr.left == cr.right)
              startState.AddChar(cr.left);
           else
              startState.AddRange(cr.left, cr.right);
        }
     }

     startState.next = finalState;

     return retVal;
  }

  static boolean Overlaps(CharacterRange r1, CharacterRange r2)
  {
     return (r1.left <= r2.right && r1.right > r2.right);
  }

  static boolean SubRange(CharacterRange r1, CharacterRange r2)
  {
     return (r1.left >= r2.left && r1.right <= r2.right);
  }

  static boolean InRange(char c, CharacterRange range)
  {
     return (c >= range.left && c <= range.right);
  }

  void SortDescriptors()
  {
     int j;

     Vector newDesc = new Vector(descriptors.size());
     int cnt = 0;

     Outer:
     for (int i = 0; i < descriptors.size(); i++)
     {
        SingleCharacter s;
        CharacterRange range;

        if (descriptors.elementAt(i) instanceof SingleCharacter)
        {
           s = (SingleCharacter)descriptors.elementAt(i);

           for (j = 0; j < cnt; j++)
           {
              if (newDesc.elementAt(j) instanceof SingleCharacter)
              {
                 if (((SingleCharacter)newDesc.elementAt(j)).ch > s.ch)
                    break;
                 else if (((SingleCharacter)newDesc.elementAt(j)).ch == s.ch)
                    continue Outer;
              }
              else
              {
                 char l = ((CharacterRange)newDesc.elementAt(j)).left;

                 if (InRange(s.ch, (CharacterRange)newDesc.elementAt(j)))
                    continue Outer;
                 else if (l > s.ch)
                    break;
              }
           }

           newDesc.insertElementAt(s, j);
           cnt++;
        }
        else
        {
           range = (CharacterRange)descriptors.elementAt(i);

           for (j = 0; j < cnt; j++)
           {
              if (newDesc.elementAt(j) instanceof SingleCharacter)
              {
                 if (InRange(((SingleCharacter)newDesc.elementAt(j)).ch, range))
                 {
                    newDesc.removeElementAt(j--);
                    cnt--;
                 }
                 else if (((SingleCharacter)newDesc.elementAt(j)).ch > range.right)
                    break;
              }
              else
              {
                 if (SubRange(range, (CharacterRange)newDesc.elementAt(j)))
                 {
                    continue Outer;
                 }
                 else if (SubRange((CharacterRange)newDesc.elementAt(j), range))
                 {
                    newDesc.setElementAt(range, j);
                    continue Outer;
                 }
                 else if (Overlaps(range,  (CharacterRange)newDesc.elementAt(j)))
                 {
                    range.left = (char)(((CharacterRange)newDesc.elementAt(j)).right + 1);
                 }
                 else if (Overlaps((CharacterRange)newDesc.elementAt(j), range))
                 {
                    CharacterRange tmp = range;
                    ((CharacterRange)newDesc.elementAt(j)).right = (char)(range.left + 1);
                    range = (CharacterRange)newDesc.elementAt(j);
                    newDesc.setElementAt(tmp, j);
                 }
                 else if (((CharacterRange)newDesc.elementAt(j)).left > range.right)
                    break;
              }
           }

           newDesc.insertElementAt(range, j);
           cnt++;
        }
     }

     newDesc.trimToSize();
     descriptors = newDesc;
  }

  void RemoveNegation()
  {
     int i;

     SortDescriptors();

/*
     System.out.println("REM. NEG Before:");
     for (i = 0; i < descriptors.size(); i++)
     {
        if (descriptors.elementAt(i) instanceof SingleCharacter)
        {
           char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
           System.out.print((int)c + " ");
        }
        else
        {
           char l = ((CharacterRange)descriptors.elementAt(i)).left;
           char r = ((CharacterRange)descriptors.elementAt(i)).right;

           System.out.print((int)l + "-" + (int)r + " ");
        }
     }
     System.out.println("");
*/

     Vector newDescriptors = new Vector();
     int lastRemoved = -1; // One less than the first valid character.

   OuterLoop:
     for (i = 0; i < descriptors.size(); i++)
     {
        if (descriptors.elementAt(i) instanceof SingleCharacter)
        {
           char c = ((SingleCharacter)descriptors.elementAt(i)).ch;

           if (c >= 0 && c <= lastRemoved + 1)
           {
              lastRemoved = c;
              continue;
           }

           //System.out.println("lastRemoved : " + (int)lastRemoved + "; char : "  + (int)c);
           newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
                                         (char)((lastRemoved = c) - 1)));
        }
        else
        {
           char l = ((CharacterRange)descriptors.elementAt(i)).left;
           char r = ((CharacterRange)descriptors.elementAt(i)).right;

           if (l >= 0 && l <= lastRemoved + 1)
           {
              lastRemoved = r;
              continue;
           }

           //System.out.println("lastRemoved : " + (int)lastRemoved + "; left : "  + l + "; right : " + (int)r);
           newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
                                            (char)(l - 1)));
           lastRemoved = r;
        }
     }

     //System.out.println("lastRem : " + (int)lastRemoved);
     if (NfaState.unicodeWarningGiven || Options.B("JAVA_UNICODE_ESCAPE"))
     {
        if (lastRemoved < (char)0xffff)
           newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
                                     (char)0xffff));
     }
     else
     {
        if (lastRemoved < (char)0xff)
           newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
                                                                   (char)0xff));
     }

     descriptors = newDescriptors;
     negated_list = false;

/*
     System.out.println("REM NEG After:");
     for (i = 0; i < descriptors.size(); i++)
     {
        if (descriptors.elementAt(i) instanceof SingleCharacter)
        {
           char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
           System.out.print((int)c + " ");
        }
        else
        {
           char l = ((CharacterRange)descriptors.elementAt(i)).left;
           char r = ((CharacterRange)descriptors.elementAt(i)).right;

           System.out.print((int)l + "-" + (int)r + " ");
        }
     }
     System.out.println("");
*/
  }

  RCharacterList()
  {
  }

  RCharacterList(char c)
  {
     descriptors = new Vector();
     descriptors.addElement(new SingleCharacter(c));
     negated_list = false;
     ordinal = Integer.MAX_VALUE;
  }

  public boolean CanMatchAnyChar()
  {
     // Return true only if it is ~[]
     return negated_list && (descriptors == null || descriptors.size() == 0);
  }
}