LR(1)語法分析器生成器(生成Action表和Goto表)java實現(二)

　　updata : 附我之前bilibili講解視頻鏈接 : https://www.bilibili.com/video/av63666423?share_medium=android&share_source=qq&bbid=PQ0-BzIEPAU2VGNXK1crinfoc&ts=1565782566880

　　目前完成進度 : 目前已經完成了表驅動,通過函數輸出這個Action 和 Goto表。然后使用者就可以根據兩個表來進行LR(1)語法分析。且經過比對,發現和書上的例子(括號語法)是完全吻合的。

　　

package cn.vizdl.LR1.version3;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

/*
項目名 :  LR(1) parser generator (LR(1)語法分析器生成器)
項目分析 : 
    輸入 : 輸入某文件內存地址。且內部采用  <Expr> ::=  <Term> + <Factor>; 的結構輸入的LR(1)語法。
    這里的僅支持 BNF范式內部的 終結符,非終結符,或運算,;(表示產生式結束),::=(表示為定義為)
    在這里不支持閉包,也就是{},因為閉包可以轉換為非終結符的遞歸。
        輸入文本格式 : 要求輸入語法為 無回溯語法,在前瞻一個符號的情況下,總能預測正確的產生式規則。
            start : <aim_name>  //aim_name表示起始符號名稱 
        例子 : 
        //這是錯誤的例子,不符合LR(1)語法
            start : <Goal>;
            <Goal> ::= <Expr>;
            <Expr> ::= <Expr> "+" <Term> | <Expr> "-" <Term>;
            <Term> ::= <Term> "*" <Factor> | <Term> "/" <Factor>;
            <Factor> ::= "number";
            #
            
            
            start : <Goal>;
            <Goal> ::= <Expr>;
            <Expr> ::= <Term><Expr'>;
            <Expr'> ::= "+" <Term><Expr'> 
                    |    "-" <Term><Expr'> 
                    |    "ε";
            <Term> ::= <Factor><Term'>;
            <Term'> ::= "*" <Factor><Term'>
                    |    "/" <Factor><Term'>
                    |    "ε";
            <Factor> ::= "("<Expr>")"
                    |    "num"
                    |    "name";
            #
            
            
            start : <Goal>;
            <Goal> ::= <List>;
            <List> ::= <List><Pair>
                    |    <Pair>;
            <Pair> ::= "(" <Pair> ")"
                    |    "("")";
            #
        以#作為結尾
    輸入分析 : 因為上下文無關語法是一個四元組,而LR(1)語法又是上下文無關語法的子集。所以采用四元組的形式來表示LR(1)語法,是不會損失信息的。
        四元組 (T,NT,S,P)
        T ： 終結符集合
        NT : 非終結符集合
        S : 語法的起始符號(非終結符)
        P : 產生式集合 
        T, NT都可以用一個hash_set來表示。
        P 可以分為兩個部分,左側一定是一個非終結符,右側是一個支持或運算的產生式。 
        產生式左端可以使用Node節點來表示,產生式右端可以使用多個鏈表(具體有幾個取決於當前產生式有多少個或運算符)來表示。
        將當下語法分為三級,第一級是Expr,第二級別是Term,第三個級別是Factor
        <Expr> ::= <Term> { "|" <Term>}; //產生式(表達式)可以表達成多個小句子 或 起來
        <Term> ::= <Factor> { "+" <Factor>}; // + 表示連接
        <Factor> ::= <T> | <NT>
    輸出 : Action 和 GoTo 表。 
    
    1.0完成進度 : 完成了將 輸入字符串 轉換成了 中間數據結構(BnfContainer)表示。
    2.0完成進度 : closure()閉包函數
    在這里 [A -> β·Cθ,a]指的是,識別完了A后非終結符號為a(也就是LR(1)中的1,前瞻一個符號)。
    關於FIRST : 
        FIRST(A) : 對於語法符號A,FIRST(A)表示,從A推導出的符號串的第一個單詞所對應的終結符的集合。
        FIRST定義域 : T ∪ NT ∪ {ε, eof}
        FIRST值域 : T ∪ {ε, eof}
        如若A等於T ∪ {ε, eof}
        那么 FIRST(A) = A
    在閉包函數中,難點在於 FIRST(θa),這不是一個簡單的 FIRST(θ),因為多了一個非終結符號 a。
    這是為了防止FIRST(θ)為ε的情況,這樣FIRST(θa)退化為FIRST(a) = {a}
    closure(s) : 
    while (s is still changing)
        for each item [A -> β·Cθ,a] ∈ s        //從當前s集中尋求新狀態
            for each production C -> γ ∈ P  //有效產生式
                for each b ∈ FIRST(θa)        //如若是可能是前瞻符號(非終結符)
                    s <- s ∪ {[C -> ·γ,b]}
                    
    //這里x是語法符號,可以是終結符,也可以是非終結符
    goto(s, x)
    moved <- ∅
    for each item ∈ s        //對於s集中的每個項
        if the from of i is [A -> β·xθ,a] then
            moved <- moved ∪ {[A -> βx·θ,a]}
    return closure (moved)
    
    構建CC的算法:
    CC0 <- closure({[S' -> ·S,eof]}) //構建初始狀態集
    CC <- {CC0}        //將初始狀態集添加到規范族CC中
    while (new set are still being added to CC)        
        for each unmarked set CCi ∈ CC    //unmarked : 未標記的
            mark CCi as processed    //將CCi標記為處理過的
            for each x following a · in an item in CCi  //對於CCi中項a ·后面的每個x
                temp <- goto(CCi, x)
                if temp ∉ CC
                    then CC <- CC ∪ {temp}
                record transition from CCi to temp on x
    例子 : 
    <Goal> ::= <List>;
    <List> ::= <List> <Pair> | <Pair>;
    <Pair> ::= "(" <Pair> ")" | "(" ")";
    closure({[Goal -> ·List,eof]})
    
    理解 : 將整個BNF范式語句全都替換成非終結符,結果可能會有很多個。
    但是這可以組成一個DFA,但是許多項都表示的其實是同一種狀態,所以需要
    closure來將這些狀態來並到同一個集合內,而goto則是從某個狀態集接各種符號
    ,轉移到一個新的狀態集,這里即可以是終結符,也可以是非終結符。但是轉移后不一定
    能包含所有的這一狀態下的項,所以仍需要閉包運算來完善狀態集。
    
    如何表示一個項？
    一個項包含三個元素,第一是產生式,第二是 · ,第三是前瞻符號。
    這可以用三個數字來表示。可以使用一個NODE來表示,
    但是這樣好像就用不了set,來篩選是否重合了。
    字符串表示法？
    使用字符串,並且兩個中隔符號隔開三個數據。
    如若需要,再從字符串轉換為數字。
    
    3.0版本完成進度 :
    填表算法 : 
    Action表  縱軸是狀態,橫軸是 前瞻符號(終結符),內容是規約,狀態轉移,接收以及失敗。
    Goto表  縱軸是狀態,橫軸是 前瞻符號(非終結符),當進行規約操作后,可以依靠棧中之前的狀態,
    加上前瞻的非終結符,來進行狀態轉移。
    
    for each CCi ∈ CC
        for each  item I ∈ CCi
            if I is [A -> β·cθ,a] and goto (CCi , c) = CCj then
                Action[i,c] <- "shift j"
            else if I is [A -> β·,a] then    //規約
                Action[i,a] <- "reduce A->B"
            else if I is [S'->S·,eof] then    //如若是目標項產生式推導完成狀態並且前瞻符號為eof,則為接收狀態。
                Action[i,eof] <- "accept"
        for each n ∈ NT                //如若項集CCi跳過一個非終結符n即到達j
            if goto(CCi, n) = CCj then
                Goto[i,n] <- j
                
    如何表示幾種狀態?
    可以使用位來保證兩種狀態不混合, shift j直接填入j,而reduce A -> B則或上整型最高位。
這個圖的狀態 對應 書上狀態
0 - 0
1 - 1
6 - 6
這里r是產生式下標...,而不是表達式下標...。
因為我們采用的結構是產生式 -> 表達式,也就是一個產生式連接多個表達式。

本圖 對應 書上圖(狀態)
0 - 0
1 - 1
6 - 6
4 - 4
11 - 11
9 - 9
2 - 3
3 - 2
5 - 7
7 - 5
10 - 8
8 - 10
Action表如下
    eof    (    )    
0    err    s2    err    
1    acc    s2    err    
2    err    s6    s5    
3    r3    r3    err    
4    r2    r2    err    
5    r5    r5    err    
6    err    s6    s8    
7    err    err    s10    
8    err    err    r5    
9    err    err    s11    
10    r4    r4    err    
11    err    err    r4    
Goto表如下
    Goal    List    Pair    
0    err    s1    s3    
1    err    err    s4    
2    err    err    s7    
3    err    err    err    
4    err    err    err    
5    err    err    err    
6    err    err    s9    
7    err    err    err    
8    err    err    err    
9    err    err    err    
10    err    err    err    
11    err    err    err    


*/ 
public class Demo2 {
    public static void main (String[] args) {
        //將輸入的產生式都放入ch中
        Scanner scanner = new Scanner(System.in);
        String s = new String();
        String c;
        //輸入處理...
        while (true) {
            c = scanner.nextLine();
            int i;
            for (i = 0; i < c.length(); i++) {
                if (c.charAt(i) != '#')
                    s += c.charAt(i);
                else {
                    scanner.close();
                    break;
                }
            }
            if (i != c.length()) {
                break;
            }
        }
        BnfContainer bc = new BnfContainer();
        CodeAnalyzer ca = new CodeAnalyzer(s, bc);
        ca.analyze();
        bc.toLRTable();
        bc.printActionAndGotoTable();
    }
}

