API tools faq
paste
osipyonok

Untitled

osipyonok
Mar 11th, 2017
124
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 21.16 KB | None | 0 0
raw download clone embed print report
  1. import java.lang.*;
  2. import java.util.*;
  3. import java.io.*;
  4. import java.nio.charset.Charset;
  5. import JavaTeacherLib.*;
  6.  
  7. public class SysProgrammingMainAlgorithm {
  8.  
  9.     static public LinkedList<Node> language = new LinkedList();
  10.     static public LinkedList<TableNode> lexemaTable = new LinkedList();
  11.    
  12.     static public int getLexemaCode(String lexema, int lexemaClass) {
  13.         for(TableNode tmp : lexemaTable) {
  14.             if(tmp.getLexemaText().equals(lexema))return tmp.getLexemaCode();
  15.         }
  16.         return 0;
  17.     }
  18.  
  19.     static public String getLexemaText(int code) {
  20.         for(TableNode tmp : lexemaTable) {
  21.             if(tmp.getLexemaCode() == code)return tmp.getLexemaText();
  22.         }
  23.         return null;
  24.     }
  25.    
  26.     public static void printlang(){
  27.         int count = 0;
  28.         for (Node tmp : language) {
  29.             int[] roole = tmp.getRoole();
  30.             System.out.print("" + ++count + " ");
  31.             for (int ii = 0; ii < roole.length; ++ii) {
  32.                 if (ii == 1) {
  33.                     System.out.print(" -> ");
  34.                 }
  35.                 System.out.print(getLexemaText(roole[ii]) + " ");
  36.                 if (roole.length != 1) continue;
  37.                 System.out.print(" -> ");
  38.             }
  39.             System.out.println("");
  40.         }
  41.     }
  42.    
  43.      public static void main(String[] args) {
  44.           byte [] readline=new byte [80];
  45.           boolean result;
  46.           String fileName;
  47.           MyLang testLang=null;
  48.           int codeAction, llk=1, textLen;
  49.           String [] menu= { "*1.  Прочитати граматику з файла  ",
  50.                             " 2.  Лабораторна робота. Клас будує студент",
  51.                             " 3.  Надрукувати граматику",
  52.                             "*4.  Побудувати списки терміналів та нетерміналів",
  53.                             "*5.  Пошук непродуктивних нетерміналів",
  54.                             "*6.  Пошук недосяжних нетерміналів",
  55.                             "*7.  Побудова списку епсілон-нетерміналів",
  56.                             " 8.  Друк списку епсілон-нетерміналів",
  57.                             " 9.  Пошук ліворекурсивних нетерміналів",
  58.                             " 10. Пошук різних ліворекурсивних виводів мінімальної довжини",
  59.                             " 11. Пошук праворекурсивних нетерміналів",
  60.                             " 12. Пошук різних праворекурсивних виводів мінімальної довжини",
  61.                             "*13. Побудувати множини FirstK(A), A-нетермінал",
  62.                             " 14. Вивести на термінал множини FirstK(A), A-нетермінал",
  63.                             "*15. Побудувати множини FollowK(A), A-нетермінал",
  64.                             " 16. Вивести на термінал множини FollowK(A), A-нетермінал",
  65.                             "*17. Побудувати множини FirstK(w) + FollowK(A) для правила А->w",
  66.                             " 18. Вивести на термінал FirstK(w) + FollowK(A) для всіх правил А->w",
  67.                             " 19. Вивести на термінал FirstK(w) + FollowK(A) для вибраних правил А->w",
  68.                             "*20. Перевірка сильної LL(1)-властивості",
  69.                             " 21. Побудова таблиці LL(1)-синтаксичного аналізатора",
  70.                             " 22. Синтаксичний аналізатор. Клас будує студент",
  71.                             "*23. Побудувати множини LocalK(A), A-нетермінал",
  72.                             " 24. Вивести на термінал множини LocalK(A), A-нетермінал",
  73.                             "*25. Перевірка LL(k)-властивості, k>1",
  74.                             " 26. Вихід з системи"
  75.                           };
  76.         do  {
  77.            codeAction=0;
  78.            String upr;
  79.           for (String ss: menu) System.out.println(ss); // вивести меню
  80.           System.out.println("Введіть код дії або end:");
  81.          do {  // цикл перебору даних
  82.            try {
  83.             textLen=System.in.read(readline);
  84.             upr = new String (readline,0,textLen, "ISO-8859-1");
  85.             if (upr.trim().equals("end") ) return;
  86.             codeAction=new Integer (upr.trim());
  87.               }
  88.            catch(Exception ee)
  89.                 { System.out.println ("Невірний код дії, повторіть: ");
  90.                  continue;
  91.                 }
  92.            if (codeAction >=1  &&  codeAction<=menu.length ) {
  93.                if (menu [codeAction-1].substring(0, 1).equals("+"))  {
  94.                 System.out.println("Елемент меню " +codeAction+" повторно виконати неможливо");
  95.                 continue ;
  96.                 }
  97.                int itmp;
  98.                for (itmp=0; itmp < codeAction-1; itmp++)
  99.                    if (menu[itmp].substring(0, 1).equals("*")) break;
  100.                if (itmp !=codeAction-1) {
  101.                    System.out.println ("Виконайте попередні елементи меню, що позначені * : ");
  102.                    continue ;
  103.                   }  
  104.                break;
  105.               }
  106.               else {
  107.                 System.out.println ("Невірний код дії, повторіть: ");
  108.                 continue ;
  109.                }
  110.          }  while (true);
  111.          // перевірка на виконання усіх попередніх дій
  112.          result=false;
  113.            switch (codeAction) {
  114.                 case 1: //1. Прочитати граматику з файла",
  115.                    
  116.                     System.out.print ("Введіть ім'я файлу граматики:");
  117.                     try{
  118.                         textLen=System.in.read(readline);
  119.                         fileName = new String (readline,0,textLen, "ISO-8859-1");
  120.                         fileName = fileName.trim();
  121.                     }
  122.                     catch(Exception ee)
  123.                     { System.out.println ("Системна помилка: "+ee.toString());
  124.                               return;
  125.                     }
  126.                    
  127.                     BufferedReader s;
  128.                     final int maxn = 256;
  129.                     final int nterm = 0x80000000;
  130.                     final int term = 0x10000000;
  131.                     char[] lex = new char[maxn];
  132.                     int[] rule = new int[maxn];
  133.                     try {
  134.                         s = new BufferedReader(new FileReader(fileName));
  135.                     }
  136.                     catch (FileNotFoundException ee) {
  137.                         System.out.print("Файл не найден");
  138.                         return;
  139.                     }
  140.                    
  141.                     Arrays.fill(lex , (char)0);
  142.                     Arrays.fill(rule ,  0);
  143.                    
  144.                     int act = 0; // 0 - хз , 1 - читаем нетерминал , 2 - читаем терминал , 3 - читаем экранированный символ
  145.                    
  146.                     String line = null;
  147.                     int cur_rule = 0;
  148.                     int len = 0;
  149.                     int read_pos = 0;
  150.                     int pos = 0;
  151.                    
  152.                     try{
  153.                         while(s.ready()){
  154.                             if (line == null || read_pos >= len) {
  155.                                 line = s.readLine();
  156.                                 if (line.length() > 0 && line.charAt(0) == 65279) {
  157.                                     line = line.substring(1);
  158.                                 }
  159.                                 len = line.length();
  160.                             }
  161.                             for(read_pos = 0 ; read_pos < len ; ++read_pos){
  162.                                 char cur = line.charAt(read_pos);
  163.                                 if(act == 0){
  164.                                     String ck = " \t\n\n\b";
  165.                                     if(ck.indexOf(cur) != -1)continue;
  166.                                     if(read_pos == 0 && cur_rule > 0 && (cur == '#' || cur == '!')){
  167.                                         Node node = new Node(rule , cur_rule);
  168.                                         language.add(node);
  169.                                         if(cur == '!'){
  170.                                             cur_rule = 1;
  171.                                             continue;
  172.                                         }else{
  173.                                             cur_rule = 0;
  174.                                         }
  175.                                     }
  176.                                     lex[0] = cur;
  177.                                     pos = 1;
  178.                                     if(cur == '#'){
  179.                                         act = 1;
  180.                                     }else if(cur == '\\'){
  181.                                         act = 3;
  182.                                         --pos;
  183.                                     }else{
  184.                                         act = 2;
  185.                                     }
  186.                                     continue;                        
  187.                                 }
  188.                                 if(act == 1){
  189.                                     lex[pos] = cur;
  190.                                     ++pos;
  191.                                     if(read_pos != 0 && cur != '#')continue;
  192.                                     String str = new String(lex , 0, pos);
  193.                                     TableNode tnode = new TableNode(str, nterm);
  194.                                     boolean find = false;
  195.                                     for(TableNode tn : lexemaTable){
  196.                                         if(tn.equals(tnode)){
  197.                                             find = true;
  198.                                             break;
  199.                                         }
  200.                                     }
  201.                                     if(!find){
  202.                                         lexemaTable.add(tnode);
  203.                                     }
  204.                                     int code = getLexemaCode(str, nterm);
  205.                                     rule[cur_rule] = code;
  206.                                     ++cur_rule;
  207.                                     pos = act = 0;
  208.                                     continue;                      
  209.                                 }
  210.                                 if(act == 2){
  211.                                     if(cur == '\\'){
  212.                                         act = 3;
  213.                                         --pos;
  214.                                         continue;
  215.                                     }
  216.                                     String ck = " #\t\r";
  217.                                     if(ck.indexOf(cur) != -1 || read_pos == 0){
  218.                                         String str = new String(lex , 0, pos);
  219.                                         TableNode tnode = new TableNode(str ,  term);
  220.                                         boolean find = false;
  221.                                         for(TableNode tn : lexemaTable){
  222.                                             if(tn.equals(tnode)){
  223.                                                 find = true;
  224.                                                 break;
  225.                                             }
  226.                                         }
  227.                                         if(!find){
  228.                                             lexemaTable.add(tnode);
  229.                                         }
  230.                                         int code = getLexemaCode(str , term);
  231.                                         rule[cur_rule] = code;
  232.                                         ++cur_rule;
  233.                                         pos = act = 0;
  234.                                         --read_pos;                    
  235.                                     }else{
  236.                                         lex[pos] = cur;
  237.                                         ++pos;
  238.                                     }
  239.                                     continue;
  240.                                 }
  241.                                 if(act == 3){
  242.                                     act = 2;
  243.                                     lex[pos] = cur;
  244.                                     ++pos;
  245.                                     continue;
  246.                                 }
  247.                                
  248.                             }
  249.                         }
  250.                         if(pos > 0){
  251.                             String str = new String(lex , 0, pos);
  252.                             TableNode tnode = new TableNode(str , act == 1 ? nterm : term);
  253.                             boolean find = false;
  254.                             for(TableNode tn : lexemaTable){
  255.                                 if(tn.equals(tnode)){
  256.                                     find = true;
  257.                                     break;
  258.                                 }
  259.                             }
  260.                             if(!find){
  261.                                 lexemaTable.add(tnode);
  262.                             }
  263.                             int code = getLexemaCode(str , act == 1 ? nterm : term);
  264.                             rule[cur_rule] = code;
  265.                             ++cur_rule;
  266.                         }
  267.                         if (cur_rule > 0) {
  268.                             Node node = new Node(rule, cur_rule);
  269.                             language.add(node);
  270.                         }
  271.                     }catch(Exception e){}
  272.                     printlang();
  273.                     break;
  274.                 case 2: //2. Лабораторна робота студента
  275.                     System.out.print ("Введіть ім'я файлу граматики:");
  276.                      try {
  277.                         textLen=System.in.read(readline);
  278.                         fileName = new String (readline,0,textLen, "ISO-8859-1");
  279.                         fileName = fileName.trim();
  280.                          }
  281.                        catch(Exception ee)
  282.                             { System.out.println ("Системна помилка: "+ee.toString());
  283.                               return;
  284.                             }
  285.                     System.out.print ("Введіть значення параметра k : ");
  286.                     try {
  287.                         textLen=System.in.read(readline);
  288.                         String llkText = new String (readline,0,textLen, "ISO-8859-1");
  289.                         llkText = llkText.trim();
  290.                         llk=Integer.parseInt(llkText);
  291.                          }
  292.                        catch(Exception ee)
  293.                             { System.out.println ("Системна помилка: "+ee.toString());
  294.                               return;
  295.                             }
  296.                     testLang = new MyLang (fileName,llk);
  297.                     if (!testLang.isCreate()) break;  //не створили об'єкт
  298.                     System.out.println ("Граматика прочитана успішно");
  299.                     result=true;
  300.                     for (int jj=0;  jj<menu.length; jj++) {
  301.                        if (menu [jj].substring(0, 1).equals(" ")) continue;
  302.                        menu [jj]=menu [jj].replace(menu [jj].charAt(0), '*') ;  
  303.                     }
  304.                     break;
  305.                 case 3:  // Надрукувати граматику
  306.                      testLang.printGramma();
  307.                      break;
  308.                 case 4:  // надрукувати список терміналів та нетерміналів
  309.                      testLang.printTerminals();
  310.                      testLang.printNonterminals();
  311.                      result=true;
  312.                     break;
  313.                 case 5: // вивести непродуктивні правила
  314.                      result=testLang.createNonProdRools();
  315.                      break;
  316.                 case 6: // недосяжні нетермінали
  317.                     result=testLang.createNonDosNeterminals();
  318.                      break;
  319.                  case 7:  //Побудова списку епсілон-нетерміналів
  320.                       int [] epsilon=testLang.createEpsilonNonterminals ();
  321.                       testLang.setEpsilonNonterminals (epsilon);
  322.                       result=true;
  323.                      break;
  324.                  case 8: //Друк списку епсілон-нетерміналів
  325.                       testLang.printEpsilonNonterminals();
  326.                      break;
  327.                  case 9:    //Пошук ліворекурсивних нетерміналів"
  328.                      testLang.leftRecursNonnerminal();
  329.                       break;
  330.                    case 10:  //Пошук різних ліворекурсивних виводів мінімальної довжини"
  331.                        testLang.leftRecusionTrace();
  332.                        break;
  333.                    case 11:  //Пошук праворекурсивних нетерміналів"
  334.                        testLang.rightRecursNonnerminal();
  335.                        break;
  336.                    case 12:  //Пошук різних праворекурсивних виводів мінімальної довжини"
  337.                       testLang.rigthRecusionTrace();
  338.                        break;
  339.                    case 13:  //Побудувати множини FirstK
  340.                        JavaTeacherLib.LlkContext[] firstContext = testLang.firstK();
  341.                        testLang.setFirstK(firstContext);
  342.                        result=true;
  343.                        break;
  344.                    case 14:  //Друк множини FirstK
  345.                        testLang.printFirstkContext ( );
  346.                        break;
  347.                    case 15:  //Побудувати множини FollowK
  348.                        JavaTeacherLib.LlkContext[] followContext = testLang.followK();
  349.                        testLang.setFollowK(followContext);
  350.                        result=true;
  351.                        break;
  352.                  case 16:  //Друк множини FollowK
  353.                        testLang.printFollowkContext ( );
  354.                        break;
  355.                  case 17:  //Побудувати множини FirstK(w) + FollowK(A) для правила А->w
  356.                        testLang.firstFollowK ( );
  357.                        result=true;
  358.                        break;
  359.                   case 18:  //Друк множини FirstK(w) + FollowK(A) для правила А->w
  360.                        testLang.printFirstFollowK( );
  361.                        break;
  362.                   case 19:  //Друк множини FirstK(w) + FollowK(A) для вибраних правил А->w
  363.                        testLang.printFirstFollowForRoole();
  364.                        break;
  365.                  case 20:  //Перевірка сильної LL(k)-властивості",
  366.                      result=testLang. strongLlkCondition () ;
  367.                         break;    
  368.                 case 21:  //Побудова таблиці LL(1)-синтаксичного аналізатора
  369.                        int [][] uprTable=testLang.createUprTable ();
  370.                         testLang.setUprTable(uprTable);
  371.                        break;
  372.                  case 22: // PASCAL
  373.                     break;
  374.                    
  375.                  case 23: // 23. Побудувати множини LocalK(A), A-нетермінал
  376.                     LinkedList<JavaTeacherLib.LlkContext>[] Localk=testLang.createLocalK();
  377.                     testLang.setLocalkContext(Localk);
  378.                     result=true;
  379.                     break;
  380.                  case 24: // 24. Вивести на термінал множини LocalK(A), A-нетермінал
  381.                        testLang.printLocalk();
  382.                        break;
  383.                  case 25: // 25. Перевірка LL(k)-властивості, k>1
  384.                     result= testLang.llkCondition();
  385.                      break;
  386.                  case 26: // rtrtrtr  
  387.                      return;
  388.                  case 27:
  389.                      break;
  390.                  }  // кінець switch
  391.            // блокуємо елемент обробки
  392.            if (result) // функція виконана успішно
  393.                if (menu [codeAction-1].substring(0, 1).equals("*"))
  394.                      menu [codeAction-1]=menu [codeAction-1].replace('*', '+') ;
  395.        } while (true);  //глобальний цикл  обробки
  396.                  
  397.      }  // кінець main
  398.      
  399.      static void tesrReadWrite(String fname)
  400.     {  String readline;
  401.         BufferedReader s;
  402.         BufferedWriter bw;
  403.         try {
  404.         s = new BufferedReader(new FileReader(fname));
  405.         bw = new BufferedWriter (new FileWriter("c:\\rez.txt"));
  406.       // s=new FileInputStream (fname);
  407.         //s=new FileInputStream ("C:\\Eclipse\\C1.txt");
  408.         //s=new FileInputStream ("C:\\test1.txt");
  409.         while ( s.ready() ) {
  410.             readline= s.readLine();
  411.             System.out.println(readline);
  412.             //System.out.println("Read Line");
  413.             //bw.write(readline, 0,readline.length() );
  414.             //bw.write((int)'\r'); bw.flush();
  415.             //System.out.println("Print Line");
  416.         }
  417.        
  418.         //bw.close();
  419.         }
  420.         catch(Exception ee)
  421.         {
  422.             System.out.print("File: " +fname + "not found\n");
  423.             //return;  
  424.         }
  425.     }
  426.     }
Add Comment
Please, Sign In to add comment
Public Pastes
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!