API tools faq
paste
Advertisement
osipyonok

Untitled

osipyonok
May 31st, 2017
213
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 46.87 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.     table_name,
  24.     col_name,
  25.     name,
  26.     Atom,
  27.     Int,
  28.     Hex,
  29.     Double,
  30.     Comment,
  31.     String,
  32.     Char,
  33.     Directive,
  34.     Operator,
  35.     Punctuation,
  36.     CONST_NAME,
  37.     DIGIT,
  38.     IDN,
  39.     LITER_STR,
  40.     PROC_NAME,
  41.     FUNC_NAME,
  42.     TYPE_NAME
  43. }
  44.  
  45.  
  46.  
  47.  
  48. class LexPascal{
  49.     private String path = "";
  50.     private static Map<Tokens , Pattern> regular = new HashMap<Tokens , Pattern>();
  51.     private static Map<Tokens , Integer> priority = new HashMap<Tokens , Integer>();
  52.  
  53.     public LexPascal(String _path){
  54.         path = _path.trim();
  55.         InitRegex();
  56.         InitPriority();
  57.     }
  58.  
  59.     private void InitRegex(){
  60.         regular.put(Tokens.IDN , Pattern.compile("^(_|[a-z])([a-z]|[0-9]|_)*"));
  61.         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)"));
  62.         regular.put(Tokens.DIGIT , Pattern.compile("^(0|[1-9]\\d*)"));
  63.         regular.put(Tokens.LITER_STR, Pattern.compile("^'(?:[^']+|(''))*'$"));
  64.         regular.put(Tokens.Comment, Pattern.compile("^(//(.*?)//|\\{(.*?)\\}|\\(\\*(.*?)\\*\\))"));
  65.         regular.put(Tokens.Punctuation, Pattern.compile("^(\\(|\\)|;|,|\\.|:|\\[|\\]|\\^|\\.\\.)"));
  66. //        regular.put(Tokens.Hex, Pattern.compile("^0[xX]((0|[1-9a-fA-F][\\da-fA-F]*))"));
  67.         regular.put(Tokens.Operator, Pattern.compile("^\\+|\\-|\\*|/|:=|<>|=|>|<|>=|<=|!=|div|mod|and|not|~"));
  68.         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]))"));
  69. //        regular.put(Tokens.Directive, Pattern.compile("^mp:.*"));
  70.         regular.put(Tokens.TYPE_NAME , Pattern.compile("^(byte|integer|real|char|boolean|string)"));
  71.         //   regular.put(Tokens.PROC_NAME , Pattern.compile("^(randomize)"));
  72.     }
  73.  
  74.     private void InitPriority(){
  75.         priority.put(Tokens.Operator, 10);
  76.         priority.put(Tokens.Punctuation, 2);
  77.         priority.put(Tokens.Double, 3);
  78.         priority.put(Tokens.DIGIT, 4);
  79.         priority.put(Tokens.Hex, 4);
  80.         priority.put(Tokens.IDN, 5);
  81.         priority.put(Tokens.Keyword, 6);
  82.         priority.put(Tokens.LITER_STR, 7);
  83.         priority.put(Tokens.TYPE_NAME, 8);
  84.         priority.put(Tokens.Comment, 9);
  85.     }
  86.  
  87.     private String Prepare(String text){
  88.         text = text.toLowerCase();
  89.         String code = "";
  90.         boolean ck = false;
  91.  
  92.         //  text = text.replace(";",";;");
  93.         text = text.replace("clrscr;","clrscr();");
  94.         text = text.replace("writeln;","writeln();");
  95.         text = text.replace("write;","write();");
  96.         text = text.replace("readln;","readln();");
  97.         text = text.replace("read;","read();");
  98.         text = text.replace("randomize;","randomize();");
  99.         text = text.replace("function","func");
  100.         text = text.replace("procedure","proc");
  101.         text = text.replace("true","1");
  102.         text = text.replace("false","0");
  103.  
  104.  
  105.         for(int i = 0 ; i < text.length() ; ++i){
  106.             char ch = text.charAt(i);
  107.             String small = "йцукенгшщзхъфывапролджэёячсмитьбю";
  108.             String big = "ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЁЯЧСМИТЬБЮ";
  109.             if(small.indexOf(ch) != -1 && !ck){
  110.                 code += 'a';
  111.                 ck = true;
  112.             }else if(big.indexOf(ch) != -1 && !ck){
  113.                 code += 'A';
  114.                 ck = true;
  115.             }else if(small.indexOf(ch) == -1 && big.indexOf(ch) == -1){
  116.                 code += ch;
  117.                 ck = false;
  118.             }
  119.         }
  120.         String temp = "";
  121.         boolean add = false;
  122.         int st = 0;
  123.         for(int i = 0 ; i < code.length() ; ++i){
  124.             char ch = code.charAt(i);
  125.             if(st == 0 && ch == '\''){
  126.                 add = false;
  127.                 temp += ch;
  128.                 st = 1;
  129.                 continue;
  130.             }
  131.             if(st == 1 && ch == '\''){
  132.                 st = 0;
  133.                 temp += ch;
  134.                 continue;
  135.             }
  136.             if(st == 1 && ch == '\\'){
  137.                 st = 2;
  138.                 continue;
  139.             }
  140.             if(st == 2){
  141.                 st = 1;
  142.                 continue;
  143.             }
  144.             if(st == 1) {
  145.                 if(add == false){
  146.                     temp += ch;
  147.                     add = true;
  148.                 }
  149.                 continue;
  150.             }
  151.             temp += ch;
  152.         }
  153.         return temp.toLowerCase();
  154.     }
  155.  
  156.     public ArrayList<Map<Tokens , String>> Tokenize() throws Exception{
  157.         int wasbegin = 0;
  158.         Set<String> consts = new HashSet<>();
  159.         String last_key = "";
  160.  
  161.         File file = new File(path);
  162.  
  163.         String text = "";
  164.         try {
  165.             FileInputStream fis = new FileInputStream(new File(path));
  166.             byte[] data = new byte[(int) file.length()];
  167.             fis.read(data);
  168.             fis.close();
  169.             text = new String(data, "UTF-8");
  170.         }catch(FileNotFoundException e){
  171.             System.out.print(path + " File not found");
  172.         }catch(IOException e) {
  173.             e.printStackTrace();
  174.         }
  175.  
  176.         ArrayList<Map<Tokens , String>> ans = new ArrayList<>();
  177.         String code = Prepare(text);
  178.         //    System.out.println(code);
  179.         while(code.length() > 0 && (code.charAt(0) == ' ' || code.charAt(0) == '\n' || code.charAt(0) == '\t'))code = code.substring(1);
  180.         while(code.length() > 0){
  181.             Tokens tokType = Tokens.Comment;
  182.             int len = -1;
  183.             for(Tokens tok : regular.keySet()){
  184.                 Pattern trg = regular.get(tok);
  185.  
  186.                 String tmp = code;
  187.                 for(int j = code.length() ; j > 0 ; --j){
  188.                     Matcher tmat = trg.matcher(tmp);
  189.                     if(tmat.matches()){
  190.                         if(j > len || (j == len && priority.get(tok) > priority.get(tokType))){
  191.                             len = j;
  192.                             tokType = tok;
  193.                             break;
  194.                         }
  195.                     }
  196.                     tmp = tmp.substring(0 , tmp.length() - 1);
  197.                 }
  198.  
  199.  
  200.                 Matcher tmat = trg.matcher(code);
  201.  
  202.                 MatchResult res1 = tmat.toMatchResult();
  203.                 try{
  204.                     System.out.println(res1.end());
  205.                 }catch(java.lang.IllegalStateException e){}
  206.                 if(tmat.matches()){
  207.                     MatchResult res = tmat.toMatchResult();
  208.                     if(res.start() == 0){
  209.                         if(res.end() > len){
  210.                             len = res.end();
  211.                             tokType = tok;
  212.                         }
  213.                     }
  214.                 }
  215.             }
  216.             if(len <= 0){
  217.                 throw new Exception("Unknown lexeme " + code);
  218.             }
  219.  
  220.             if(tokType == Tokens.IDN){
  221.                 if(ans.size() > 0) {
  222.                     for (Tokens tk : ans.get(ans.size() - 1).keySet()) {
  223.                         if (tk == Tokens.Keyword && (ans.get(ans.size() - 1).get(tk).equals("procedure")
  224.                                 || ans.get(ans.size() - 1).get(tk).equals("function"))) {
  225.                             tokType = ans.get(ans.size() - 1).get(tk).equals("function") ? Tokens.FUNC_NAME : Tokens.PROC_NAME;
  226.                         }
  227.                     }
  228.                 }
  229.             }
  230.  
  231.          /*   if(tokType == Tokens.Keyword && code.substring(0 , 2).equals("if")){
  232.                 ++opif;
  233.             }
  234.             if(opif > 0 && tokType == Tokens.Keyword && code.substring(0 , 4).equals("then")){
  235.                 ++opth;
  236.             }*/
  237.             if(wasbegin == 0 && tokType == Tokens.Keyword && code.substring(0 , 5).equals("begin")){
  238.                 ++wasbegin;
  239.             }
  240.             if(tokType == Tokens.Double){
  241.                 tokType = Tokens.DIGIT;
  242.             }
  243.             if(wasbegin > 0 && tokType == Tokens.Punctuation && code.substring(0 , 1).equals("(")){
  244.                 if(ans.size() > 1){
  245.                     for (Tokens tk : ans.get(ans.size() - 1).keySet()) {
  246.                         if(tk == Tokens.IDN){
  247.                             boolean ck = false;
  248.                             String str = "";
  249.                             str = ans.get(ans.size() - 1).get(tk);
  250.  
  251.                             for(Tokens tk2 : ans.get(ans.size() - 2).keySet()){
  252.                                 if(tk2 == Tokens.Operator || (tk2 == Tokens.Punctuation && (",(").contains(ans.get(ans.size() - 2).get(tk2)))){
  253.                                     ck = true;//function
  254.                                 }
  255.                             }
  256.                             //    System.out.println(ck);
  257.                             ans.get(ans.size() - 1).clear();
  258.                             if(ck){
  259.                                 ans.get(ans.size() - 1).put(Tokens.FUNC_NAME , str);
  260.                             }else{
  261.                                 ans.get(ans.size() - 1).put(Tokens.PROC_NAME , str);
  262.                             }
  263.                         }
  264.                     }
  265.                 }
  266.             }
  267.  
  268.             if(tokType == Tokens.Keyword){
  269.                 last_key = code.substring(0 , len);
  270.             }
  271.             if(last_key.equals("const") && tokType == Tokens.IDN){
  272.                 consts.add(code.substring(0 , len));
  273.                 //    tokType = Tokens.CONST_NAME;
  274.             }
  275.             if(!last_key.equals("const") && tokType == Tokens.IDN && consts.contains(code.substring(0 , len))){
  276.                 tokType = Tokens.CONST_NAME;
  277.             }
  278.  
  279.             Map<Tokens , String> curans = new HashMap<>();
  280.             curans.put(tokType , code.substring(0 , len));
  281.             //    System.out.println(curans);
  282.             //   if(tokType != Tokens.Comment)
  283.             int repeat = 1;
  284.             if(wasbegin > 0 && tokType == Tokens.Punctuation && code.substring(0 , len).equals(";")){
  285.                 ++repeat;
  286.             }
  287.             for(int kk = 0 ; kk < repeat ; ++kk)
  288.                 ans.add(curans);
  289.             //      System.out.println(code.substring(0 , len) + " " + tokType.toString());
  290.             code = code.substring(len);
  291.             code = code.trim();
  292.         }
  293.  
  294.         int sz = ans.size() - 1;
  295.         int st = 0;
  296.         lab:
  297.         while(true){
  298.             for(Tokens tk : ans.get(sz).keySet()){
  299.                 if(tk == Tokens.Comment) {
  300.                     --sz;
  301.                     continue lab;
  302.                 }
  303.             }
  304.  
  305.             for(Tokens tk : ans.get(sz).keySet()) {
  306.                 if (st == 0 && tk == Tokens.Punctuation && ans.get(sz).get(tk).equals(".")) {
  307.                     st = 1;
  308.                     --sz;
  309.                     continue lab;
  310.                 }
  311.                 if (st == 1 && tk == Tokens.Keyword && ans.get(sz).get(tk).equals("end")) {
  312.                     st = 2;
  313.                     --sz;
  314.                     continue lab;
  315.                 }
  316.  
  317.                 if (st == 2 && (tk != Tokens.Punctuation || !ans.get(sz).get(tk).equals(";"))) {
  318.                     Map<Tokens, String> curans = new HashMap<>();
  319.                     curans.put(Tokens.Punctuation, ";");
  320.                     ans.add(sz + 1, curans);ans.add(sz + 1, curans);
  321.                 }
  322.                 return ans;
  323.             }
  324.         }
  325.  
  326.         //   return ans;
  327.     }
  328. }
  329.  
  330. public class SysProgrammingMainAlgorithm {
  331.     public static final boolean sql = false;
  332.     public static final boolean debug = false;
  333.  
  334.     public static void main(String[] args) {
  335.         byte [] readline=new byte [80];
  336.         boolean result;
  337.         String fileName;
  338.         MyLang testLang=null;
  339.         int codeAction, llk=1, textLen;
  340.         String [] menu= { "*1.  Прочитати граматику з файла  ",
  341.                 " 2.  Лабораторна робота. Клас будує студент",
  342.                 " 3.  Надрукувати граматику",
  343.                 "*4.  Побудувати списки терміналів та нетерміналів",
  344.                 "*5.  Пошук непродуктивних нетерміналів",
  345.                 "*6.  Пошук недосяжних нетерміналів",
  346.                 "*7.  Побудова списку епсілон-нетерміналів",
  347.                 " 8.  Друк списку епсілон-нетерміналів",
  348.                 " 9.  Пошук ліворекурсивних нетерміналів",
  349.                 " 10. Пошук різних ліворекурсивних виводів мінімальної довжини",
  350.                 " 11. Пошук праворекурсивних нетерміналів",
  351.                 " 12. Пошук різних праворекурсивних виводів мінімальної довжини",
  352.                 "*13. Побудувати множини FirstK(A), A-нетермінал",
  353.                 " 14. Вивести на термінал множини FirstK(A), A-нетермінал",
  354.                 "*15. Побудувати множини FollowK(A), A-нетермінал",
  355.                 " 16. Вивести на термінал множини FollowK(A), A-нетермінал",
  356.                 "*17. Побудувати множини FirstK(w) + FollowK(A) для правила А->w",
  357.                 " 18. Вивести на термінал FirstK(w) + FollowK(A) для всіх правил А->w",
  358.                 " 19. Вивести на термінал FirstK(w) + FollowK(A) для вибраних правил А->w",
  359.                 "*20. Перевірка сильної LL(1)-властивості",
  360.                 " 21. Побудова таблиці LL(1)-синтаксичного аналізатора",
  361.                 " 22. Синтаксичний аналізатор. Клас будує студент",
  362.                 "*23. Побудувати множини LocalK(A), A-нетермінал",
  363.                 " 24. Вивести на термінал множини LocalK(A), A-нетермінал",
  364.                 "*25. Перевірка LL(k)-властивості, k>1",
  365.                 " 26. Вихід з системи"
  366.         };
  367.         do  {
  368.             codeAction=0;
  369.             String upr;
  370.             for (String ss: menu) System.out.println(ss); // вивести меню
  371.             System.out.println("Введіть код дії або end:");
  372.             do {  // цикл перебору даних
  373.                 try {
  374.                     textLen=System.in.read(readline);
  375.                     upr = new String (readline,0,textLen, "ISO-8859-1");
  376.                     if (upr.trim().equals("end") ) return;
  377.                     codeAction=new Integer (upr.trim());
  378.                 }
  379.                 catch(Exception ee)
  380.                 { System.out.println ("Невірний код дії, повторіть: ");
  381.                     continue;
  382.                 }
  383.                 if (codeAction >=1  &&  codeAction<=menu.length ) {
  384.                     if (menu [codeAction-1].substring(0, 1).equals("+"))  {
  385.                         System.out.println("Елемент меню " +codeAction+" повторно виконати неможливо");
  386.                         continue ;
  387.                     }
  388.                     int itmp;
  389.                     for (itmp=0; itmp < codeAction-1; itmp++)
  390.                         if (menu[itmp].substring(0, 1).equals("*")) break;
  391.                     if (itmp !=codeAction-1) {
  392.                         System.out.println ("Виконайте попередні елементи меню, що позначені * : ");
  393.                         continue ;
  394.                     }
  395.                     if(codeAction == 2){
  396.                         for(itmp=0; itmp <= 7 ; ++itmp){
  397.                             if(menu[itmp].substring(0, 1).equals("*")) break;
  398.                         }
  399.                         if(itmp != 8){
  400.                             System.out.println ("Виконайте елементи меню до 8го, що позначені * : ");
  401.                             continue ;
  402.                         }
  403.                     }
  404.                     break;
  405.                 }
  406.                 else {
  407.                     System.out.println ("Невірний код дії, повторіть: ");
  408.                     continue ;
  409.                 }
  410.             }  while (true);
  411.             // перевірка на виконання усіх попередніх дій
  412.             result=false;
  413.             switch (codeAction) {
  414.                 case 1: //1. Прочитати граматику з файла",
  415.                     System.out.print ("Введіть ім'я файлу граматики:");
  416.                     try {
  417.                         textLen=System.in.read(readline);
  418.                         fileName = new String (readline,0,textLen, "ISO-8859-1");
  419.                         fileName = fileName.trim();
  420.                     }
  421.                     catch(Exception ee)
  422.                     { System.out.println ("Системна помилка: "+ee.toString());
  423.                         return;
  424.                     }
  425.                     System.out.print ("Введіть значення параметра k : ");
  426.                     try {
  427.                         textLen=System.in.read(readline);
  428.                         String llkText = new String (readline,0,textLen, "ISO-8859-1");
  429.                         llkText = llkText.trim();
  430.                         llk=Integer.parseInt(llkText);
  431.                     }
  432.                     catch(Exception ee)
  433.                     { System.out.println ("Системна помилка: "+ee.toString());
  434.                         return;
  435.                     }
  436.                     testLang = new MyLang (fileName,llk);
  437.                     if (!testLang.isCreate()) break;  //не створили об'єкт
  438.                     System.out.println ("Граматика прочитана успішно");
  439.                     result=true;
  440.                     for (int jj=0;  jj<menu.length; jj++) {
  441.                         if (menu [jj].substring(0, 1).equals(" ")) continue;
  442.                         menu [jj]=menu [jj].replace(menu [jj].charAt(0), '*');
  443.                     }
  444.                     break;
  445.                 case 2: //2. Лабораторна робота студента
  446.                     //   long s = System.currentTimeMillis();
  447.  
  448.                     boolean ck = false;
  449.                     int[] term = testLang.getTerminals();
  450.                     int[] nonterm = testLang.getNonTerminals();
  451.  
  452.                     Map<Integer , Integer> notrm = new HashMap();
  453.                     Map<Integer , Integer> trm = new HashMap();
  454.  
  455.                     for(int i = 0 ; i < term.length ; ++i){
  456.                         trm.put(term[i] , i);
  457.                     }
  458.                     for(int i = 0 ; i < nonterm.length ; ++i){
  459.                         notrm.put(nonterm[i] , i);
  460.                     }
  461.  
  462.                     LlkContext[] llkTrmContext = testLang.getLlkTrmContext();
  463.                     LlkContext[] res_cur = new LlkContext[nonterm.length];
  464.  
  465.                     for (int i = 0; i < nonterm.length; ++i) {
  466.                         res_cur[i] = new LlkContext();
  467.                     }
  468.  
  469.                     for(int u : testLang.getEpsilonNonterminals()){
  470.                         res_cur[notrm.get(u)].addWord(new int[0]);
  471.                     }
  472.  
  473.                     ck = true;
  474.  
  475.                     while(ck){
  476.                         ck = false;
  477.  
  478.                         for(Node node : testLang.getLanguarge()) {
  479.                             int[] rule = node.getRoole();
  480.                             int left = notrm.get(rule[0]);
  481.                             int last = 1;
  482.                             if(rule.length == 1)continue;
  483.  
  484.                             Queue<ArrayList<Integer>> q = new LinkedList<>();
  485.  
  486.                             ArrayList<Integer> temp = new ArrayList<>();
  487.                             temp.add(-1);
  488.  
  489.                             q.add(temp);
  490.  
  491.                             ArrayList<ArrayList<Integer>> done = new ArrayList<>();
  492.  
  493.                             for(; last < rule.length ; ++last){
  494.                                 int cur = rule[last] > 0 ? trm.get(rule[last]) : notrm.get(rule[last]);
  495.                                 LlkContext tmp = rule[last] > 0 ? llkTrmContext[cur] : res_cur[cur];
  496.                                 if(rule[last] < 0 && res_cur[cur].calcWords() == 0)break;
  497.                                 boolean cont = false;
  498.                                 while(!q.isEmpty()){
  499.                                     ArrayList<Integer> word = (ArrayList<Integer>)q.peek().clone();
  500.                                     if(word.get(0) == last){
  501.                                         cont = true;
  502.                                         break;
  503.                                     }
  504.                                     q.poll();
  505.                                     for(int i = 0 ; i < tmp.calcWords() ; ++i){
  506.                                         ArrayList<Integer> word1 = (ArrayList<Integer>)word.clone();
  507.                                         word1.set(0 , last);
  508.                                         for(int j = 0 ; j < tmp.getWord(i).length ; ++j){
  509.                                             word1.add(tmp.getWord(i)[j]);
  510.                                         }
  511.                                         if(word1.size() - 1 >= testLang.getLlkConst()){
  512.                                             done.add(word1);
  513.                                         }else{
  514.                                             q.add(word1);
  515.                                         }
  516.                                     }
  517.                                 }
  518.                                 if(cont)continue;
  519.                                 break;
  520.                             }
  521.  
  522.                             while(last == rule.length && !q.isEmpty()){
  523.                                 ArrayList<Integer> word = (ArrayList<Integer>)q.peek().clone();
  524.                                 q.poll();
  525.                                 done.add(word);
  526.                             }
  527.  
  528.                             for(int i = 0 ; i < done.size() ; ++i){
  529.                                 int word[] = new int[Math.min(done.get(i).size() - 1 , testLang.getLlkConst())];
  530.                                 for(int j = 0 ; j < word.length ; ++j){
  531.                                     word[j] = done.get(i).get(j + 1);
  532.                                 }
  533.                                 ck |= (res_cur[left].addWord(word));
  534.                             }
  535.                         }
  536.                     }
  537.  
  538.                     testLang.setFirstK(res_cur);
  539.                     testLang.printFirstkContext();
  540.  
  541.                     //   long f = System.currentTimeMillis() - s;
  542.                     //   System.out.print("Время работы: " + f);
  543.  
  544.                     break;
  545.                 case 3:  // Надрукувати граматику
  546.                     testLang.printGramma();
  547.                     break;
  548.                 case 4:  // надрукувати список терміналів та нетерміналів
  549.                     testLang.printTerminals();
  550.                     testLang.printNonterminals();
  551.                     result=true;
  552.                     break;
  553.                 case 5: // вивести непродуктивні правила
  554.                     result=testLang.createNonProdRools();
  555.                     break;
  556.                 case 6: // недосяжні нетермінали
  557.                     result=testLang.createNonDosNeterminals();
  558.                     break;
  559.                 case 7:  //Побудова списку епсілон-нетерміналів
  560.                     int [] epsilon=testLang.createEpsilonNonterminals ();
  561.                     testLang.setEpsilonNonterminals (epsilon);
  562.                     result=true;
  563.                     break;
  564.                 case 8: //Друк списку епсілон-нетерміналів
  565.                     testLang.printEpsilonNonterminals();
  566.                     break;
  567.                 case 9:    //Пошук ліворекурсивних нетерміналів"
  568.                     testLang.leftRecursNonnerminal();
  569.                     break;
  570.                 case 10:  //Пошук різних ліворекурсивних виводів мінімальної довжини"
  571.                     testLang.leftRecusionTrace();
  572.                     break;
  573.                 case 11:  //Пошук праворекурсивних нетерміналів"
  574.                     testLang.rightRecursNonnerminal();
  575.                     break;
  576.                 case 12:  //Пошук різних праворекурсивних виводів мінімальної довжини"
  577.                     testLang.rigthRecusionTrace();
  578.                     break;
  579.                 case 13:  //Побудувати множини FirstK
  580.                     //   s = System.currentTimeMillis();
  581.  
  582.                     LlkContext [] firstContext = testLang.firstK();
  583.                     testLang.setFirstK(firstContext);
  584.                     result=true;
  585.  
  586.                     //    f = System.currentTimeMillis() - s;
  587.                     //    System.out.print("Время работы: " + f);
  588.                     break;
  589.                 case 14:  //Друк множини FirstK
  590.                     testLang.printFirstkContext ( );
  591.                     break;
  592.                 case 15:  //Побудувати множини FollowK
  593.                     LlkContext [] followContext = testLang.followK();
  594.                     testLang.setFollowK(followContext);
  595.                     result=true;
  596.                     break;
  597.                 case 16:  //Друк множини FollowK
  598.                     testLang.printFollowkContext ( );
  599.                     break;
  600.                 case 17:  //Побудувати множини FirstK(w) + FollowK(A) для правила А->w
  601.                     testLang.firstFollowK ( );
  602.                     result=true;
  603.                     break;
  604.                 case 18:  //Друк множини FirstK(w) + FollowK(A) для правила А->w
  605.                     testLang.printFirstFollowK( );
  606.                     break;
  607.                 case 19:  //Друк множини FirstK(w) + FollowK(A) для вибраних правил А->w
  608.                     testLang.printFirstFollowForRoole();
  609.                     break;
  610.                 case 20:  //Перевірка сильної LL(k)-властивості",
  611.                     result=testLang. strongLlkCondition () ;
  612.                     break;
  613.                 case 21:  //Побудова таблиці LL(1)-синтаксичного аналізатора
  614.                     int [][] uprTable=testLang.createUprTable ();
  615.                     testLang.setUprTable(uprTable);
  616.                     break;
  617.                 case 22: // PASCAL
  618.                     String path;
  619.                     System.out.println("Введiть назву вхiдного файлу: ");
  620.                     try{
  621.                         textLen=System.in.read(readline);
  622.                         String codepath = new String (readline,0,textLen, "ISO-8859-1");
  623.                         LexPascal lex = new LexPascal(codepath);
  624.                         SQLparser sqlp = new SQLparser(codepath);
  625.                         ArrayList<Map<Tokens , String>> tokens = !sql ? lex.Tokenize() : sqlp.Tokenize();
  626.                         //    ArrayList<Map<Tokens , String>> tokens = lex.Tokenize();
  627.  
  628.                         if(debug)
  629.                             for(Map<Tokens , String> mp : tokens){
  630.                                 for(Tokens tk : mp.keySet()){
  631.                                     System.out.println(tk.toString() + " " + mp.get(tk));
  632.                                 }
  633.                             }
  634.                         //    if(sql)break;
  635.  
  636.                         boolean accepted = true;
  637.  
  638.                         Stack<Integer> st = new Stack<>();
  639.                         st.push(testLang.getAxioma());
  640.                         int last_lex = Integer.MAX_VALUE;
  641.                         int[][] table = testLang.getUprTable();
  642.  
  643.                         for(int kk = 0 ; kk < tokens.size() ; ++kk , kk = Math.max(kk , 0)){
  644.                             Map<Tokens , String> mp = tokens.get(kk);
  645.                             if(debug)
  646.                                 System.out.println(mp + " " + st.size() + " " + testLang.getLexemaText(st.peek()));
  647.                             if(debug)
  648.                                 Thread.sleep(250);
  649.                             boolean skip = false;
  650.                             for(Tokens tk : mp.keySet()){
  651.                                 if(tk == Tokens.Comment){
  652.                                     skip = true;
  653.                                 }
  654.                             }
  655.  
  656.                             if(skip) {
  657.                                 if(kk == tokens.size() - 1)
  658.                                     break;
  659.                                 continue;
  660.                             }
  661.  
  662.                             if(st.isEmpty()){
  663.  
  664.                                 System.out.println("Error, stack is empty! ");
  665.                                 accepted = false;
  666.                                 break;
  667.                             }
  668.  
  669.                             int top = st.peek();
  670.                             if(top == last_lex && sql){
  671.                                 for(Tokens tk : mp.keySet()){
  672.                                     System.out.println("Syntax error before '" + mp.get(tk) + "'! ");
  673.                                 }
  674.                                 accepted = false;
  675.                                 break;
  676.                             }else{
  677.                                 last_lex = top;
  678.                             }
  679.  
  680.                             if(top < 0){//top is non terminal
  681.                                 int cur = -1;
  682.                                 int nt[] = testLang.getNonTerminals();
  683.  
  684.                                 for(int i = 0 ; i < nt.length ; ++i){
  685.                                     if(top == nt[i]){
  686.                                         cur = i;
  687.                                         break;
  688.                                     }
  689.                                 }
  690.  
  691.  
  692.                                 int el = -1;
  693.                                 int tr[] = testLang.getTerminals();
  694.  
  695.                                 for(int i = 0 ; i < tr.length ; ++i){
  696.                                     String terminal = testLang.getLexemaText(tr[i]);
  697.                                     for(Tokens tk : mp.keySet()){
  698.                                         if(terminal.equals(mp.get(tk)) || terminal.equals(tk.toString())){
  699.                                             el = i;
  700.                                             break;
  701.                                         }
  702.                                     }
  703.                                     if(sql)
  704.                                         if(el >= 0)break;
  705.                                 }
  706.  
  707.                                 if(cur < 0 || el < 0){
  708.                                     System.out.println("Error, no such lexema found in the grammar!");
  709.                                 }
  710.  
  711.                                 int next = table[cur][el];
  712.  
  713.                                 LinkedList<Node> lang = testLang.getLanguarge();
  714.                                 int rule[] = lang.get(Math.max(next - 1 , 0)).getRoole();
  715.  
  716.                                 st.pop();
  717.  
  718.                                 for(int i = rule.length - 1; i >= 1 ; --i) {
  719.                                     st.push(rule[i]);
  720.                                 }
  721.  
  722.                                 --kk;
  723.                             }else{//top is terminal
  724.                                 String terminal = testLang.getLexemaText(top);
  725.  
  726.                                 boolean eq = false;
  727.  
  728.                                 for(Tokens tk : mp.keySet()){
  729.                                     if(debug)
  730.                                         System.out.println("Try to compare: " + terminal + " " + mp.get(tk) + "\nand " + terminal + " " + tk.toString());
  731.                                     if(terminal.equals(mp.get(tk)) || terminal.equals(tk.toString())){
  732.                                         eq = true;
  733.                                     }
  734.                                 }
  735.  
  736.                                 if(eq){
  737.                                     st.pop();
  738.                                     continue;
  739.                                 }else{
  740.                                     for(Tokens tk : mp.keySet()){
  741.                                         System.out.println("Syntax error before '" + mp.get(tk) + "'! ");
  742.                                     }
  743.                                     accepted = false;
  744.                                     break;
  745.                                 }
  746.  
  747.  
  748.                             }
  749.                         }
  750.  
  751.                         int[] eps = testLang.getEpsilonNonterminals();
  752.                         while(!st.isEmpty() && st.peek() < 0){
  753.                             boolean check = false;
  754.                             for(int e : eps){
  755.                                 if(e == st.peek()){
  756.                                     st.pop();
  757.                                     check = true;
  758.                                     break;
  759.                                 }
  760.                             }
  761.                             if(!check)
  762.                                 break;
  763.                         }
  764.  
  765.                         if(!st.isEmpty() && accepted){
  766.                             accepted = false;
  767.                             System.out.println("Error, analyzer have reached end of the code, but stack is not empty!");
  768.  
  769.                             if(debug)
  770.                                 while(!st.isEmpty()){
  771.                                     int el = st.pop();
  772.                                     System.out.println(testLang.getLexemaText(el));
  773.                                 }
  774.  
  775.                         }
  776.  
  777.                         if(accepted == true) {
  778.                             System.out.print("OK\n");
  779.                             //    System.out.println(st);
  780.                         }
  781.  
  782.  
  783.                     }catch (java.io.IOException e ){}
  784.                  //   catch (RuntimeException e){System.out.println("There is some lexical errors in the code.");}
  785.                     catch (java.lang.Exception e){e.printStackTrace();}
  786.  
  787.  
  788.  
  789.  
  790.  
  791.                     break;
  792.  
  793.                 case 23: // 23. Побудувати множини LocalK(A), A-нетермінал
  794.                     LinkedList <LlkContext> [] Localk=testLang.createLocalK();
  795.                     testLang.setLocalkContext(Localk);
  796.                     result=true;
  797.                     break;
  798.                 case 24: // 24. Вивести на термінал множини LocalK(A), A-нетермінал
  799.                     testLang.printLocalk();
  800.                     break;
  801.                 case 25: // 25. Перевірка LL(k)-властивості, k>1
  802.                     result= testLang.llkCondition();
  803.                     break;
  804.                 case 26: // rtrtrtr
  805.                     return;
  806.                 case 27:
  807.                     break;
  808.             }  // кінець switch
  809.             // блокуємо елемент обробки
  810.             if (result) // функція виконана успішно
  811.                 if (menu [codeAction-1].substring(0, 1).equals("*"))
  812.                     menu [codeAction-1]=menu [codeAction-1].replace('*', '+') ;
  813.         } while (true);  //глобальний цикл  обробки
  814.  
  815.     }  // кінець main
  816.  
  817.     static void tesrReadWrite(String fname)
  818.     {  String readline;
  819.         BufferedReader s;
  820.         BufferedWriter bw;
  821.         try {
  822.             s = new BufferedReader(new FileReader(fname));
  823.             bw = new BufferedWriter (new FileWriter("c:\\rez.txt"));
  824.             // s=new FileInputStream (fname);
  825.             //s=new FileInputStream ("C:\\Eclipse\\C1.txt");
  826.             //s=new FileInputStream ("C:\\test1.txt");
  827.             while ( s.ready() ) {
  828.                 readline= s.readLine();
  829.                 System.out.println(readline);
  830.                 //System.out.println("Read Line");
  831.                 //bw.write(readline, 0,readline.length() );
  832.                 //bw.write((int)'\r'); bw.flush();
  833.                 //System.out.println("Print Line");
  834.             }
  835.  
  836.             //bw.close();
  837.         }
  838.         catch(Exception ee)
  839.         {
  840.             System.out.print("File: " +fname + "not found\n");
  841.             //return;
  842.         }
  843.     }
  844. }
  845.  
  846.  
  847. class SQLparser{
  848.     private String path = "";
  849.     private static Map<Tokens , Pattern> regular = new HashMap<Tokens , Pattern>();
  850.     private static Map<Tokens , Integer> priority = new HashMap<Tokens , Integer>();
  851.  
  852.     public SQLparser(String _path){
  853.         path = _path.trim();
  854.         InitRegex();
  855.         InitPriority();
  856.     }
  857.  
  858.     static void InitRegex(){
  859.         regular.put(Tokens.IDN , Pattern.compile("^(_|[a-z])([a-z]|[0-9]|_)*"));
  860.         regular.put(Tokens.Keyword , Pattern.compile("^(values|insert|into|select|distinct|from|where|using|group|order|asc|desc|having|by|as|in)"));
  861.         regular.put(Tokens.FUNC_NAME , Pattern.compile("^(count|sum|avg|min|max)"));
  862.         regular.put(Tokens.DIGIT , Pattern.compile("^(0|[1-9]\\d*)"));
  863.         regular.put(Tokens.LITER_STR, Pattern.compile("^'(?:[^']+|(''))*'$"));
  864.         regular.put(Tokens.Comment, Pattern.compile("^(/\\*(.|[\\r\\n])*?\\*/)|(--(.*|[\\r\\n]))$"));
  865.         regular.put(Tokens.Punctuation, Pattern.compile("^(\\(|\\)|;|,|\\.|:|\\[|\\]|\\^|\\.\\.)"));
  866. //        regular.put(Tokens.Hex, Pattern.compile("^0[xX]((0|[1-9a-fA-F][\\da-fA-F]*))"));
  867.         regular.put(Tokens.Operator, Pattern.compile("^\\+|\\-|\\*|/|:=|<>|=|>|<|>=|<="));
  868.         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]))"));
  869. //        regular.put(Tokens.Directive, Pattern.compile("^mp:.*"));
  870.         regular.put(Tokens.TYPE_NAME , Pattern.compile("^(integer|real|char|boolean)"));
  871.     }
  872.  
  873.     private void InitPriority(){
  874.         priority.put(Tokens.Operator, 10);
  875.         priority.put(Tokens.Punctuation, 2);
  876.         priority.put(Tokens.Double, 3);
  877.         priority.put(Tokens.DIGIT, 4);
  878.         priority.put(Tokens.Hex, 4);
  879.         priority.put(Tokens.IDN, 5);
  880.         priority.put(Tokens.Keyword, 6);
  881.         priority.put(Tokens.LITER_STR, 7);
  882.         priority.put(Tokens.TYPE_NAME, 8);
  883.         priority.put(Tokens.Comment, 9);
  884.         priority.put(Tokens.FUNC_NAME , 7);
  885.     }
  886.  
  887.     private String Prepare(String text){
  888.         text = text.toLowerCase();
  889.         String code = "";
  890.         boolean ck = false;
  891.  
  892.         //  text = text.replace(";",";;");
  893.         text = text.replace("clrscr;","clrscr();");
  894.         text = text.replace("writeln;","writeln();");
  895.         text = text.replace("write;","write();");
  896.         text = text.replace("readln;","readln();");
  897.         text = text.replace("read;","read();");
  898.         text = text.replace("randomize;","randomize();");
  899.         text = text.replace("function","func");
  900.         text = text.replace("procedure","proc");
  901.         text = text.replace("true","1");
  902.         text = text.replace("false","0");
  903.  
  904.  
  905.         for(int i = 0 ; i < text.length() ; ++i){
  906.             char ch = text.charAt(i);
  907.             String small = "йцукенгшщзхъфывапролджэёячсмитьбю";
  908.             String big = "ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЁЯЧСМИТЬБЮ";
  909.             if(small.indexOf(ch) != -1 && !ck){
  910.                 code += 'a';
  911.                 ck = true;
  912.             }else if(big.indexOf(ch) != -1 && !ck){
  913.                 code += 'A';
  914.                 ck = true;
  915.             }else if(small.indexOf(ch) == -1 && big.indexOf(ch) == -1){
  916.                 code += ch;
  917.                 ck = false;
  918.             }
  919.         }
  920.         String temp = "";
  921.         boolean add = false;
  922.         int st = 0;
  923.         for(int i = 0 ; i < code.length() ; ++i){
  924.             char ch = code.charAt(i);
  925.             if(st == 0 && ch == '\''){
  926.                 add = false;
  927.                 temp += ch;
  928.                 st = 1;
  929.                 continue;
  930.             }
  931.             if(st == 1 && ch == '\''){
  932.                 st = 0;
  933.                 temp += ch;
  934.                 continue;
  935.             }
  936.             if(st == 1 && ch == '\\'){
  937.                 st = 2;
  938.                 continue;
  939.             }
  940.             if(st == 2){
  941.                 st = 1;
  942.                 continue;
  943.             }
  944.             if(st == 1) {
  945.                 if(add == false){
  946.                     temp += ch;
  947.                     add = true;
  948.                 }
  949.                 continue;
  950.             }
  951.             temp += ch;
  952.         }
  953.         return temp.toLowerCase();
  954.     }
  955.  
  956.     public ArrayList<Map<Tokens , String>> Tokenize() throws Exception{
  957.         File file = new File(path);
  958.         int tlast = -1;
  959.  
  960.         String text = "";
  961.         try {
  962.             FileInputStream fis = new FileInputStream(new File(path));
  963.             byte[] data = new byte[(int) file.length()];
  964.             fis.read(data);
  965.             fis.close();
  966.             text = new String(data, "UTF-8");
  967.         }catch(FileNotFoundException e){
  968.             System.out.print(path + " File not found");
  969.         }catch(IOException e) {
  970.             e.printStackTrace();
  971.         }
  972.  
  973.         ArrayList<Map<Tokens , String>> ans = new ArrayList<>();
  974.         String code = Prepare(text);
  975.         //    System.out.println(code);
  976.         while(code.length() > 0 && (code.charAt(0) == ' ' || code.charAt(0) == '\n' || code.charAt(0) == '\t'))code = code.substring(1);
  977.         while(code.length() > 0){
  978.             Tokens tokType = Tokens.Comment;
  979.             int len = -1;
  980.             for(Tokens tok : regular.keySet()){
  981.                 Pattern trg = regular.get(tok);
  982.  
  983.                 String tmp = code;
  984.                 for(int j = code.length() ; j > 0 ; --j){
  985.                     Matcher tmat = trg.matcher(tmp);
  986.                     if(tmat.matches()){
  987.                         if(j > len || (j == len && priority.get(tok) > priority.get(tokType))){
  988.                             len = j;
  989.                             tokType = tok;
  990.                             break;
  991.                         }
  992.                     }
  993.                     tmp = tmp.substring(0 , tmp.length() - 1);
  994.                 }
  995.  
  996.  
  997.                 Matcher tmat = trg.matcher(code);
  998.  
  999.                 MatchResult res1 = tmat.toMatchResult();
  1000.                 try{
  1001.                     System.out.println(res1.end());
  1002.                 }catch(java.lang.IllegalStateException e){}
  1003.                 if(tmat.matches()){
  1004.                     MatchResult res = tmat.toMatchResult();
  1005.                     if(res.start() == 0){
  1006.                         if(res.end() > len){
  1007.                             len = res.end();
  1008.                             tokType = tok;
  1009.                         }
  1010.                     }
  1011.                 }
  1012.             }
  1013.             if(len <= 0){
  1014.                 throw new Exception("Unknown lexeme " + code);
  1015.             }
  1016.  
  1017.             //              table_name,
  1018.             //              col_name,
  1019.             //              name,
  1020.             if(tokType == Tokens.Keyword){
  1021.                 String cur_lex = code.substring(0 , len);
  1022.                 if(cur_lex.equals("select") || cur_lex.equals("by") || cur_lex.equals("insert")){
  1023.                     tlast = 1;
  1024.                 }else if(cur_lex.equals("from")){
  1025.                     tlast = 2;
  1026.                 }else if(cur_lex.equals("where")){
  1027.                     tlast = 3;
  1028.                 }
  1029.             }
  1030.  
  1031.             if(tokType == Tokens.IDN){
  1032.                 int sz = ans.size();
  1033.                 if(sz == 0){
  1034.                     System.out.println(tokType + " " + code.substring(0 , len));
  1035.                     throw new RuntimeException();
  1036.                 }
  1037.                 Map<Tokens , String> last = ans.get(sz - 1);
  1038.  
  1039.                 for(Tokens tk : last.keySet()){
  1040.                     //     System.out.println("debug: " + last.get(tk));
  1041.                     if(last.get(tk).equals("as")){
  1042.                         tokType = Tokens.name;
  1043.                     }else if(last.get(tk).equals(".")){
  1044.                         if(sz - 2 < 0){
  1045.                             System.out.println(tokType + " " + code.substring(0 , len));
  1046.                             throw new RuntimeException();
  1047.                         }
  1048.  
  1049.                         Map<Tokens , String> prev = ans.get(sz - 2);
  1050.                         Map<Tokens , String> new_prev = new HashMap<>();
  1051.  
  1052.                         //   if(tlast == 1){//select
  1053.                         for(Tokens tk2 : prev.keySet()){
  1054.                             new_prev.put(Tokens.table_name , prev.get(tk2));
  1055.                         }
  1056.  
  1057.                         ans.set(sz - 2 , new_prev);
  1058.                         tokType = Tokens.col_name;
  1059.                         //   }else if(tlast == 2)//from
  1060.  
  1061.  
  1062.                     }else{
  1063.                         if(tlast == 1){//select
  1064.                             tokType = Tokens.col_name;
  1065.                         }else if(tlast == 2){//from
  1066.                             tokType = Tokens.table_name;
  1067.                         }else if(tlast == 3) {//where
  1068.                             tokType = Tokens.col_name;
  1069.                         }else{
  1070.                             {
  1071.                                 System.out.println(tokType + " " + code.substring(0 , len));
  1072.                                 throw new RuntimeException();
  1073.                             }
  1074.                         }
  1075.                     }
  1076.                 }
  1077.             }
  1078.  
  1079.  
  1080.             Map<Tokens , String> curans = new HashMap<>();
  1081.             curans.put(tokType , code.substring(0 , len));
  1082.             ans.add(curans);
  1083.             //      System.out.println(code.substring(0 , len) + " " + tokType.toString());
  1084.             code = code.substring(len);
  1085.             code = code.trim();
  1086.         }
  1087.         return ans;
  1088.     }
  1089. }
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!