/**
 * 用來裝載BNF范式的信息。
 */
class BnfContainer {
    /**
     * 內部類,NT的節點。
     * @author HP
     */
    class NTNode {
        private String name; //符號id
        private List<List<Integer>> expr;
        public NTNode(String name) {
            expr = new ArrayList<List<Integer>>();
            this.name = name;
        }
        /**
         * 添加一條expr
         * 返回這個expr的下標
         * @return
         */
        public int addExpr() {
            expr.add(new ArrayList<Integer>());
            return expr.size() - 1;
        }
        /**
         * 向下標為idx的expr添加value
         * @param idx
         * @param value
         */
        public void addExprElement (int idx, int value) {
            this.expr.get(idx).add(value);
        }
        /**
         * 向最后一個表達式添加value
         * @param value
         */
        public void addExprElement (int value) {
            this.addExprElement(this.expr.size() - 1, value);
        }
        
        public void printNTNode () {
            System.out.println("NTNumber : " + this.name);
            for (List<Integer> list : this.expr) {
                for (Integer val : list) {
                    System.out.print(val + " ");
                }System.out.println();
            }
        }
    }
    
    
    //常量定義
    /**
     * 這兩個常量只出現在終結符
     * 因為要將終結符和非終結符
     * 放在同一個鏈表中
     * 所以使用這個來辨別終結符和非終結符。
     */
    private static final int MASK = 0X80000000; //掩碼,用來給終結符做掩飾的編碼。
    private static final int DECODE = 0X7fffffff; //解碼,破譯掩碼得到原本的編碼。
    private static final String separationCharacter = " ";
    /**
     * 非終結符Map 
     * key : 非終結符名稱
     * value : 非終結符在production鏈表中的下標
     */
    private HashMap<String,Integer> NTMap;
    /**
     * 終結符Map 
     * key : 終結符名稱
     * value : 終結符在T鏈表中的下標
     */
    private HashMap<String,Integer> TMap;
    // 終結符鏈表
    private ArrayList<String> T;
    // 產生式鏈表,因為一個非終結符一個產生式具有雙射關系。
    private ArrayList<NTNode> production;
    //如若未設置,默認為0
    public int startIndex = 0;
    private int eof, epsilon;
    /**
     * 這個數組包含了所有非終結符的FIRST
     */
    private Set<Integer>[] First;
    /**
     * 要輸出的Action表
     */
    private int[][] Action;
    /**
     * 要輸出的Goto表
     */
    private int[][] Goto;
    
