예제 #1
0
 /**
  * Returns a new automaton that accepts strings representing decimal non-negative integers in the
  * given interval.
  *
  * @param min minimal value of interval
  * @param max maximal value of inverval (both end points are included in the interval)
  * @param digits if >0, use fixed number of digits (strings must be prefixed by 0's to obtain the
  *     right length) - otherwise, the number of digits is not fixed
  * @throws IllegalArgumentException if min>max or if numbers in the interval cannot be expressed
  *     with the given fixed number of digits
  */
 public static DefaultAutomaton makeInterval(int min, int max, int digits)
     throws IllegalArgumentException {
   DefaultAutomaton a = new DefaultAutomaton();
   String x = Integer.toString(min);
   String y = Integer.toString(max);
   if (min > max || (digits > 0 && y.length() > digits)) throw new IllegalArgumentException();
   int d;
   if (digits > 0) d = digits;
   else d = y.length();
   StringBuilder bx = new StringBuilder();
   for (int i = x.length(); i < d; i++) bx.append('0');
   bx.append(x);
   x = bx.toString();
   StringBuilder by = new StringBuilder();
   for (int i = y.length(); i < d; i++) by.append('0');
   by.append(y);
   y = by.toString();
   Collection<State> initials = new ArrayList<State>();
   a.initial = between(x, y, 0, initials, digits <= 0);
   if (digits <= 0) {
     ArrayList<StatePair> pairs = new ArrayList<StatePair>();
     for (State p : initials) if (a.initial != p) pairs.add(new StatePair(a.initial, p));
     addEpsilons(a, pairs);
     a.initial.addTransition(new Transition('0', a.initial));
     a.deterministic = false;
   } else a.deterministic = true;
   a.checkMinimizeAlways();
   return a;
 }
예제 #2
0
 /** Returns a new (deterministic) automaton with the empty language. */
 public static DefaultAutomaton makeEmpty() {
   DefaultAutomaton a = new DefaultAutomaton();
   State s = new State();
   a.initial = s;
   a.deterministic = true;
   return a;
 }
예제 #3
0
 /** Returns a new (deterministic) automaton that accepts all strings. */
 public static DefaultAutomaton makeAnyString() {
   DefaultAutomaton a = new DefaultAutomaton();
   State s = new State();
   a.initial = s;
   s.accept = true;
   s.transitions.add(new Transition(Character.MIN_VALUE, Character.MAX_VALUE, s));
   a.deterministic = true;
   return a;
 }
예제 #4
0
 /**
  * Returns a new (deterministic) automaton that accepts a single char whose value is in the given
  * interval (including both end points).
  */
 public static DefaultAutomaton makeCharRange(char min, char max) {
   if (min == max) return makeChar(min);
   DefaultAutomaton a = new DefaultAutomaton();
   State s1 = new State();
   State s2 = new State();
   a.initial = s1;
   s2.accept = true;
   if (min <= max) s1.transitions.add(new Transition(min, max, s2));
   a.deterministic = true;
   return a;
 }
예제 #5
0
 /** Returns a new (deterministic) automaton that accepts a single character in the given set. */
 public static DefaultAutomaton makeCharSet(String set) {
   if (set.length() == 1) return makeChar(set.charAt(0));
   DefaultAutomaton a = new DefaultAutomaton();
   State s1 = new State();
   State s2 = new State();
   a.initial = s1;
   s2.accept = true;
   for (int i = 0; i < set.length(); i++) s1.transitions.add(new Transition(set.charAt(i), s2));
   a.deterministic = true;
   a.reduce();
   return a;
 }
예제 #6
0
 /** Constructs deterministic automaton that matches strings that contain the given substring. */
 public static DefaultAutomaton makeStringMatcher(String s) {
   DefaultAutomaton a = new DefaultAutomaton();
   State[] states = new State[s.length() + 1];
   states[0] = a.initial;
   for (int i = 0; i < s.length(); i++) states[i + 1] = new State();
   State f = states[s.length()];
   f.accept = true;
   f.transitions.add(new Transition(Character.MIN_VALUE, Character.MAX_VALUE, f));
   for (int i = 0; i < s.length(); i++) {
     Set<Character> done = new HashSet<Character>();
     char c = s.charAt(i);
     states[i].transitions.add(new Transition(c, states[i + 1]));
     done.add(c);
     for (int j = i; j >= 1; j--) {
       char d = s.charAt(j - 1);
       if (!done.contains(d) && s.substring(0, j - 1).equals(s.substring(i - j + 1, i))) {
         states[i].transitions.add(new Transition(d, states[j]));
         done.add(d);
       }
     }
     char[] da = new char[done.size()];
     int h = 0;
     for (char w : done) da[h++] = w;
     Arrays.sort(da);
     int from = Character.MIN_VALUE;
     int k = 0;
     while (from <= Character.MAX_VALUE) {
       while (k < da.length && da[k] == from) {
         k++;
         from++;
       }
       if (from <= Character.MAX_VALUE) {
         int to = Character.MAX_VALUE;
         if (k < da.length) {
           to = da[k] - 1;
           k++;
         }
         states[i].transitions.add(new Transition((char) from, (char) to, states[0]));
         from = to + 2;
       }
     }
   }
   a.deterministic = true;
   return a;
 }
예제 #7
0
 /** Returns a new (deterministic) automaton that accepts a single character of the given value. */
 public static DefaultAutomaton makeChar(char c) {
   DefaultAutomaton a = new DefaultAutomaton();
   a.singleton = Character.toString(c);
   a.deterministic = true;
   return a;
 }
예제 #8
0
 /** Returns a new (deterministic) automaton that accepts only the empty string. */
 public static DefaultAutomaton makeEmptyString() {
   DefaultAutomaton a = new DefaultAutomaton();
   a.singleton = "";
   a.deterministic = true;
   return a;
 }
예제 #9
0
 /** Returns a new (deterministic) automaton that accepts the single given string. */
 public static DefaultAutomaton makeString(String s) {
   DefaultAutomaton a = new DefaultAutomaton();
   a.singleton = s;
   a.deterministic = true;
   return a;
 }