sp backup

/**
 * Created by max on 09.04.2017.
 */
import java.lang.*;
import java.util.*;
import java.io.*;
import java.nio.charset.Charset;

import JavaTeacherLib.MyLang;
import JavaTeacherLib.LlkContext;
import JavaTeacherLib.Node;
import JavaTeacherLib.TableNode;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.regex.*;

enum Tokens {
    Keyword,
    Atom,
    Int,
    Hex,
    Double,
    Comment,
    String,
    Char,
    Directive,
    Operator,
    Punctuation,
    CONST_NAME,
    DIGIT,
    IDN,
    LITER_STR,
    PROC_NAME,
    FUNC_NAME,
    TYPE_NAME
}

class LexPascal{
    private String path = "";
    private static Map<Tokens , Pattern> regular = new HashMap<Tokens , Pattern>();
    private static Map<Tokens , Integer> priority = new HashMap<Tokens , Integer>();

    public LexPascal(String _path){
        path = path;
        InitRegex();
        InitPriority();
    }

    private void InitRegex(){
        regular.put(Tokens.IDN , Pattern.compile("^(_|[a-z])([a-z]|[0-9]|_)*"));
        regular.put(Tokens.Keyword , Pattern.compile("^(program|var|const|type|begin|repeat|until|end|if|then|else|while|do|for|of|record|with|procedure|function|case|in|set|array|nil|true|false)"));
        regular.put(Tokens.DIGIT , Pattern.compile("^(0|[1-9]\\d*)"));
        regular.put(Tokens.LITER_STR, Pattern.compile("^'(?:[^']+|(''))*'$"));
        regular.put(Tokens.Comment, Pattern.compile("^(//(.*?)//|\\{(.*?)\\}|\\(\\*(.*?)\\*\\))"));
        regular.put(Tokens.Punctuation, Pattern.compile("^(\\(|\\)|;|,|\\.|:|\\[|\\]|\\^|\\.\\.)"));
//        regular.put(Tokens.Hex, Pattern.compile("^0[xX]((0|[1-9a-fA-F][\\da-fA-F]*))"));
        regular.put(Tokens.Operator, Pattern.compile("^\\+|\\-|\\*|/|:=|<>|=|>|<|>=|<=|!=|div|mod|and|not"));
        regular.put(Tokens.Double, Pattern.compile("^(((0|[1-9]\\d*)?\\.\\d+([eE][+-]?\\d+)?[FfDdMm]?)|((0|[1-9]\\d*)([eE][+-]?\\d+)[FfDdMm]?)|((0|[1-9]\\d*)[FfDdMm]))"));
//        regular.put(Tokens.Directive, Pattern.compile("^mp:.*"));
        regular.put(Tokens.TYPE_NAME , Pattern.compile("^(integer|real|char|boolean)"));
    }

    private void InitPriority(){
        priority.put(Tokens.Operator, 1);
        priority.put(Tokens.Punctuation, 2);
        priority.put(Tokens.Double, 3);
        priority.put(Tokens.DIGIT, 4);
        priority.put(Tokens.Hex, 4);
        priority.put(Tokens.IDN, 5);
        priority.put(Tokens.Keyword, 6);
        priority.put(Tokens.LITER_STR, 7);
        priority.put(Tokens.TYPE_NAME, 8);
        priority.put(Tokens.Comment, 9);
    }