    public BnfContainer() {
        //內部數據結構初始化
        NTMap = new HashMap<String,Integer>();
        TMap = new HashMap<String,Integer>();
        T = new ArrayList<String>();
        production = new ArrayList<NTNode>();
        
        
        //添加兩個特殊的非終結符 eof 和 ε
        this.addT("eof");
        this.addT("ε");
        eof = this.getTSerialNumber("eof");
        epsilon = this.getTSerialNumber("ε");
    }
    
    /**
     * 設置開始非終結符
     * @param name
     */
    public void setStart (String name) {
        this.addNT(name);
        this.startIndex = this.NTMap.get(name);
    }
    
    /**
     * 將非終結符的名字傳入,即可添加一個非終結符節點。
     * @param name
     */
    public void addNT (String name) {
        if (name.isEmpty()) {
            System.out.println("終結符不可為空");
            System.exit(-1);
        }
        if (!NTMap.containsKey(name)) {
            NTNode node = new NTNode(name);
            NTMap.put(name, production.size());
            production.add(node);
        }
    }
    
    /**
     * 將終結符傳入,增加非終結符。
     * @param name
     */
    public void addT(String name) {
        if (!this.TMap.containsKey(name)) {
            this.TMap.put(name, T.size());
            this.T.add(name);
        }
    }
    
    /**
     * 輸入終結符名稱
     * 獲取終結符編號
     * 如若存在當前終結符,返回編號
     * 否則返回-1,輸出錯誤警告並且退出。
     * @param name
     * @return
     */
    private int getTSerialNumber (String name) {
        this.notFindTWarning(name);
        return this.TMap.get(name) | BnfContainer.MASK;
    }
    
    /**
     * 輸入非終結符名稱
     * 獲取非終結符編號
     * 如若存在當前非終結符,返回編號
     * 否則返回-1,輸出錯誤警告並且退出。
     * @param name
     * @return
     */
    private int getNTSerialNumber (String name) {
        this.notFindNTWarning(name);
        return this.NTMap.get(name);
    }
    
