Lexical Analyzer Generator

　　This program generates a random Regular Expression in the form of Binary Tree, and repeatedly checks whether an input string match that Regex ("$" as the end of input):

　　(1) Use McNaughton-Yamada-Thompson (MYT) Construction to generate the NFA of the given regex;

　　(2) Use the Subset Construction to generate the DFA from the given NFA;

　　(3) Implement the DFA to check whether an input string match the regex.

import java.util.*;
import java.io.*;

class State {
    public boolean ac;
    public Edge next;
}

class Edge {
    public static Set<Character> digit;
    public static Set<Character> letter;
    public static Set<Character> binop;
    public static Set<Character> uniop;
    public static Set<Character> or;
    public static Set<Character> plus;
    public static Set<Character> star;
    static {
        digit = new HashSet<Character>();
        for (int i=0;i<10;i++) {
            digit.add(new Character((char)('0'+i)));
        }
        letter = new HashSet<Character>();
        for (int i=0;i<26;i++) {
            letter.add(new Character((char)('a'+i)));
            letter.add(new Character((char)('A'+i)));
        }
        binop = new HashSet<Character>();
        binop.add(new Character('|'));
        binop.add(new Character('^'));
        binop.add(new Character('&'));
        binop.add(new Character('+'));
        binop.add(new Character('-'));
        binop.add(new Character('*'));
        binop.add(new Character('/'));
        binop.add(new Character('%'));
        binop.add(new Character('<'));
        binop.add(new Character('>'));
        binop.add(new Character('='));
        uniop = new HashSet<Character>();
        uniop.add(new Character('~'));
        uniop.add(new Character('!'));
        uniop.add(new Character('-'));
        // or, plus and star are just sentinels
        or = new HashSet<Character>();
        plus = new HashSet<Character>();
        star = new HashSet<Character>();
    }

    public Set<Character> data;
    public Edge next;
    public int end;
}

class Node {
    public Set<Character> data;
    public Node left, right;
    
    public Node() {
        int rand = (new Random()).nextInt(16);
        if (rand<2) {
            data = Edge.digit;
        } else if (rand<5) {
            data = Edge.letter;
        } else if (rand<7) {
            data = Edge.binop;
        } else if (rand<8) {
            data = Edge.uniop;
        } else if (rand<11) {
            data = Edge.or;
            left = new Node();
            right = new Node();
        } else if (rand<14) {
            data = Edge.plus;
            left = new Node();
            right = new Node();
        } else {
            data = Edge.star;
            left = new Node();
        }
    }
    public String toString() {
        if (data==Edge.digit) {
            return "DIGIT";
        } else if (data==Edge.letter) {
            return "LETTER";
        } else if (data==Edge.uniop) {
            return "UNIOP";
        } else if (data==Edge.binop) {
            return "BINOP";
        }
        String leftStr="", rightStr="";
        if (left!=null) {
            leftStr = "("+left.toString()+")";
        }
        if (right!=null) {
            rightStr = "("+right.toString()+")";
        }
        if (data==Edge.or) {
            return leftStr+"|"+rightStr;
        } else if (data==Edge.star) {
            return leftStr+"*";
        } else {
            return leftStr+rightStr;
        }
    }
}

class NFA {
    private List<State> state;
    
    public NFA(Node root) {
        state = new LinkedList<State>();
        state.add(new State());    // start
        state.add(new State());    // final
        state.get(1).ac = true;
        preOrder(root,0,1);
    }
    private void preOrder(Node sub,int from,int to) {
        // MYT Construction: regex -> NFA
        if (sub.data==Edge.or) {
            preOrder(sub.left,from,to);
            preOrder(sub.right,from,to);
        } else if (sub.data==Edge.plus) {
            int mid = insertState();
            preOrder(sub.left,from,mid);
            preOrder(sub.right,mid,to);
        } else if (sub.data==Edge.star) {
            int a = insertState();
            int b = insertState();
            insertEdge(from,null,a);
            insertEdge(b,null,a);
            insertEdge(b,null,to);
            insertEdge(from,null,to);
            preOrder(sub.left,a,b);
        } else {
            insertEdge(from,sub.data,to);
        }
    }
    private int insertState() {
        // Insert a new state and return its index:
        state.add(new State());
        return state.size()-1;
    }
    private void insertEdge(int idx,Set<Character> data,int end) {
        // Insert an Edge: NTran[idx,end] = data
        Edge e = new Edge();
        e.data = data;
        e.next = state.get(idx).next;
        e.end = end;
        state.get(idx).next = e;
    }
    public List<State> getStates() {
        return state;
    }
}

class DFA {
    private List<State> dState;
    private List<State> nState;
    private List<Set<State>> nSet;
    private Queue<Integer> q;
    private List<Boolean> vis;
    
