API tools faq
paste
Advertisement
osipyonok

SP Lab3 Full

osipyonok
May 9th, 2017
198
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 34.41 KB | None | 0 0
raw download clone embed print report
  1. /**
  2.  * Created by max on 09.04.2017.
  3.  */
  4. import java.lang.*;
  5. import java.util.*;
  6. import java.io.*;
  7. import java.nio.charset.Charset;
  8.  
  9. import JavaTeacherLib.MyLang;
  10. import JavaTeacherLib.LlkContext;
  11. import JavaTeacherLib.Node;
  12. import JavaTeacherLib.TableNode;
  13. import com.sun.xml.internal.messaging.saaj.packaging.mime.internet.HeaderTokenizer;
  14.  
  15. import java.io.File;
  16. import java.io.FileInputStream;
  17. import java.io.FileNotFoundException;
  18. import java.io.IOException;
  19. import java.util.regex.*;
  20.  
  21. enum Tokens {
  22.     Keyword,
  23.     Atom,
  24.     Int,
  25.     Hex,
  26.     Double,
  27.     Comment,
  28.     String,
  29.     Char,
  30.     Directive,
  31.     Operator,
  32.     Punctuation,
  33.     CONST_NAME,
  34.     DIGIT,
  35.     IDN,
  36.     LITER_STR,
  37.     PROC_NAME,
  38.     FUNC_NAME,
  39.     TYPE_NAME
  40. }
  41.  
  42. class LexPascal{
  43.     private String path = "";
  44.     private static Map<Tokens , Pattern> regular = new HashMap<Tokens , Pattern>();
  45.     private static Map<Tokens , Integer> priority = new HashMap<Tokens , Integer>();
  46.  
  47.     public LexPascal(String _path){
  48.         path = _path.trim();
  49.         InitRegex();
  50.         InitPriority();
  51.     }
  52.  
  53.     private void InitRegex(){
  54.         regular.put(Tokens.IDN , Pattern.compile("^(_|[a-z])([a-z]|[0-9]|_)*"));
  55.         regular.put(Tokens.Keyword , Pattern.compile("^(uses|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)"));
  56.         regular.put(Tokens.DIGIT , Pattern.compile("^(0|[1-9]\\d*)"));
  57.         regular.put(Tokens.LITER_STR, Pattern.compile("^'(?:[^']+|(''))*'$"));
  58.         regular.put(Tokens.Comment, Pattern.compile("^(//(.*?)//|\\{(.*?)\\}|\\(\\*(.*?)\\*\\))"));
  59.         regular.put(Tokens.Punctuation, Pattern.compile("^(\\(|\\)|;|,|\\.|:|\\[|\\]|\\^|\\.\\.)"));
  60. //        regular.put(Tokens.Hex, Pattern.compile("^0[xX]((0|[1-9a-fA-F][\\da-fA-F]*))"));
  61.         regular.put(Tokens.Operator, Pattern.compile("^\\+|\\-|\\*|/|:=|<>|=|>|<|>=|<=|!=|div|mod|and|not|~"));
  62.         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]))"));
  63. //        regular.put(Tokens.Directive, Pattern.compile("^mp:.*"));
  64.         regular.put(Tokens.TYPE_NAME , Pattern.compile("^(byte|integer|real|char|boolean|string)"));
  65.      //   regular.put(Tokens.PROC_NAME , Pattern.compile("^(randomize)"));
  66.     }
  67.  
  68.     private void InitPriority(){
  69.         priority.put(Tokens.Operator, 10);
  70.         priority.put(Tokens.Punctuation, 2);
  71.         priority.put(Tokens.Double, 3);
  72.         priority.put(Tokens.DIGIT, 4);
  73.         priority.put(Tokens.Hex, 4);
  74.         priority.put(Tokens.IDN, 5);
  75.         priority.put(Tokens.Keyword, 6);
  76.         priority.put(Tokens.LITER_STR, 7);
  77.         priority.put(Tokens.TYPE_NAME, 8);
  78.         priority.put(Tokens.Comment, 9);
  79.     }
  80.  
  81.     private String Prepare(String text){
  82.         text = text.toLowerCase();
  83.         String code = "";
  84.         boolean ck = false;
  85.  
  86.       //  text = text.replace(";",";;");
  87.         text = text.replace("clrscr;","clrscr();");
  88.         text = text.replace("writeln;","writeln();");
  89.         text = text.replace("write;","write();");
  90.         text = text.replace("readln;","readln();");
  91.         text = text.replace("read;","read();");
  92.         text = text.replace("randomize;","randomize();");
  93.         text = text.replace("function","func");
  94.         text = text.replace("procedure","proc");
  95.         text = text.replace("true","1");
  96.         text = text.replace("false","0");
  97.  
  98.  
  99.         for(int i = 0 ; i < text.length() ; ++i){
  100.             char ch = text.charAt(i);
  101.             String small = "йцукенгшщзхъфывапролджэёячсмитьбю";
  102.             String big = "ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЁЯЧСМИТЬБЮ";
  103.             if(small.indexOf(ch) != -1 && !ck){
  104.                 code += 'a';
  105.                 ck = true;
  106.             }else if(big.indexOf(ch) != -1 && !ck){
  107.                 code += 'A';
  108.                 ck = true;
  109.             }else if(small.indexOf(ch) == -1 && big.indexOf(ch) == -1){
  110.                 code += ch;
  111.                 ck = false;
  112.             }
  113.         }
  114.         String temp = "";
  115.         boolean add = false;
  116.         int st = 0;
  117.         for(int i = 0 ; i < code.length() ; ++i){
  118.             char ch = code.charAt(i);
  119.             if(st == 0 && ch == '\''){
  120.                 add = false;
  121.                 temp += ch;
  122.                 st = 1;
  123.                 continue;
  124.             }
  125.             if(st == 1 && ch == '\''){
  126.                 st = 0;
  127.                 temp += ch;
  128.                 continue;
  129.             }
  130.             if(st == 1 && ch == '\\'){
  131.                 st = 2;
  132.                 continue;
  133.             }
  134.             if(st == 2){
  135.                 st = 1;
  136.                 continue;
  137.             }
  138.             if(st == 1) {
  139.                 if(add == false){
  140.                     temp += ch;
  141.                     add = true;
  142.                 }
  143.                 continue;
  144.             }
  145.             temp += ch;
  146.         }
  147.         return temp.toLowerCase();
  148.     }
  149.  
  150.     public ArrayList<Map<Tokens , String>> Tokenize() throws Exception{
  151.         int wasbegin = 0;
  152.         Set<String> consts = new HashSet<>();
  153.         String last_key = "";
  154.  
  155.         File file = new File(path);
  156.  
  157.         String text = "";
  158.         try {
  159.             FileInputStream fis = new FileInputStream(new File(path));
  160.             byte[] data = new byte[(int) file.length()];
  161.             fis.read(data);
  162.             fis.close();
  163.             text = new String(data, "UTF-8");
  164.         }catch(FileNotFoundException e){
  165.             System.out.print(path + " File not found");
  166.         }catch(IOException e) {
  167.             e.printStackTrace();
  168.         }
  169.  
  170.         ArrayList<Map<Tokens , String>> ans = new ArrayList<>();
  171.         String code = Prepare(text);
  172.         //    System.out.println(code);
  173.         while(code.length() > 0 && (code.charAt(0) == ' ' || code.charAt(0) == '\n' || code.charAt(0) == '\t'))code = code.substring(1);
  174.         while(code.length() > 0){
  175.             Tokens tokType = Tokens.Comment;
  176.             int len = -1;
  177.             for(Tokens tok : regular.keySet()){
  178.                 Pattern trg = regular.get(tok);
  179.  
  180.                 String tmp = code;
  181.                 for(int j = code.length() ; j > 0 ; --j){
  182.                     Matcher tmat = trg.matcher(tmp);
  183.                     if(tmat.matches()){
  184.                         if(j > len || (j == len && priority.get(tok) > priority.get(tokType))){
  185.                             len = j;
  186.                             tokType = tok;
  187.                             break;
  188.                         }
  189.                     }
  190.                     tmp = tmp.substring(0 , tmp.length() - 1);
  191.                 }
  192.  
  193.  
  194.                 Matcher tmat = trg.matcher(code);
  195.  
  196.                 MatchResult res1 = tmat.toMatchResult();
  197.                 try{
  198.                     System.out.println(res1.end());
  199.                 }catch(java.lang.IllegalStateException e){}
  200.                 if(tmat.matches()){
  201.                     MatchResult res = tmat.toMatchResult();
  202.                     if(res.start() == 0){
  203.                         if(res.end() > len){
  204.                             len = res.end();
  205.                             tokType = tok;
  206.                         }
  207.                     }
  208.                 }
  209.             }
  210.             if(len <= 0){
  211.                 throw new Exception("Unknown lexeme " + code);
  212.             }
  213.  
  214.             if(tokType == Tokens.IDN){
  215.                 if(ans.size() > 0) {
  216.                     for (Tokens tk : ans.get(ans.size() - 1).keySet()) {
  217.                         if (tk == Tokens.Keyword && (ans.get(ans.size() - 1).get(tk).equals("procedure")
  218.                                 || ans.get(ans.size() - 1).get(tk).equals("function"))) {
  219.                             tokType = ans.get(ans.size() - 1).get(tk).equals("function") ? Tokens.FUNC_NAME : Tokens.PROC_NAME;
  220.                         }
  221.                     }
  222.                 }
  223.             }
  224.  
  225.          /*   if(tokType == Tokens.Keyword && code.substring(0 , 2).equals("if")){
  226.                 ++opif;
  227.             }
  228.             if(opif > 0 && tokType == Tokens.Keyword && code.substring(0 , 4).equals("then")){
  229.                 ++opth;
  230.             }*/
  231.             if(wasbegin == 0 && tokType == Tokens.Keyword && code.substring(0 , 5).equals("begin")){
  232.                 ++wasbegin;
  233.             }
  234.             if(tokType == Tokens.Double){
  235.                 tokType = Tokens.DIGIT;
  236.             }
  237.             if(wasbegin > 0 && tokType == Tokens.Punctuation && code.substring(0 , 1).equals("(")){
  238.                 if(ans.size() > 1){
  239.                     for (Tokens tk : ans.get(ans.size() - 1).keySet()) {
  240.                         if(tk == Tokens.IDN){
  241.                             boolean ck = false;
  242.                             String str = "";
  243.                             str = ans.get(ans.size() - 1).get(tk);
  244.  
  245.                             for(Tokens tk2 : ans.get(ans.size() - 2).keySet()){
  246.                                 if(tk2 == Tokens.Operator || (tk2 == Tokens.Punctuation && (",(").contains(ans.get(ans.size() - 2).get(tk2)))){
  247.                                     ck = true;//function
  248.                                 }
  249.                             }
  250.                         //    System.out.println(ck);
  251.                             ans.get(ans.size() - 1).clear();
  252.                             if(ck){
  253.                                 ans.get(ans.size() - 1).put(Tokens.FUNC_NAME , str);
  254.                             }else{
  255.                                 ans.get(ans.size() - 1).put(Tokens.PROC_NAME , str);
  256.                             }
  257.                         }
  258.                     }
  259.                 }
  260.             }
  261.  
  262.             if(tokType == Tokens.Keyword){
  263.                 last_key = code.substring(0 , len);
  264.             }
  265.             if(last_key.equals("const") && tokType == Tokens.IDN){
  266.                 consts.add(code.substring(0 , len));
  267.             //    tokType = Tokens.CONST_NAME;
  268.             }
  269.             if(!last_key.equals("const") && tokType == Tokens.IDN && consts.contains(code.substring(0 , len))){
  270.                 tokType = Tokens.CONST_NAME;
  271.             }
  272.  
  273.             Map<Tokens , String> curans = new HashMap<>();
  274.             curans.put(tokType , code.substring(0 , len));
  275.         //    System.out.println(curans);
  276.          //   if(tokType != Tokens.Comment)
  277.             int repeat = 1;
  278.             if(wasbegin > 0 && tokType == Tokens.Punctuation && code.substring(0 , len).equals(";")){
  279.                 ++repeat;
  280.             }
  281.             for(int kk = 0 ; kk < repeat ; ++kk)
  282.                 ans.add(curans);
  283.             //      System.out.println(code.substring(0 , len) + " " + tokType.toString());
  284.             code = code.substring(len);
  285.             code = code.trim();
  286.         }
  287.  
  288.         int sz = ans.size() - 1;
  289.         int st = 0;
  290.         lab:
  291.         while(true){
  292.             for(Tokens tk : ans.get(sz).keySet()){
  293.                 if(tk == Tokens.Comment) {
  294.                     --sz;
  295.                     continue lab;
  296.                 }
  297.             }
  298.  
  299.             for(Tokens tk : ans.get(sz).keySet()) {
  300.                 if (st == 0 && tk == Tokens.Punctuation && ans.get(sz).get(tk).equals(".")) {
  301.                     st = 1;
  302.                     --sz;
  303.                     continue lab;
  304.                 }
  305.                 if (st == 1 && tk == Tokens.Keyword && ans.get(sz).get(tk).equals("end")) {
  306.                     st = 2;
  307.                     --sz;
  308.                     continue lab;
  309.                 }
  310.  
  311.                 if (st == 2 && (tk != Tokens.Punctuation || !ans.get(sz).get(tk).equals(";"))) {
  312.                     Map<Tokens, String> curans = new HashMap<>();
  313.                     curans.put(Tokens.Punctuation, ";");
  314.                     ans.add(sz + 1, curans);ans.add(sz + 1, curans);
  315.                 }
  316.                 return ans;
  317.             }
  318.         }
  319.  
  320.      //   return ans;
  321.     }
  322. }
  323.  
  324. public class SysProgrammingMainAlgorithm {
  325.  
  326.     public static void main(String[] args) {
  327.         byte [] readline=new byte [80];
  328.         boolean result;
  329.         String fileName;
  330.         MyLang testLang=null;
  331.         int codeAction, llk=1, textLen;
  332.         String [] menu= { "*1.  Прочитати граматику з файла  ",
  333.                 " 2.  Лабораторна робота. Клас будує студент",
  334.                 " 3.  Надрукувати граматику",
  335.                 "*4.  Побудувати списки терміналів та нетерміналів",
  336.                 "*5.  Пошук непродуктивних нетерміналів",
  337.                 "*6.  Пошук недосяжних нетерміналів",
  338.                 "*7.  Побудова списку епсілон-нетерміналів",
  339.                 " 8.  Друк списку епсілон-нетерміналів",
  340.                 " 9.  Пошук ліворекурсивних нетерміналів",
  341.                 " 10. Пошук різних ліворекурсивних виводів мінімальної довжини",
  342.                 " 11. Пошук праворекурсивних нетерміналів",
  343.                 " 12. Пошук різних праворекурсивних виводів мінімальної довжини",
  344.                 "*13. Побудувати множини FirstK(A), A-нетермінал",
  345.                 " 14. Вивести на термінал множини FirstK(A), A-нетермінал",
  346.                 "*15. Побудувати множини FollowK(A), A-нетермінал",
  347.                 " 16. Вивести на термінал множини FollowK(A), A-нетермінал",
  348.                 "*17. Побудувати множини FirstK(w) + FollowK(A) для правила А->w",
  349.                 " 18. Вивести на термінал FirstK(w) + FollowK(A) для всіх правил А->w",
  350.                 " 19. Вивести на термінал FirstK(w) + FollowK(A) для вибраних правил А->w",
  351.                 "*20. Перевірка сильної LL(1)-властивості",
  352.                 " 21. Побудова таблиці LL(1)-синтаксичного аналізатора",
  353.                 " 22. Синтаксичний аналізатор. Клас будує студент",
  354.                 "*23. Побудувати множини LocalK(A), A-нетермінал",
  355.                 " 24. Вивести на термінал множини LocalK(A), A-нетермінал",
  356.                 "*25. Перевірка LL(k)-властивості, k>1",
  357.                 " 26. Вихід з системи"
  358.         };
  359.         do  {
  360.             codeAction=0;
  361.             String upr;
  362.             for (String ss: menu) System.out.println(ss); // вивести меню
  363.             System.out.println("Введіть код дії або end:");
  364.             do {  // цикл перебору даних
  365.                 try {
  366.                     textLen=System.in.read(readline);
  367.                     upr = new String (readline,0,textLen, "ISO-8859-1");
  368.                     if (upr.trim().equals("end") ) return;
  369.                     codeAction=new Integer (upr.trim());
  370.                 }
  371.                 catch(Exception ee)
  372.                 { System.out.println ("Невірний код дії, повторіть: ");
  373.                     continue;
  374.                 }
  375.                 if (codeAction >=1  &&  codeAction<=menu.length ) {
  376.                     if (menu [codeAction-1].substring(0, 1).equals("+"))  {
  377.                         System.out.println("Елемент меню " +codeAction+" повторно виконати неможливо");
  378.                         continue ;
  379.                     }
  380.                     int itmp;
  381.                     for (itmp=0; itmp < codeAction-1; itmp++)
  382.                         if (menu[itmp].substring(0, 1).equals("*")) break;
  383.                     if (itmp !=codeAction-1) {
  384.                         System.out.println ("Виконайте попередні елементи меню, що позначені * : ");
  385.                         continue ;
  386.                     }
  387.                     if(codeAction == 2){
  388.                         for(itmp=0; itmp <= 7 ; ++itmp){
  389.                             if(menu[itmp].substring(0, 1).equals("*")) break;
  390.                         }
  391.                         if(itmp != 8){
  392.                             System.out.println ("Виконайте елементи меню до 8го, що позначені * : ");
  393.                             continue ;
  394.                         }
  395.                     }
  396.                     break;
  397.                 }
  398.                 else {
  399.                     System.out.println ("Невірний код дії, повторіть: ");
  400.                     continue ;
  401.                 }
  402.             }  while (true);
  403.             // перевірка на виконання усіх попередніх дій
  404.             result=false;
  405.             switch (codeAction) {
  406.                 case 1: //1. Прочитати граматику з файла",
  407.                     System.out.print ("Введіть ім'я файлу граматики:");
  408.                     try {
  409.                         textLen=System.in.read(readline);
  410.                         fileName = new String (readline,0,textLen, "ISO-8859-1");
  411.                         fileName = fileName.trim();
  412.                     }
  413.                     catch(Exception ee)
  414.                     { System.out.println ("Системна помилка: "+ee.toString());
  415.                         return;
  416.                     }
  417.                     System.out.print ("Введіть значення параметра k : ");
  418.                     try {
  419.                         textLen=System.in.read(readline);
  420.                         String llkText = new String (readline,0,textLen, "ISO-8859-1");
  421.                         llkText = llkText.trim();
  422.                         llk=Integer.parseInt(llkText);
  423.                     }
  424.                     catch(Exception ee)
  425.                     { System.out.println ("Системна помилка: "+ee.toString());
  426.                         return;
  427.                     }
  428.                     testLang = new MyLang (fileName,llk);
  429.                     if (!testLang.isCreate()) break;  //не створили об'єкт
  430.                     System.out.println ("Граматика прочитана успішно");
  431.                     result=true;
  432.                     for (int jj=0;  jj<menu.length; jj++) {
  433.                         if (menu [jj].substring(0, 1).equals(" ")) continue;
  434.                         menu [jj]=menu [jj].replace(menu [jj].charAt(0), '*');
  435.                     }
  436.                     break;
  437.                 case 2: //2. Лабораторна робота студента
  438.                     boolean ck = false;
  439.                     int[] term = testLang.getTerminals();
  440.                     int[] nonterm = testLang.getNonTerminals();
  441.  
  442.                     Map<Integer , Integer> notrm = new HashMap();
  443.                     Map<Integer , Integer> trm = new HashMap();
  444.  
  445.                     for(int i = 0 ; i < term.length ; ++i){
  446.                         trm.put(term[i] , i);
  447.                     }
  448.                     for(int i = 0 ; i < nonterm.length ; ++i){
  449.                         notrm.put(nonterm[i] , i);
  450.                     }
  451.  
  452.                     LlkContext[] llkTrmContext = testLang.getLlkTrmContext();
  453.                     LlkContext[] res_cur = new LlkContext[nonterm.length];
  454.  
  455.                     for (int i = 0; i < nonterm.length; ++i) {
  456.                         res_cur[i] = new LlkContext();
  457.                     }
  458.  
  459.                     for(int u : testLang.getEpsilonNonterminals()){
  460.                         res_cur[notrm.get(u)].addWord(new int[0]);
  461.                     }
  462.  
  463.                     ck = true;
  464.  
  465.                     while(ck){
  466.                         ck = false;
  467.  
  468.                         for(Node node : testLang.getLanguarge()) {
  469.                             int[] rool = node.getRoole();
  470.                             int left = notrm.get(rool[0]);
  471.                             int last = 1;
  472.                             if(rool.length == 1)continue;
  473.  
  474.                             Queue<ArrayList<Integer>> q = new LinkedList<>();
  475.  
  476.                             ArrayList<Integer> temp = new ArrayList<>();
  477.                             temp.add(-1);
  478.  
  479.                             q.add(temp);
  480.  
  481.                             ArrayList<ArrayList<Integer>> done = new ArrayList<>();
  482.  
  483.                             for(; last < rool.length ; ++last){
  484.                                 int cur = rool[last] > 0 ? trm.get(rool[last]) : notrm.get(rool[last]);
  485.                                 LlkContext tmp = rool[last] > 0 ? llkTrmContext[cur] : res_cur[cur];
  486.                                 if(rool[last] < 0 && res_cur[cur].calcWords() == 0)break;
  487.                                 boolean cont = false;
  488.                                 while(!q.isEmpty()){
  489.                                     ArrayList<Integer> word = (ArrayList<Integer>)q.peek().clone();
  490.                                     if(word.get(0) == last){
  491.                                         cont = true;
  492.                                         break;
  493.                                     }
  494.                                     q.poll();
  495.                                     for(int i = 0 ; i < tmp.calcWords() ; ++i){
  496.                                         ArrayList<Integer> word1 = (ArrayList<Integer>)word.clone();
  497.                                         word1.set(0 , last);
  498.                                         for(int j = 0 ; j < tmp.getWord(i).length ; ++j){
  499.                                             word1.add(tmp.getWord(i)[j]);
  500.                                         }
  501.                                         if(word1.size() - 1 >= testLang.getLlkConst()){
  502.                                             done.add(word1);
  503.                                         }else{
  504.                                             q.add(word1);
  505.                                         }
  506.                                     }
  507.                                 }
  508.                                 if(cont)continue;
  509.                                 break;
  510.                             }
  511.  
  512.                             while(last == rool.length && !q.isEmpty()){
  513.                                 ArrayList<Integer> word = (ArrayList<Integer>)q.peek().clone();
  514.                                 q.poll();
  515.                                 done.add(word);
  516.                             }
  517.  
  518.                             for(int i = 0 ; i < done.size() ; ++i){
  519.                                 int word[] = new int[Math.min(done.get(i).size() - 1 , testLang.getLlkConst())];
  520.                                 for(int j = 0 ; j < word.length ; ++j){
  521.                                     word[j] = done.get(i).get(j + 1);
  522.                                 }
  523.                                 ck |= (res_cur[left].addWord(word));
  524.                             }
  525.                         }
  526.                     }
  527.  
  528.                     testLang.setFirstK(res_cur);
  529.                     testLang.printFirstkContext();
  530.  
  531.                     break;
  532.                 case 3:  // Надрукувати граматику
  533.                     testLang.printGramma();
  534.                     break;
  535.                 case 4:  // надрукувати список терміналів та нетерміналів
  536.                     testLang.printTerminals();
  537.                     testLang.printNonterminals();
  538.                     result=true;
  539.                     break;
  540.                 case 5: // вивести непродуктивні правила
  541.                     result=testLang.createNonProdRools();
  542.                     break;
  543.                 case 6: // недосяжні нетермінали
  544.                     result=testLang.createNonDosNeterminals();
  545.                     break;
  546.                 case 7:  //Побудова списку епсілон-нетерміналів
  547.                     int [] epsilon=testLang.createEpsilonNonterminals ();
  548.                     testLang.setEpsilonNonterminals (epsilon);
  549.                     result=true;
  550.                     break;
  551.                 case 8: //Друк списку епсілон-нетерміналів
  552.                     testLang.printEpsilonNonterminals();
  553.                     break;
  554.                 case 9:    //Пошук ліворекурсивних нетерміналів"
  555.                     testLang.leftRecursNonnerminal();
  556.                     break;
  557.                 case 10:  //Пошук різних ліворекурсивних виводів мінімальної довжини"
  558.                     testLang.leftRecusionTrace();
  559.                     break;
  560.                 case 11:  //Пошук праворекурсивних нетерміналів"
  561.                     testLang.rightRecursNonnerminal();
  562.                     break;
  563.                 case 12:  //Пошук різних праворекурсивних виводів мінімальної довжини"
  564.                     testLang.rigthRecusionTrace();
  565.                     break;
  566.                 case 13:  //Побудувати множини FirstK
  567.                     LlkContext [] firstContext = testLang.firstK();
  568.                     testLang.setFirstK(firstContext);
  569.                     result=true;
  570.                     break;
  571.                 case 14:  //Друк множини FirstK
  572.                     testLang.printFirstkContext ( );
  573.                     break;
  574.                 case 15:  //Побудувати множини FollowK
  575.                     LlkContext [] followContext = testLang.followK();
  576.                     testLang.setFollowK(followContext);
  577.                     result=true;
  578.                     break;
  579.                 case 16:  //Друк множини FollowK
  580.                     testLang.printFollowkContext ( );
  581.                     break;
  582.                 case 17:  //Побудувати множини FirstK(w) + FollowK(A) для правила А->w
  583.                     testLang.firstFollowK ( );
  584.                     result=true;
  585.                     break;
  586.                 case 18:  //Друк множини FirstK(w) + FollowK(A) для правила А->w
  587.                     testLang.printFirstFollowK( );
  588.                     break;
  589.                 case 19:  //Друк множини FirstK(w) + FollowK(A) для вибраних правил А->w
  590.                     testLang.printFirstFollowForRoole();
  591.                     break;
  592.                 case 20:  //Перевірка сильної LL(k)-властивості",
  593.                     result=testLang. strongLlkCondition () ;
  594.                     break;
  595.                 case 21:  //Побудова таблиці LL(1)-синтаксичного аналізатора
  596.                     int [][] uprTable=testLang.createUprTable ();
  597.                     testLang.setUprTable(uprTable);
  598.                     break;
  599.                 case 22: // PASCAL
  600.                     String path;
  601.                     System.out.println("Введiть назву вхiдного файлу: ");
  602.                     try{
  603.                         textLen=System.in.read(readline);
  604.                         String codepath = new String (readline,0,textLen, "ISO-8859-1");
  605.                         LexPascal lex = new LexPascal(codepath);
  606.                         ArrayList<Map<Tokens , String>> tokens = lex.Tokenize();
  607.  
  608.                  /*       for(Map<Tokens , String> mp : tokens){
  609.                             for(Tokens tk : mp.keySet()){
  610.                                 System.out.println(tk.toString() + " " + mp.get(tk));
  611.                             }
  612.                         }*/
  613.  
  614.  
  615.                         boolean accepted = true;
  616.  
  617.                         Stack<Integer> st = new Stack<>();
  618.                         st.push(testLang.getAxioma());
  619.  
  620.                         int[][] table = testLang.getUprTable();
  621.  
  622.                         for(int kk = 0 ; kk < tokens.size() ; ++kk , kk = Math.max(kk , 0)){
  623.                             Map<Tokens , String> mp = tokens.get(kk);
  624.  
  625.                             boolean skip = false;
  626.                             for(Tokens tk : mp.keySet()){
  627.                                 if(tk == Tokens.Comment){
  628.                                     skip = true;
  629.                                 }
  630.                             }
  631.  
  632.                             if(skip) {
  633.                                 continue;
  634.                             }
  635.  
  636.                             if(st.isEmpty()){
  637.                                 System.out.println("Error, stack is empty! ");
  638.                                 accepted = false;
  639.                                 break;
  640.                             }
  641.  
  642.                             int top = st.peek();
  643.  
  644.                             if(top < 0){//top is non terminal
  645.                                 int cur = -1;
  646.                                 int nt[] = testLang.getNonTerminals();
  647.  
  648.                                 for(int i = 0 ; i < nt.length ; ++i){
  649.                                     if(top == nt[i]){
  650.                                         cur = i;
  651.                                         break;
  652.                                     }
  653.                                 }
  654.  
  655.                                 //check that cur != -1
  656.  
  657.                                 int el = -1;
  658.                                 int tr[] = testLang.getTerminals();
  659.  
  660.                                 for(int i = 0 ; i < tr.length ; ++i){
  661.                                     String terminal = testLang.getLexemaText(tr[i]);
  662.                                     for(Tokens tk : mp.keySet()){
  663.                                         if(terminal.equals(mp.get(tk)) || terminal.equals(tk.toString())){
  664.                                             el = i;
  665.                                             break;
  666.                                         }
  667.                                     }
  668.                                 }
  669.  
  670.                                 if(cur < 0 || el < 0){
  671.                                     System.out.println("Error, no such lexema found in the grammar!");
  672.                                 }
  673.  
  674.                                 int next = table[cur][el];
  675.  
  676.                                 LinkedList<Node> lang = testLang.getLanguarge();
  677.                                 int rule[] = lang.get(Math.max(next - 1 , 0)).getRoole();
  678.  
  679.                                 st.pop();
  680.  
  681.                                 for(int i = rule.length - 1; i >= 1 ; --i) {
  682.                                     st.push(rule[i]);
  683.                                 }
  684.  
  685.                                 --kk;
  686.                             }else{//top is terminal
  687.                                 String terminal = testLang.getLexemaText(top);
  688.  
  689.                                 boolean eq = false;
  690.  
  691.                                 for(Tokens tk : mp.keySet()){
  692.                                     if(terminal.equals(mp.get(tk)) || terminal.equals(tk.toString())){
  693.                                         eq = true;
  694.                                     }
  695.                                 }
  696.  
  697.                                 if(eq){
  698.                                     st.pop();
  699.                                     continue;
  700.                                 }else{
  701.                                     System.out.println("Error: " + mp + " found, expected: " + terminal);
  702.                                     accepted = false;
  703.                                     break;
  704.                                 }
  705.  
  706.  
  707.                             }
  708.                         }
  709.                         if(!st.isEmpty() && accepted){
  710.                             accepted = false;
  711.                             System.out.println("Error, analyzer have reached end of the code, but stack is not empty!");
  712.                         }
  713.  
  714.                         if(accepted == true) {
  715.                             System.out.print("OK\n");
  716.                         //    System.out.println(st);
  717.                         }
  718.  
  719.  
  720.                     }catch (java.io.IOException e ){}
  721.                     catch (java.lang.Exception e){e.printStackTrace();}
  722.  
  723.  
  724.  
  725.  
  726.                     break;
  727.  
  728.                 case 23: // 23. Побудувати множини LocalK(A), A-нетермінал
  729.                     LinkedList <LlkContext> [] Localk=testLang.createLocalK();
  730.                     testLang.setLocalkContext(Localk);
  731.                     result=true;
  732.                     break;
  733.                 case 24: // 24. Вивести на термінал множини LocalK(A), A-нетермінал
  734.                     testLang.printLocalk();
  735.                     break;
  736.                 case 25: // 25. Перевірка LL(k)-властивості, k>1
  737.                     result= testLang.llkCondition();
  738.                     break;
  739.                 case 26: // rtrtrtr
  740.                     return;
  741.                 case 27:
  742.                     break;
  743.             }  // кінець switch
  744.             // блокуємо елемент обробки
  745.             if (result) // функція виконана успішно
  746.                 if (menu [codeAction-1].substring(0, 1).equals("*"))
  747.                     menu [codeAction-1]=menu [codeAction-1].replace('*', '+') ;
  748.         } while (true);  //глобальний цикл  обробки
  749.  
  750.     }  // кінець main
  751.  
  752.     static void tesrReadWrite(String fname)
  753.     {  String readline;
  754.         BufferedReader s;
  755.         BufferedWriter bw;
  756.         try {
  757.             s = new BufferedReader(new FileReader(fname));
  758.             bw = new BufferedWriter (new FileWriter("c:\\rez.txt"));
  759.             // s=new FileInputStream (fname);
  760.             //s=new FileInputStream ("C:\\Eclipse\\C1.txt");
  761.             //s=new FileInputStream ("C:\\test1.txt");
  762.             while ( s.ready() ) {
  763.                 readline= s.readLine();
  764.                 System.out.println(readline);
  765.                 //System.out.println("Read Line");
  766.                 //bw.write(readline, 0,readline.length() );
  767.                 //bw.write((int)'\r'); bw.flush();
  768.                 //System.out.println("Print Line");
  769.             }
  770.  
  771.             //bw.close();
  772.         }
  773.         catch(Exception ee)
  774.         {
  775.             System.out.print("File: " +fname + "not found\n");
  776.             //return;
  777.         }
  778.     }
  779. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!