    /**
     * 創建新的表達式並添加到名稱為name的非終結符節點上
     * 返回表達式編號
     */
    public int creatNewExper(String name) {
        this.notFindNTWarning(name);
        NTNode ntn = this.production.get(this.NTMap.get(name));
        return ntn.addExpr();
    }
    /**
     * 向左端非終結符名稱為name的產生式
     * 第idx表達式添加元素
     * @param name
     * @param idx
     * @param isNt
     */
    public void addExpeElement(String name, int idx,boolean isNt, String addElement) {
        NTNode ntn = this.production.get(this.NTMap.get(name));
        if (isNt) {
            this.notFindNTWarning(name);
            this.notFindNTWarning(addElement);
            ntn.addExprElement(idx, this.getNTSerialNumber(addElement));
        }else {
            this.addT(addElement);
            ntn.addExprElement(idx, this.getTSerialNumber(addElement));
        }
    }
    
    /**
     * 向左端非終結符名稱為name的產生式
     * 最后一個表達式添加元素
     * @param name
     * @param list
     */
    public void addExpeElement(String name,boolean isNt, String addElement) {
        NTNode ntn = this.production.get(this.NTMap.get(name));
        if (isNt) {
            this.notFindNTWarning(name);
            this.notFindNTWarning(addElement);
            ntn.addExprElement(this.getNTSerialNumber(addElement));
        }else {
            this.addT(addElement);
            ntn.addExprElement(this.getTSerialNumber(addElement));
        }
    }
    
    /**
     * 如若找到了當前非終結符,什么都不會發生。
     * 否則會提示並且退出程序
     * @param name
     */
    private void notFindNTWarning(String name) {
        if (!this.NTMap.containsKey(name)) {
            System.out.println("錯誤的非終結符" + name + "!");
            System.exit(-1);
        }
    }
    /**
     * 如若找到了當前終結符,什么都不會發生。
     * 否則會提示並且退出程序
     * @param name
     */
    private void notFindTWarning(String name) {
        if (!this.TMap.containsKey(name)) {
            System.out.println("錯誤的終結符" + name + "!");
            System.exit(-1);
        }
    }

    public void printBNF() {
        System.out.println("開始非終結符為 : " + this.production.get(startIndex).name);
//        System.out.println("終結符對應表 : ");
//        for (int i = 0; i < this.T.size(); i++) {
//            System.out.println(this.T.get(i) + " : " + (i | MASK));
//        }
//        System.out.println("非終結符對應表 : ");
//        for (int i = 0; i < this.production.size(); i++) {
//            System.out.println(this.production.get(i).name + " : " + i);
//        }
        for (NTNode ntn : this.production) {
            ntn.printNTNode();
        }
        
        System.out.println("First集 : ");
        int count = 0;
        for (Set<Integer> s : First) {
            System.out.println("第" + count + "個非終結符" + this.production.get(count).name);
            for (Integer i : s) {
                this.printSymbol(i);
            }System.out.println();
            count++;
        }
        System.out.println("一共有 " + this.CC.size() + " 種狀態");
        for (Set<String> s : this.CC) {
            this.printCCSet(s);
        }
    }
    /**
     * 輸出項集 s
     * @param s
     */
    private void printCCSet(Set<String> s) {
        for (String item : s) {
            this.printItem(item);
        }
        System.out.println();
    }
    
    
    private void printItem (String item) {
        String[] strs = item.split(BnfContainer.separationCharacter); // ! 為分隔符
        int productionIdx = Integer.parseInt(strs[0]); //產生式下標
        int exprIdx = Integer.parseInt(strs[1]); //表達式下標
        int placeholder = Integer.parseInt(strs[2]); //占位符下標 這個下標從0開始(表示左側無語法符號)。
        int prospectiveSymbol = Integer.parseInt(strs[3]);//前瞻符
        NTNode ntn = this.production.get(productionIdx);
        System.out.print("[" + ntn.name + "::=");
        List<Integer> list = ntn.expr.get(exprIdx);
        for (int i = 0; i < list.size(); i++) {
            if (i == placeholder) {
                System.out.print("·");
            }
            this.printSymbol(list.get(i));
            System.out.print(" ");
        }
        if (list.size() == placeholder) {
            System.out.print("·");
        }
        System.out.print(",");
        this.printSymbol(prospectiveSymbol);
        System.out.print("]\t");
    }
    
    private void printSymbol (int sym) {
        if (this.isT(sym)) {
            System.out.print(this.T.get(sym & DECODE));
        }else {
            System.out.print(this.production.get(sym).name);
        }
    }
    
    /**
     * 求所有非終結符符號的FIRST集(終結符的FIRST就是它本身)
     * FIRST(A) : 對於語法符號A,FIRST(A)表示,
     * 從A推導出的符號串的第一個單詞所對應的終結符的集合。
     */
    private void FIRSTAllSymbol() {
        First = new Set[this.production.size()];
        for (int i = First.length - 1; i >= 0; i--) {
            FIRST(i);
        }return;
    }
    /**
     * 輸入非終結符下標
     */
    private void FIRST(int idx) {
        if (First[idx] != null) {
            return;
        }First[idx] = new HashSet<Integer>();
        List<List<Integer>> next = this.production.get(idx).expr;
        for (List<Integer> list : next) {
            int val = list.get(0);
            //非終結符
            if (this.isT(val)) {
                First[idx].add(val);
            }else {
                this.FIRST(val);
                First[idx].addAll(First[val]);
            }
        }
    }
    