    public DFA(Node root) {
        nState = (new NFA(root)).getStates();
        dState = new LinkedList<State>();
        nSet = new LinkedList<Set<State>>();
        q = new LinkedList<Integer>();
        vis = new LinkedList<Boolean>();
        bfs();
    }
    private void bfs() {
        // Create the first dState:
        dState.add(new State());
        nSet.add(new HashSet<State>());
        addClosure(nState.get(0),nSet.get(0));
        // Breadth-First Search:
        q.add(new Integer(0));
        vis.add(new Boolean(false));
        while (!q.isEmpty()) {
            int idx = q.poll().intValue();
            if (!vis.get(idx)) {
                vis.set(idx, new Boolean(true));
                addTrans(idx,Edge.digit);
                addTrans(idx,Edge.letter);
                addTrans(idx,Edge.binop);
                addTrans(idx,Edge.uniop);
            }
        }
    }
    private void addTrans(int idx,Set<Character> data) {
        // Add to set all nStates that can be accessed from start through data:
        Set<State> set = new HashSet<State>();
        for (State nstate:nSet.get(idx)) {
            Edge itr = nstate.next;
            while (itr!=null) {
                if (itr.data==data) {
                    addClosure(nState.get(itr.end),set);
                }
                itr = itr.next;
            }
        }
        if (!set.isEmpty()) {
            for (int i=0;i<nSet.size();i++) {
                // If set exists in nSet, only insert an edge:
                if (nSet.get(i).equals(set)) {
                    insertEdge(idx,data,i);
                    return;
                }
            }
            insertEdge(idx,data,dState.size());
            dState.add(new State());
            nSet.add(set);
            for (State itr:set) {
                // Mark on accepting states:
                if (itr.ac) {
                    dState.get(dState.size()-1).ac = true;
                    break;
                }
            }
            q.add(new Integer(dState.size()-1));
            vis.add(new Boolean(false));
        }
    }
    private void addClosure(State start,Set<State> set) {
        // Add the Epsilon-Closure of nState.get(start) to set:
        set.add(start);
        Edge itr = start.next;
        while (itr!=null) {
            if (itr.data==null && !set.contains(nState.get(itr.end))) {
                addClosure(nState.get(itr.end),set);
            }
            itr = itr.next;
        }
    }
    private void insertEdge(int idx,Set<Character> data,int end) {
        // Insert an Edge: DTran[idx,end] = data
        Edge e = new Edge();
        e.data = data;
        e.next = dState.get(idx).next;
        e.end = end;
        dState.get(idx).next = e;
    }
    public boolean test(int pos,String expr,int i) {
        // Test expr.char(i) at dState.get(pos):
        if (i==expr.length()) {
            return dState.get(pos).ac;
        }
        Edge itr = dState.get(pos).next;
        while (itr!=null) {
            if (itr.data.contains(new Character(expr.charAt(i)))) {
                return test(itr.end,expr,i+1);
            }
            itr = itr.next;
        }
        return false;
    }
}

class Regex {
    private Node root;
    private DFA dfa;
    
    public Regex() {
        root = new Node();
        dfa = new DFA(root);
    }
    public String toString() {
        return root.toString();
    }
    public boolean test(String expr) {
        return dfa.test(0,expr,0);
    }
}

public class LexicalAnalyzer {
    
    public static void main(String[] args) {
        Regex regex = new Regex();
        System.out.println("Regex:	"+regex);
        Scanner in = new Scanner(System.in);
        System.out.print("Test Expressions:
	");
        String expr = in.nextLine();
        while (!expr.equals("$")) {
            if (regex.test(expr)) {
                System.out.print("	ACCEPTED
	");
            } else {
                System.out.print("	WRONG
	");
            }
            expr = in.nextLine();
        }
        in.close();
    }
}

　　I have been determined to refactor this program (I wrote it last year) since I took part in the Touchpal Interview on Wednesday (April 1, 2015) and failed to give a correct answer at that moment.

 1     public static boolean match(String pattern,String expr) {
 2         if (pattern.length()==0) {
 3             return expr.length()==0;
 4         } else if (pattern.charAt(0)=='.') {
 5             return expr.length()>0 
 6                     && match(pattern.substring(1),expr.substring(1));
 7         } else if (pattern.length()==1) {
 8             return expr.equals(pattern);
 9         } else if (pattern.charAt(1)!='*') {
10             return pattern.charAt(0)==expr.charAt(0)
11                     && match(pattern.substring(1),expr.substring(1));
12         } else {
13             if (match(pattern.substring(2),expr)) {
14                 return true;
15             } else if (pattern.charAt(0)==expr.charAt(0)) {
16                 return match(pattern.substring(2),expr.substring(1))
17                         || match(pattern,expr.substring(1));
18             } else {
19                 return false;
20             }
21         }
22     }

References:

　　1. Aho, Alfred V. et al. Compilers: Principles, Techniques, and Tools [M]. 北京：机械工业出版社, 2008-12