    private String Prepare(String text){
        String code = "";
        boolean ck = false;
        for(int i = 0 ; i < text.length() ; ++i){
            char ch = text.charAt(i);
            String small = "йцукенгшщзхъфывапролджэёячсмитьбю";
            String big = "ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЁЯЧСМИТЬБЮ";
            if(small.indexOf(ch) != -1 && !ck){
                code += 'a';
                ck = true;
            }else if(big.indexOf(ch) != -1 && !ck){
                code += 'A';
                ck = true;
            }else if(small.indexOf(ch) == -1 && big.indexOf(ch) == -1){
                code += ch;
                ck = false;
            }
        }
        String temp = "";
        boolean add = false;
        int st = 0;
        for(int i = 0 ; i < code.length() ; ++i){
            char ch = code.charAt(i);
            if(st == 0 && ch == '\''){
                add = false;
                temp += ch;
                st = 1;
                continue;
            }
            if(st == 1 && ch == '\''){
                st = 0;
                temp += ch;
                continue;
            }
            if(st == 1 && ch == '\\'){
                st = 2;
                continue;
            }
            if(st == 2){
                st = 1;
                continue;
            }
            if(st == 1) {
                if(add == false){
                    temp += ch;
                    add = true;
                }
                continue;
            }
            temp += ch;
        }
        return temp.toLowerCase();
    }

    public ArrayList<Map<Tokens , String>> Tokenize() throws Exception{
        File file = new File("C:\\Users\\максим\\IdeaProjects\\SysProgrammingMainAlgorithm\\Example1.txt");
        String text = "";
        try {
            FileInputStream fis = new FileInputStream(file);
            byte[] data = new byte[(int) file.length()];
            fis.read(data);
            fis.close();
            text = new String(data, "UTF-8");
        }catch(FileNotFoundException e){
            System.out.print("File not found");
        }catch(IOException e) {
            e.printStackTrace();
        }

        ArrayList<Map<Tokens , String>> ans = new ArrayList<>();
        String code = Prepare(text);
        //    System.out.println(code);
        while(code.length() > 0 && (code.charAt(0) == ' ' || code.charAt(0) == '\n' || code.charAt(0) == '\t'))code = code.substring(1);
        while(code.length() > 0){
            Tokens tokType = Tokens.Comment;
            int len = -1;
            for(Tokens tok : regular.keySet()){
                Pattern trg = regular.get(tok);

                String tmp = code;
                for(int j = code.length() ; j > 0 ; --j){
                    Matcher tmat = trg.matcher(tmp);
                    if(tmat.matches()){
                        if(j > len || (j == len && priority.get(tok) > priority.get(tokType))){
                            len = j;
                            tokType = tok;
                            break;
                        }
                    }
                    tmp = tmp.substring(0 , tmp.length() - 1);
                }


                Matcher tmat = trg.matcher(code);

                MatchResult res1 = tmat.toMatchResult();
                try{
                    System.out.println(res1.end());
                }catch(java.lang.IllegalStateException e){}
                if(tmat.matches()){
                    MatchResult res = tmat.toMatchResult();
                    if(res.start() == 0){
                        if(res.end() > len){
                            len = res.end();
                            tokType = tok;
                        }
                    }
                }
            }
            if(len <= 0){
                throw new Exception("Unknown lexeme " + code);
            }

            if(tokType == Tokens.IDN){
                if(ans.size() > 0){
                    for(Tokens tk : ans.get(ans.size() - 1).keySet()){
                        if(tk == Tokens.Keyword && (ans.get(ans.size() - 1).get(tk).equals("procedure")
                                                    || ans.get(ans.size() - 1).get(tk).equals("function"))){
                            tokType = ans.get(ans.size() - 1).get(tk).equals("function") ? Tokens.FUNC_NAME : Tokens.PROC_NAME;
                        }
                    }
                }
            }

            Map<Tokens , String> curans = new HashMap<>();
            curans.put(tokType , code.substring(0 , len));
            ans.add(curans);
            //      System.out.println(code.substring(0 , len) + " " + tokType.toString());
            code = code.substring(len);
            code = code.trim();
        }
        return ans;
    }
}

public class SysProgrammingMainAlgorithm {