    private boolean isT (int val) {
        return (val & MASK) == MASK;
    }
    /**
     * 一個產生式項
     * 分別有四個元素
     * productionIdx : 產生式下標
     * exprIdx : 表達式下標
     * placeholder : 占位符
     * prospectiveSymbol : 前瞻符
     */
    /**
    閉包運算
    closure(s) : 
    while (s is still changing)
        for each item [A -> β·Cθ,a] ∈ s        //從當前s集中尋求新狀態
            for each production C -> γ ∈ P  //有效產生式
                for each b ∈ FIRST(θa)        //如若是可能是前瞻符號(非終結符)
                    s <- s ∪ {[C -> ·γ,b]}
     */
    private List<Set<String>> CC;
    private void closure (Set<String> s) {
        int lastSize = -1;
        while (lastSize != s.size()) {
            lastSize = s.size();
            Set<String> hashset = new HashSet<String>();
            for (String item : s) {
                String[] strs = item.split(BnfContainer.separationCharacter); //  為分隔符
                int productionIdx = Integer.parseInt(strs[0]); //產生式下標
                int exprIdx = Integer.parseInt(strs[1]); //表達式下標
                int placeholder = Integer.parseInt(strs[2]); //占位符下標 這個下標從0開始(表示左側無語法符號)。
                int prospectiveSymbol = Integer.parseInt(strs[3]);//前瞻符
                List<Integer> temp = this.production.get(productionIdx).expr.get(exprIdx);
                //for each item [A -> β·Cθ,a] ∈ s        //從當前s集中尋求新狀態
                //    for each production C -> γ ∈ P  //有效產生式
                //temp.get(placeholder) 為 這里的 C
                //條件為 C不是終結符 且 當前占位符未達到最右端    如若C是個終結符,那么就無法拓展,如若占位符已經到達最右端,也無法拓展。
                if (placeholder < temp.size() && !this.isT(temp.get(placeholder))) {
                    int cIdx = temp.get(placeholder);
                    //先求FIRST(占位符后的串)
                    Set<Integer> set = this.FIRSTNextStr(temp, placeholder + 1, prospectiveSymbol);
                    List<List<Integer>> expr = this.production.get(cIdx).expr;
                    for (int i = 0; i < expr.size(); i++){
                        for (Integer val : set) {
                            String res = cIdx + BnfContainer.separationCharacter + i + BnfContainer.separationCharacter + 0 + BnfContainer.separationCharacter + val;
                            hashset.add(res);
                        }
                    }
                }
            }s.addAll(hashset);
        }
        /**
         * 項集之間會有交集,
         * start : <Goal>;
         * <Goal> ::= <List>;
         * <List> ::= <List><Pair>
         *         |    <Pair>;
         * <Pair> ::= "(" <Pair> ")"
         *         |    "("")";
         * #
         * 書上這個例子的原項 CC0 和 CC1就重復了 [Pair ::= ·(Pair),(]
         * 當然還有其他的也重復了...
         */
        return;
    }
    /*
    goto(s, x)
    moved <- ∅
    for each item ∈ s        //對於s集中的每個項
        if the from of i is [A -> β·xθ,a] then
            moved <- moved ∪ {[A -> βx·θ,a]}
    return closure (moved)
    */
    private Set<String> go (Set<String> s, int x){
        Set<String> res = new HashSet<String>();
        for (String item : s) {
            String[] strs = item.split(BnfContainer.separationCharacter); // ! 為分隔符
            int productionIdx = Integer.parseInt(strs[0]); //產生式下標
            int exprIdx = Integer.parseInt(strs[1]); //表達式下標
            int placeholder = Integer.parseInt(strs[2]); //占位符下標 這個下標從0開始(表示左側無語法符號)。
            int prospectiveSymbol = Integer.parseInt(strs[3]);//前瞻符
            List<Integer> temp = this.production.get(productionIdx).expr.get(exprIdx);
            String str = new String();
            if (placeholder + 1 <= temp.size() && temp.get(placeholder) == x) {
                str = productionIdx + BnfContainer.separationCharacter + exprIdx + BnfContainer.separationCharacter + (placeholder + 1) + BnfContainer.separationCharacter + prospectiveSymbol;
                res.add(str);
            }
        }
        this.closure(res);
        return res;
    }
    
    /**
     * 獲取    從expr表達式中下標為idx的語法符號開始的串     的FIRST
     * @param expr
     * @param idx
     * @param prospectiveSymbol
     * @return
     */
    private Set<Integer> FIRSTNextStr (List<Integer> expr, int idx, int prospectiveSymbol){
        Set<Integer> res = new HashSet<Integer>();
        if (idx >= expr.size()) {
            res.add(prospectiveSymbol);
            return res;
        }
        //當前符號是終結符
        if (this.isT(expr.get(idx))) {
            res.add(expr.get(idx));
            return res;
        }
        res.addAll(First[expr.get(idx)]);
        //如若存在 epsilon 
        if (res.contains(this.epsilon)) {
            res.remove(this.epsilon);
            res.addAll(this.FIRSTNextStr(expr, idx + 1, prospectiveSymbol));
        }return res;
    }
    
