手撸词法生成器(1)...

这两天时间不多啊, 明天下午要考AI了, 没什么时间写这个, 今天抽空把昨天的留下的作业(用C写不下去的那个...)转移到了java上, 只完成了Thompson那一部分, 之后的两部分估计要等考试完再继续了, 因为代码还没写完就不扔github上了... 直接贴代码了 :

包结构如图...

 

Entry 是我用来测试代码的, 暂时可以认为是程序入口...

Dfa.java

package lexerGenerator.dataStructure.dfaAndNfa;

import lexerGenerator.dataStructure.pointsAndEdges.Edge;
import lexerGenerator.dataStructure.pointsAndEdges.State;

public class Dfa {
    public int start;
    public int accept;
    public State state;

    public Dfa() {
        start = -1;
        accept = -1;
        state = null;
    }

    @Override
    public String toString() {
        String str = "";
        str += "start : " + start + "   accept : " + accept + "\n";
        State cur = state;
        while(cur != null){
            Edge edge = cur.edges;
            while(edge != null){
                str += edge.from.num + "---->" + edge.ch + "---->" + edge.to.num + "\n";
                edge = edge.next;
            }
            cur = cur.next;
        }
        return str;
    }
}

 

 

Edge.java

package lexerGenerator.dataStructure.pointsAndEdges;

import lexerGenerator.dataStructure.dfaAndNfa.Dfa;

public class Edge {
    public int ch;
    public State from;
    public State to;
    public Edge next;

    public Edge(State from, State to, int ch) {
        this.from = from;
        this.to = to;
        this.ch = ch;
    }

    public static void addEdge(Dfa dfa, int from, int to, int ch){
        State left = lookUp(dfa, from);
        State right = lookUp(dfa, to);
        if(left.edges == null){
            left.edges = new Edge(left, right, ch);
        }else{
            Edge edge = left.edges;
            while(edge.next != null){
                edge = edge.next;
            }
            edge.next = new Edge(left, right, ch);
        }
    }

    public static State lookUp(Dfa dfa, int num){
        State state = dfa.state;
        if(state == null){
            dfa.state = new State(num);
            return dfa.state;
        }
        while(state != null){
            if(state.num == num){
                return state;
            }
            state = state.next;
        }
        State temp = new State(num);
        dfa.state.append(temp);
        return temp;
    }
}

 

State.java

package lexerGenerator.dataStructure.pointsAndEdges;

public class State {
    public int num;
    public State next;
    public Edge edges;

    public State(int num) {
        this.num = num;
        edges = null;
        next = null;
    }

    public void append(State state){
        State temp = this;
        while(temp.next != null){
            temp = temp.next;
        }

        temp.next = state;
    }
}

 

Re.java

package lexerGenerator.dataStructure.re;

public class Re {


    public static final int EBS = -5;

    public static enum Kind{
        Concat, Option, Closure, Char
    };

    public Kind kind;
}

 

Re_char.java

package lexerGenerator.dataStructure.re;

public class Re_char extends Re{
    public int ch;

    public Re_char(int ch) {
        this.ch = ch;
        kind = Kind.Char;
    }
}

Re_closure.java

package lexerGenerator.dataStructure.re;

public class Re_closure extends Re{
    public Re re;

    public Re_closure(Re re) {
        this.re = re;
        kind = Kind.Closure;
    }
}

 

Re_concat.java

package lexerGenerator.dataStructure.re;



public class Re_concat extends Re{
    public Re left;
    public Re right;

    public Re_concat(Re left, Re right) {
        this.left = left;
        this.right = right;
        kind = Kind.Concat;
    }
}

 

Re_option.java

package lexerGenerator.dataStructure.re;

public class Re_option extends Re{
    public Re left;
    public Re right;

    public Re_option(Re left, Re right) {
        this.left = left;
        this.right = right;
        kind = Kind.Option;
    }
}

 

Thompson.java

package lexerGenerator.thompson;

import lexerGenerator.dataStructure.dfaAndNfa.Dfa;
import lexerGenerator.dataStructure.pointsAndEdges.Edge;
import lexerGenerator.dataStructure.re.*;

public class Thompson {
    public static int num = 0;
    public static Dfa dfa;

    public static Dfa thompson(Re re){
        dfa = new Dfa();
        thompsonLoop(re);
        return dfa;
    }

    static void thompsonLoop(Re re){
        switch (re.kind){
            case Char:
                Re_char re_char = (Re_char)re;
                int from = next();
                int to = next();
                Edge.addEdge(dfa ,from, to, re_char.ch);
                dfa.start = from;
                dfa.accept = to;
                break;
            case Concat:
                Re_concat re_concat = (Re_concat) re;
                thompsonLoop(re_concat.left);
                int preStart = dfa.start;
                int preAccept = dfa.accept;
                thompsonLoop(re_concat.right);
                Edge.addEdge(dfa, preAccept, dfa.start, Re.EBS);
                dfa.start = preStart;
                break;
            case Option:
                Re_option re_option = (Re_option)re;
                thompsonLoop(re_option.left);
                int leftStart = dfa.start;
                int leftAccept = dfa.accept;
                thompsonLoop(re_option.right);
                int newStart = next();
                int newAccept = next();
                Edge.addEdge(dfa, newStart, leftStart, Re.EBS);
                Edge.addEdge(dfa, newStart, dfa.start, Re.EBS);
                Edge.addEdge(dfa, leftAccept, newAccept, Re.EBS);
                Edge.addEdge(dfa, dfa.accept, newAccept, Re.EBS);
                dfa.start = newStart;
                dfa.accept = newAccept;
                break;
            case Closure:
                Re_closure re_closure = (Re_closure) re;
                thompsonLoop(re_closure.re);
                newStart = next();
                newAccept = next();
                Edge.addEdge(dfa, newStart, dfa.start, Re.EBS);
                Edge.addEdge(dfa, newStart, newAccept, Re.EBS);
                Edge.addEdge(dfa, dfa.accept, newAccept, Re.EBS);
                Edge.addEdge(dfa, dfa.accept, dfa.start, Re.EBS);
                dfa.start = newStart;
                dfa.accept = newAccept;
                break;
            default:
                break;
        }
    }

    private static int next(){
        return num++;
    }
}

 

Entry.java

package lexerGenerator;

import lexerGenerator.dataStructure.dfaAndNfa.Dfa;
import lexerGenerator.dataStructure.re.*;
import lexerGenerator.thompson.Thompson;

public class Entry {
    public static void main(String[] args) {
        Re re1 = new Re_closure(new Re_option(new Re_char('a'), new Re_char('b')));
        Dfa dfa = Thompson.thompson(re1);
        System.out.println(dfa);
    }
}

 

代码比较简单, 所以没加注释, 测试结果如下 :

 

考完AI之后再补缺的部分...