    public static void main(String[] args) {
        byte [] readline=new byte [80];
        boolean result;
        String fileName;
        MyLang testLang=null;
        int codeAction, llk=1, textLen;
        String [] menu= { "*1.  Прочитати граматику з файла  ",
                " 2.  Лабораторна робота. Клас будує студент",
                " 3.  Надрукувати граматику",
                "*4.  Побудувати списки терміналів та нетерміналів",
                "*5.  Пошук непродуктивних нетерміналів",
                "*6.  Пошук недосяжних нетерміналів",
                "*7.  Побудова списку епсілон-нетерміналів",
                " 8.  Друк списку епсілон-нетерміналів",
                " 9.  Пошук ліворекурсивних нетерміналів",
                " 10. Пошук різних ліворекурсивних виводів мінімальної довжини",
                " 11. Пошук праворекурсивних нетерміналів",
                " 12. Пошук різних праворекурсивних виводів мінімальної довжини",
                "*13. Побудувати множини FirstK(A), A-нетермінал",
                " 14. Вивести на термінал множини FirstK(A), A-нетермінал",
                "*15. Побудувати множини FollowK(A), A-нетермінал",
                " 16. Вивести на термінал множини FollowK(A), A-нетермінал",
                "*17. Побудувати множини FirstK(w) + FollowK(A) для правила А->w",
                " 18. Вивести на термінал FirstK(w) + FollowK(A) для всіх правил А->w",
                " 19. Вивести на термінал FirstK(w) + FollowK(A) для вибраних правил А->w",
                "*20. Перевірка сильної LL(1)-властивості",
                " 21. Побудова таблиці LL(1)-синтаксичного аналізатора",
                " 22. Синтаксичний аналізатор. Клас будує студент",
                "*23. Побудувати множини LocalK(A), A-нетермінал",
                " 24. Вивести на термінал множини LocalK(A), A-нетермінал",
                "*25. Перевірка LL(k)-властивості, k>1",
                " 26. Вихід з системи"
        };
        do  {
            codeAction=0;
            String upr;
            for (String ss: menu) System.out.println(ss); // вивести меню
            System.out.println("Введіть код дії або end:");
            do {  // цикл перебору даних
                try {
                    textLen=System.in.read(readline);
                    upr = new String (readline,0,textLen, "ISO-8859-1");
                    if (upr.trim().equals("end") ) return;
                    codeAction=new Integer (upr.trim());
                }
                catch(Exception ee)
                { System.out.println ("Невірний код дії, повторіть: ");
                    continue;
                }
                if (codeAction >=1  &&  codeAction<=menu.length ) {
                    if (menu [codeAction-1].substring(0, 1).equals("+"))  {
                        System.out.println("Елемент меню " +codeAction+" повторно виконати неможливо");
                        continue ;
                    }
                    int itmp;
                    for (itmp=0; itmp < codeAction-1; itmp++)
                        if (menu[itmp].substring(0, 1).equals("*")) break;
                    if (itmp !=codeAction-1) {
                        System.out.println ("Виконайте попередні елементи меню, що позначені * : ");
                        continue ;
                    }
                    if(codeAction == 2){
                        for(itmp=0; itmp <= 7 ; ++itmp){
                            if(menu[itmp].substring(0, 1).equals("*")) break;
                        }
                        if(itmp != 8){
                            System.out.println ("Виконайте елементи меню до 8го, що позначені * : ");
                            continue ;
                        }
                    }
                    break;
                }
                else {
                    System.out.println ("Невірний код дії, повторіть: ");
                    continue ;
                }
            }  while (true);
            // перевірка на виконання усіх попередніх дій
            result=false;
            switch (codeAction) {
                case 1: //1. Прочитати граматику з файла",
                    System.out.print ("Введіть ім'я файлу граматики:");
                    try {
                        textLen=System.in.read(readline);
                        fileName = new String (readline,0,textLen, "ISO-8859-1");
                        fileName = fileName.trim();
                    }
                    catch(Exception ee)
                    { System.out.println ("Системна помилка: "+ee.toString());
                        return;
                    }
                    System.out.print ("Введіть значення параметра k : ");
                    try {
                        textLen=System.in.read(readline);
                        String llkText = new String (readline,0,textLen, "ISO-8859-1");
                        llkText = llkText.trim();
                        llk=Integer.parseInt(llkText);
                    }
                    catch(Exception ee)
                    { System.out.println ("Системна помилка: "+ee.toString());
                        return;
                    }
                    testLang = new MyLang (fileName,llk);
                    if (!testLang.isCreate()) break;  //не створили об'єкт
                    System.out.println ("Граматика прочитана успішно");
                    result=true;
                    for (int jj=0;  jj<menu.length; jj++) {
                        if (menu [jj].substring(0, 1).equals(" ")) continue;
                        menu [jj]=menu [jj].replace(menu [jj].charAt(0), '*');
                    }
                    break;
                case 2: //2. Лабораторна робота студента
                    boolean ck = false;
                    int[] term = testLang.getTerminals();
                    int[] nonterm = testLang.getNonTerminals();

                    Map<Integer , Integer> notrm = new HashMap();
                    Map<Integer , Integer> trm = new HashMap();

                    for(int i = 0 ; i < term.length ; ++i){
                        trm.put(term[i] , i);
                    }
                    for(int i = 0 ; i < nonterm.length ; ++i){
                        notrm.put(nonterm[i] , i);
                    }

                    LlkContext[] llkTrmContext = testLang.getLlkTrmContext();
                    LlkContext[] res_cur = new LlkContext[nonterm.length];

                    for (int i = 0; i < nonterm.length; ++i) {
                        res_cur[i] = new LlkContext();
                    }

                    for(Node node : testLang.getLanguarge()){
                        int[] rool = node.getRoole();
                        int left = notrm.get(rool[0]);
                        if(rool.length == 1){
                            res_cur[left].addWord(new int[0]);
                        }
                    }

                    ck = true;

                    while(ck){
                        ck = false;

                        for(Node node : testLang.getLanguarge()) {
                            int[] rool = node.getRoole();
                            int left = notrm.get(rool[0]);
                            int last = 1;
                            if(rool.length == 1)continue;

                            Queue<ArrayList<Integer>> q = new LinkedList<>();

                            ArrayList<Integer> temp = new ArrayList<>();
                            temp.add(-1);

                            q.add(temp);

                            ArrayList<ArrayList<Integer>> done = new ArrayList<>();

                            for(; last < rool.length ; ++last){
                                int cur = rool[last] > 0 ? trm.get(rool[last]) : notrm.get(rool[last]);
                                LlkContext tmp = rool[last] > 0 ? llkTrmContext[cur] : res_cur[cur];
                                if(rool[last] < 0 && res_cur[cur].calcWords() == 0)break;
                                boolean cont = false;
                                while(!q.isEmpty()){
                                    ArrayList<Integer> word = (ArrayList<Integer>)q.peek().clone();
                                    if(word.get(0) == last){
                                        cont = true;
                                        break;
                                    }
                                    q.poll();
                                    for(int i = 0 ; i < tmp.calcWords() ; ++i){
                                        ArrayList<Integer> word1 = (ArrayList<Integer>)word.clone();
                                        word1.set(0 , last);
                                        for(int j = 0 ; j < tmp.getWord(i).length ; ++j){
                                            word1.add(tmp.getWord(i)[j]);
                                        }
                                        if(word1.size() - 1 >= testLang.getLlkConst()){
                                            done.add(word1);
                                        }else{
                                            q.add(word1);
                                        }
                                    }
                                }
                                if(cont)continue;
                                break;
                            }

                            while(last == rool.length && !q.isEmpty()){
                                ArrayList<Integer> word = (ArrayList<Integer>)q.peek().clone();
                                q.poll();
                                done.add(word);
                            }

                            for(int i = 0 ; i < done.size() ; ++i){
                                int word[] = new int[Math.min(done.get(i).size() - 1 , testLang.getLlkConst())];
                                for(int j = 0 ; j < word.length ; ++j){
                                    word[j] = done.get(i).get(j + 1);
                                }
                                ck |= (res_cur[left].addWord(word));
                            }
                        }
                    }

                    testLang.setFirstK(res_cur);
                    testLang.printFirstkContext();

                    break;
                case 3:  // Надрукувати граматику
                    testLang.printGramma();
                    break;
                case 4:  // надрукувати список терміналів та нетерміналів
                    testLang.printTerminals();
                    testLang.printNonterminals();
                    result=true;
                    break;
                case 5: // вивести непродуктивні правила
                    result=testLang.createNonProdRools();
                    break;
                case 6: // недосяжні нетермінали
                    result=testLang.createNonDosNeterminals();
                    break;
                case 7:  //Побудова списку епсілон-нетерміналів
                    int [] epsilon=testLang.createEpsilonNonterminals ();
                    testLang.setEpsilonNonterminals (epsilon);
                    result=true;
                    break;
                case 8: //Друк списку епсілон-нетерміналів
                    testLang.printEpsilonNonterminals();
                    break;
                case 9:    //Пошук ліворекурсивних нетерміналів"
                    testLang.leftRecursNonnerminal();
                    break;
                case 10:  //Пошук різних ліворекурсивних виводів мінімальної довжини"
                    testLang.leftRecusionTrace();
                    break;
                case 11:  //Пошук праворекурсивних нетерміналів"
                    testLang.rightRecursNonnerminal();
                    break;
                case 12:  //Пошук різних праворекурсивних виводів мінімальної довжини"
                    testLang.rigthRecusionTrace();
                    break;
                case 13:  //Побудувати множини FirstK
                    LlkContext [] firstContext = testLang.firstK();
                    testLang.setFirstK(firstContext);
                    result=true;
                    break;
                case 14:  //Друк множини FirstK
                    testLang.printFirstkContext ( );
                    break;
                case 15:  //Побудувати множини FollowK
                    LlkContext [] followContext = testLang.followK();
                    testLang.setFollowK(followContext);
                    result=true;
                    break;
                case 16:  //Друк множини FollowK
                    testLang.printFollowkContext ( );
                    break;
                case 17:  //Побудувати множини FirstK(w) + FollowK(A) для правила А->w
                    testLang.firstFollowK ( );
                    result=true;
                    break;
                case 18:  //Друк множини FirstK(w) + FollowK(A) для правила А->w
                    testLang.printFirstFollowK( );
                    break;
                case 19:  //Друк множини FirstK(w) + FollowK(A) для вибраних правил А->w
                    testLang.printFirstFollowForRoole();
                    break;
                case 20:  //Перевірка сильної LL(k)-властивості",
                    result=testLang. strongLlkCondition () ;
                    break;
                case 21:  //Побудова таблиці LL(1)-синтаксичного аналізатора
                    int [][] uprTable=testLang.createUprTable ();
                    testLang.setUprTable(uprTable);
                    break;
                case 22: // PASCAL
                    String path;
                    System.out.println("Введiть назву вхiдного файлу: ");
                    try{
                        textLen=System.in.read(readline);
                        String codepath = new String (readline,0,textLen, "ISO-8859-1");
                        LexPascal lex = new LexPascal("Example1.txt");
                        ArrayList<Map<Tokens , String>> tokens = lex.Tokenize();
                        for(Map<Tokens , String> mp : tokens){
                            for(Tokens tok : mp.keySet()){
                         //       System.out.println(mp.get(tok) + " " + tok.toString());
                            }
                        }

                        Stack<Integer> st = new Stack<>();
                        st.push(testLang.getAxioma());

                        int[][] table = testLang.getUprTable();

                        //for(Map<Tokens , String> mp : tokens){
                        for(int kk = 0 ; kk < tokens.size() ; ++kk , kk = Math.max(kk , 0)){
                            //System.out.println(st);
                            Map<Tokens , String> mp = tokens.get(kk);
                            if(st.isEmpty()){
                                System.out.println("Error, stack is empty! ");
                            }
                            int top = st.peek();

                            if(top < 0){//top is non terminal
                                int cur = -1;
                                int nt[] = testLang.getNonTerminals();

                                for(int i = 0 ; i < nt.length ; ++i){
                                    if(top == nt[i]){
                                        cur = i;
                                        break;
                                    }
                                }

                                //check that cur != -1

                                int el = -1;
                                int tr[] = testLang.getTerminals();

                                for(int i = 0 ; i < tr.length ; ++i){
                                    String terminal = testLang.getLexemaText(tr[i]);
                                    for(Tokens tk : mp.keySet()){
                                        if(terminal.equals(mp.get(tk)) || terminal.equals(tk.toString())){
                                            el = i;
                                            break;
                                        }
                                    }
                                }

                                //check that el != -1


                                int next = table[cur][el];

                            //    System.out.println(table[cur][el] + " " + table[el][cur]);

                                LinkedList<Node> lang = testLang.getLanguarge();
                                int rule[] = lang.get(Math.max(next - 1 , 0)).getRoole();

                             //   for(int r : rule){
                             //       System.out.print(r + " ");
                             //    }
                             //   System.out.println();

                                st.pop();

                                for(int i = rule.length - 1; i >= 1 ; --i) {
                                    st.push(rule[i]);
                                }

                                --kk;
                            }else{//top is terminal
                                String terminal = testLang.getLexemaText(top);

                                boolean eq = false;

                                for(Tokens tk : mp.keySet()){
                                    if(terminal.equals(mp.get(tk)) || terminal.equals(tk.toString())){
                                        eq = true;
                                    }
                                }

                                if(eq){
                                    st.pop();
                                    continue;
                                }else{
                                    System.out.println("Error: " + mp);
                                    break;
                                }


                            }
                        }

                        System.out.print("OK\n");
                        System.out.println(st);


                    }catch (java.io.IOException e ){}
                    catch (java.lang.Exception e){e.printStackTrace();}




                    break;

                case 23: // 23. Побудувати множини LocalK(A), A-нетермінал
                    LinkedList <LlkContext> [] Localk=testLang.createLocalK();
                    testLang.setLocalkContext(Localk);
                    result=true;
                    break;
                case 24: // 24. Вивести на термінал множини LocalK(A), A-нетермінал
                    testLang.printLocalk();
                    break;
                case 25: // 25. Перевірка LL(k)-властивості, k>1
                    result= testLang.llkCondition();
                    break;
                case 26: // rtrtrtr
                    return;
                case 27:
                    break;
            }  // кінець switch
            // блокуємо елемент обробки
            if (result) // функція виконана успішно
                if (menu [codeAction-1].substring(0, 1).equals("*"))
                    menu [codeAction-1]=menu [codeAction-1].replace('*', '+') ;
        } while (true);  //глобальний цикл  обробки

    }  // кінець main

    static void tesrReadWrite(String fname)
    {  String readline;
        BufferedReader s;
        BufferedWriter bw;
        try {
            s = new BufferedReader(new FileReader(fname));
            bw = new BufferedWriter (new FileWriter("c:\\rez.txt"));
            // s=new FileInputStream (fname);
            //s=new FileInputStream ("C:\\Eclipse\\C1.txt");
            //s=new FileInputStream ("C:\\test1.txt");
            while ( s.ready() ) {
                readline= s.readLine();
                System.out.println(readline);
                //System.out.println("Read Line");
                //bw.write(readline, 0,readline.length() );
                //bw.write((int)'\r'); bw.flush();
                //System.out.println("Print Line");
            }

            //bw.close();
        }
        catch(Exception ee)
        {
            System.out.print("File: " +fname + "not found\n");
            //return;
        }
    }
}