    /*
    CC0 <- closure({[S' -> ·S,eof]}) //構建初始狀態集
    CC <- {CC0}        //將初始狀態集添加到規范族CC中
    while (new set are still being added to CC)        
        for each unmarked set CCi ∈ CC    //unmarked : 未標記的
            mark CCi as processed    //將CCi標記為處理過的
            for each x following a · in an item in CCi  //對於CCi中項a ·后面的每個x
                temp <- goto(CCi, x)
                if temp ∉ CC
                    then CC <- CC ∪ {temp}
                record transition from CCi to temp on x
    */
    /*
     因為最后生成Action表中需要規約 reduce A - > BC 
     所以需要找到這個表達式的序號為了方便弄一個前綴數組
     記錄在前i個產生式中有多少個表達式。
     */
    int[] preArr;
    
    private void initPreArr() {
        this.preArr = new int[this.production.size()];
        if (this.preArr.length > 0) {
            this.preArr[0] = this.production.get(0).expr.size();
            for (int i = 1; i < this.preArr.length; i++) {
                this.preArr[i] = this.preArr[i - 1] + this.production.get(i).expr.size();
            }
        }
    }
    public void toLRTable() {
        //初始化。
        this.initPreArr();
        this.FIRSTAllSymbol();
        Set<String> CC0 = new HashSet<String>();
        List<List<Integer>> expr = this.production.get(startIndex).expr;
        for (int i = 0; i < expr.size(); i++) {
            CC0.add(this.startIndex + BnfContainer.separationCharacter + i + BnfContainer.separationCharacter + 0 + BnfContainer.separationCharacter + this.eof);
        }
        this.closure(CC0);
        CC = new ArrayList<Set<String>>();
        CC.add(CC0);
        int begin = 0;
        int lastSize = -1;
        List<Node> res = new ArrayList<Node>();
        int endState = -1;
        while (lastSize != CC.size()) {
            lastSize = CC.size();
            for (int i = begin; i < lastSize; i++) {
                Set<String> s = this.CC.get(i);
                for (String item : s) {
                    String[] strs = item.split(BnfContainer.separationCharacter); // ! 為分隔符
                    int productionIdx = Integer.parseInt(strs[0]); //產生式下標
                    int exprIdx = Integer.parseInt(strs[1]); //表達式下標
                    int placeholder = Integer.parseInt(strs[2]); //占位符下標 這個下標從0開始(表示左側無語法符號)。
                    int prospectiveSymbol = Integer.parseInt(strs[3]);//前瞻符
                    List<Integer> list = this.production.get(productionIdx).expr.get(exprIdx);
                    if (placeholder < list.size()) {
                        //因為對於每個項集的每個項的前瞻符都會進行一次推導,所以這里包含所有的推導。我們只需要記錄下來就可以生成表了。
                        int x = list.get(placeholder);
                        Set<String> temp = this.go(s, x);
                        int CCj = this.CCcontainsTheSet(temp);
                        if (CCj == -1) {
                            CC.add(temp);
                            CCj = this.CC.size() - 1;
                        }
                        res.add(new Node(i, x, CCj));
                    }
                    //可歸約狀態
                    else {
                        res.add(new Node(i, prospectiveSymbol, ((productionIdx - 1 >= 0 ? this.preArr[productionIdx - 1] : 0) + exprIdx + 1) | MASK));
                        if (productionIdx == this.startIndex) {
                            endState = i;
                        }
                    }
                }
                //更新begins
                begin = lastSize;
            }
        }
        this.createActionAndGotoTable(res, endState);
    }
    
    /**
     * 這是構建表時臨時記錄數據的結構
     */
    class Node{
        int state;
        /**
         * 對於sym來說就是終結符和非終結符的編碼
         * 也是利用這個來區別到底把val放Action
         * 表還是Goto表。
         */
        int sym;
        /**
         * 對於val來說
         * 如若是產生式規約,則將產生式的下標 | MASK作為val
         * 如若是正常的狀態轉移,則直接輸入轉移狀態的下標。
         */
        int val;
        
        public Node(int state, int sym, int val){
            this.state = state;
            this.sym = sym;
            this.val = val;
        }
    }
    /**
     * 利用這個方法去看規范族CC中是否存在set
     * 並且會返回set在CC的下標如若存在的話
     * @param set
     * @return
     */
    private int CCcontainsTheSet (Set<String> set) {
        for (int i = 0; i < CC.size(); i++) {
            Set<String> s = CC.get(i);
            if (s.size() == set.size() && set.containsAll(s)) {
                return i;
            }
        }return -1;
    }
    /*
    for each CCi ∈ CC
        for each  item I ∈ CCi
            if I is [A -> β·cθ,a] and goto (CCi , c) = CCj then
                Action[i,c] <- "shift j"
            else if I is [A -> β·,a] then    //規約
                Action[i,a] <- "reduce A->B"
            else if I is [S'->S·,eof] then    //如若是目標項產生式推導完成狀態並且前瞻符號為eof,則為接收狀態。
                Action[i,eof] <- "accept"
        for each n ∈ NT                //如若項集CCi跳過一個非終結符n即到達j
            if goto(CCi, n) = CCj then
                Goto[i,n] <- j
    */
    private void createActionAndGotoTable(List<Node> node, int endState) {
        //豎是狀態 橫是終結符
        this.Action = new int[this.CC.size()][this.T.size()];
        //賦初始值
        for (int i = this.CC.size() - 1; i >= 0; i--) {
            for (int j = this.T.size() - 1; j >=0; j--) {
                this.Action[i][j] = -1;
            }
        }
        //豎是狀態 橫是非終結符
        this.Goto = new int[this.CC.size()][this.production.size()];//賦初始值
        for (int i = this.CC.size() - 1; i >= 0; i--) {
            for (int j = this.production.size() - 1; j >=0; j--) {
                this.Goto[i][j] = -1;
            }
        }
        for (Node n : node) {
            //如若跨越的符號是終結符
            if (this.isT(n.sym)) {
                Action[n.state][n.sym & DECODE] = n.val;
            }else {
                Goto[n.state][n.sym] = n.val;
            }
        }
        //將接受狀態設為最低值。
        this.Action[endState][this.eof & DECODE] = Integer.MIN_VALUE;
        return;
    }
    
    
    public void printActionAndGotoTable() {
        if (this.Action == null || this.Goto == null) {
            System.out.println("表未生成,請使用toLRTable函數生成表。");
            return;
        }
        //先輸出一行終結符
        System.out.println("Action表如下");
        System.out.print("\t");
        for (int i = 0; i < this.T.size(); i++) {
            if (i != (this.epsilon & DECODE)) {
                System.out.print(this.T.get(i) + "\t");
            }
        }
        System.out.print("\n");
        for (int i = 0; i < this.Action.length; i++) {
            // 每行第一個輸出i
            System.out.print(i + "\t");
            for (int j = 0; j < this.Action[i].length; j++) {
                if (j != (this.epsilon & DECODE)) {
                    if (this.Action[i][j] == -1) {
                        System.out.print("err\t");
                    } // 規約操作
                    else if (this.Action[i][j] == Integer.MIN_VALUE) {
                        System.out.print("acc\t");
                    } else if ((this.Action[i][j] & MASK) == MASK) {
                        System.out.print("r" + (this.Action[i][j] & DECODE) + "\t");
                    } else {
                        System.out.print("s" + this.Action[i][j] + "\t");
                    }
                }
            }
            System.out.print("\n");
        }
        System.out.println("Goto表如下");
        // 先輸出一行非終結符
        System.out.print("\t");
        for (int i = 0; i < this.production.size(); i++) {
            System.out.print(this.production.get(i).name + "\t");
        }
        System.out.print("\n");
        for (int i = 0; i < this.Goto.length; i++) {
            // 每行第一個輸出i
            System.out.print(i + "\t");
            for (int j = 0; j < this.Goto[i].length; j++) {
                if (this.Goto[i][j] == -1) {
                    System.out.print("err\t");
                    continue;
                }
                System.out.print("s" + this.Goto[i][j] + "\t");
            }System.out.print("\n");
        }
    }
}

/**
 * 代碼分析器 可以將代碼轉換為信息等價的數據結構
 */
class CodeAnalyzer {
    class Token{
        boolean isNt;
        String name;
        public Token (boolean isNt, String name) {
            this.isNt = isNt;
            this.name = name;
        }
    }
    private char[] text;
    private int textSize = 0; //字符串有效長度
    private int point = 0; //text解析進度的指針
    private BnfContainer bc;
    private Token token;
    String left; //左側非終結符
    private int count = 0; //記錄當前已經解析到哪個產生式了
    public CodeAnalyzer (String text, BnfContainer bc) {
        this.bc = bc;
        //初始化代碼分析器
        this.initText(text);
        this.initStartSymbol();
        this.initCodeAnalyzer();
    }
    /**
     * 輸入字符串文本,返回處理完畢的字符數組。
     * @param s
     * @return
     */
    private void initText(String s) {
        this.text = s.toCharArray();
        int idx = 0;
        //將字符串變為一個緊湊的字符數組(去除一些妨礙的字符)
        while (idx < text.length) {
            if (text[idx] == '\r' || text[idx] == '\n' || text[idx] == '\t' || text[idx] == ' ') {
                idx++;
            }else {
                text[textSize++] = text[idx++];
            }
        }
    }

    private void initStartSymbol() {
        // 驗證是否存在start:<
        point = 0;
        char[] needle = { 's', 't', 'a', 'r', 't', ':', '<' };
        if (textSize <= needle.length) {
            this.notFindStartNT();
        }
        point = 0;
        while (point < needle.length) {
            if (needle[point] == text[point]) {
                point++;
            } else {
                this.notFindStartNT();
            }
        }
        point = needle.length;
        while (point < textSize && text[point] != '>') {
            point++;
        }
        this.bc.setStart(new String(text, needle.length, point - needle.length));
        this.skip(Type.RT);
        this.skip(Type.SEMICOLON);
    }
    /**
     * 通過skip來跳過字符
     */
    enum Type{
        LT, //左尖括號
        RT, //右尖括號
        SEMICOLON, //分號
        QUOTE, //雙引號
        OR, //或
        COLON, // :
        EQ, //等於號
    }
    private void skip (Type t) {
        switch(t) {
        case LT:
            this.skip('<');
            break;
        case RT:
            this.skip('>');
            break;
        case OR:
            this.skip('|');
            break;
        case SEMICOLON:
            this.skip(';');
            break;
        case QUOTE:
            this.skip('"');
            break;
        case COLON:
            this.skip(':');
            break;
        case EQ:
            this.skip('=');
            break;
        }
    }
    private void skip (char c) {
        if (point >= this.textSize || this.text[point] != c) {
            System.out.println("第" + this.count + "個產生式,缺少符號  " + c);
            System.exit(-1);
        }
        point++;
    }
    /**
     * 報錯 : 沒有找到目標(開始)非終結符號! 並退出程序。
     */
    private void notFindStartNT() {
        System.out.println("沒有找到目標非終結符號!");
        System.exit(-1);
    }

    /**
     * 之所以一開始就要添加非終結符,而不在解析BNF時候添加
     * 是因為,非終結符存在定義的問題,如若 沒有定義
     * 但有使用(只在右側出現,未在左側定義),這個就是錯誤的。
     */
    private void initCodeAnalyzer() {
        int idx = this.point;
        this.point = 0;
        this.count = 0;
        while (true) {
            while (this.point < textSize && text[this.point] != ';') {
                this.point++;
            }this.point++;
            this.count++;
            //如若分號后面沒有左括號
            if (this.point >= textSize) {
                break;
            }
            String name = this.getNT();
            bc.addNT(name);
        }this.count = 0;
        this.point = idx;
    }

    /**
     * BNF
     * 從point開始解析字符串。
     * <Goal> ::= {<Production>}
     * <Production> ::= <左側非終結符> "::=" <Expr>;
     * <Expr> ::= <Term> { "|" <Term>}";";
     * <Term> ::= {<Factor>};     //Term在這就是多個終結符或非終結符相連接
     * <Factor> ::= <T> | <NT>
     */
    public void analyze() {
        while (point < this.textSize) {
            this.count++;
            production();
        }
    }
    
    public void production(){
        //先跳過左側非終結符
        this.left = this.getNT();
        this.skipDefineSymol();
        this.expr();
    }
    /**
     * 跳過 ::=
     */
    public void skipDefineSymol() {
        skip(Type.COLON);
        skip(Type.COLON);
        skip(Type.EQ);
    }
    /**
     * 獲取非終結符
     * <xxx>
     */
    public String getNT () {
        skip(Type.LT);
        StringBuilder res = new StringBuilder();
        while (this.point < this.textSize && text[this.point] != '>') {
            res.append(text[this.point++]);
        }
        skip(Type.RT);
        return res.toString();
    }
    
    /**
     * 當前指針指向 "T" 中第一個"
     * @return
     */
    public String getT() {
        this.skip(Type.QUOTE);
        StringBuilder res = new StringBuilder();
        while (this.point < this.textSize && this.text[this.point] != '"') {
            res.append(text[this.point++]);
        }
        this.skip(Type.QUOTE);
        return res.toString();
    }
    
    /**
     * 當前指針指向 ::= <T>... 中 = 后一個符號
     */
    public void expr(){
        this.term();
        while (this.point < this.textSize && text[this.point] == '|') {
            this.skip(Type.OR);
            term();
        }this.skip(Type.SEMICOLON);
    }
    
    /**
     * 如若還有符號,當前符號指向 終結符或非終結符的符號  < 或者 "
     */
    public void term(){
        //創建一個屬於當前term的鏈表
        bc.creatNewExper(this.left);
        while (this.point < this.textSize && (text[this.point] == '"' || text[this.point] == '<')) {
            factor();
            bc.addExpeElement(this.left, token.isNt, token.name);
        }
    }
    
    /**
     * 通過factor獲取token
     */
    public void factor(){
        //非終結符
        if (text[this.point] == '"') {
            String name = this.getT(); 
            this.token = new Token(false, name);
        }else {
            String name = this.getNT();
            token = new Token (true, name);
        }
    }
}