SHARE
TWEET

Untitled

a guest Dec 15th, 2019 84 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include<string>
  5. #include<vector>
  6. #include <iostream>
  7. #include <string.h>
  8. #include <stdlib.h>
  9. using namespace std;
  10. //#define BUFSIZE 80
  11. typedef struct tabl
  12. {
  13.     vector<string> v;
  14. } *ptabl;
  15.  
  16. tabl nTW, nTID, nTD, nTNUM;
  17. ptabl TW = &nTW, TID = &nTID, TD = &nTD, TNUM = &nTNUM;
  18. enum table
  19. {
  20.     tW, tID, tD, tNUM
  21. };
  22.  
  23. struct lex
  24. {
  25.     int t;
  26.     int ind;
  27.     bool operator ==(lex a)
  28.     {
  29.         return t == a.t && ind == a.ind;
  30.     }
  31. };
  32. //char buf[BUFSIZE];
  33. string  buf;
  34. char c;
  35. int d;
  36. void clear(void);
  37. void add(void);
  38. int look(ptabl t);
  39. int putl(ptabl t);
  40. int putnum();
  41. int j;
  42. void makelex(table t, int n);
  43. void print_tables();
  44. lex get_lex(void);
  45. //lex scan(void);
  46. void load_TD();
  47. void load_TW();
  48. FILE* fp;
  49. lex eof = { 2,1 }, er = { -1,-1 };
  50. lex cur_lex= { 0,0 };
  51. void O();//операторы
  52. void OP();//оператор
  53. bool OPERAND();//операнд
  54. void AR();//арифметическое выражение
  55. bool AR_op();//арифметическая операция
  56. void L();//логическoе выражение
  57. void SR();//выражение сравнения
  58. bool SR_op();//операция сравнения
  59. bool Un();//унарная лог операция
  60. bool Bin();//бинарная логическая операция
  61. bool is_id();
  62. bool is_num();
  63. bool equal(string s);
  64. string find_cur_lex();
  65. string searchInTable(ptabl t, int i);
  66. string current_lex="";
  67. int main()
  68. {
  69.  
  70.     load_TD();
  71.     load_TW();
  72.     fp = fopen("input.txt", "r");
  73.     c = fgetc(fp);
  74.     cur_lex = get_lex();
  75.     find_cur_lex();
  76.     if (!equal("do"))
  77.     {
  78.         printf("ERROR do expected");
  79.         return 0;
  80.     }
  81.     cur_lex = get_lex();
  82.     find_cur_lex();
  83.     O();
  84.     //cur_lex = scan();
  85.     //find_cur_lex();
  86.     if (!equal("loop"))
  87.     {
  88.         printf("ERROR loop expected");
  89.         return 0;
  90.     }
  91.     cur_lex = get_lex();
  92.     find_cur_lex();
  93.     if (!equal("while"))
  94.     {
  95.         printf("ERROR while expected");
  96.         return 0;
  97.     }
  98.     cur_lex = get_lex();
  99.     find_cur_lex();
  100.     L();
  101.     if (!(cur_lex == eof))
  102.     {
  103.         printf("ERROR EOF expected");
  104.     }
  105.     printf("OKKKK\n");
  106.     print_tables();
  107. }
  108. lex get_lex(void)
  109. {
  110.     enum state
  111.     {
  112.         H, ID, NUM, COM, ASS, DLM, ER, FIN
  113.     };
  114.     state TC;
  115.  
  116.     TC = H;
  117.  
  118.    
  119.     do
  120.     {
  121.         switch (TC)
  122.         {
  123.         case H:
  124.             if (isspace(c))
  125.                 c = fgetc(fp);
  126.             else if (isalpha(c))
  127.             {
  128.                 clear();
  129.                 add();
  130.                 c = fgetc(fp);
  131.                 TC = ID;
  132.             }
  133.             else if (isdigit(c))
  134.             {
  135.                 d = c - '0'; c = fgetc(fp);
  136.                 TC = NUM;
  137.             }
  138.             else if (c == '{')
  139.             {
  140.                 c = fgetc(fp);
  141.                 TC = COM;
  142.             }
  143.             else if (c == '}')
  144.             {
  145.                 TC = ER;
  146.             }
  147.             else if (c == ':')
  148.             {
  149.                 c = fgetc(fp);
  150.                 if (c == '=')
  151.                 {
  152.                     buf = ":=";
  153.                     //makelex(tD, look(TD));
  154.                     c = fgetc(fp);
  155.                     //find_cur_lex();
  156.                     return { tD, look(TD) };
  157.                 }
  158.                 else
  159.                 {
  160.                     TC = ER;
  161.                 }
  162.                
  163.             }
  164.             else if (c == '!')
  165.             {
  166.                 c = fgetc(fp);
  167.                 if (c == '=')
  168.                 {
  169.                     buf = "!=";
  170.                     //makelex(tD, look(TD));
  171.                     c = fgetc(fp);
  172.                 //  find_cur_lex();
  173.                     return { tD, look(TD) };
  174.                    
  175.                 }
  176.                 else
  177.                     TC = ER;
  178.             }
  179.             else if (c == EOF)
  180.             {
  181.                 clear();
  182.                 add();
  183.                 //makelex(tD, look(TD));
  184.                 TC = FIN;
  185.                 //find_cur_lex();
  186.                 return {tD, look(TD) };
  187.                
  188.             }
  189.             else
  190.                 TC = DLM;
  191.             break;
  192.         case ID:
  193.             if (isalpha(c) || isdigit(c))
  194.             {
  195.                 add();
  196.                 c = fgetc(fp);
  197.             }
  198.             else
  199.             {
  200.                 if (j = look(TW))
  201.                 {
  202.                     //makelex(tW, j);
  203.                     TC = H;
  204.                     //find_cur_lex();
  205.                     return { tW, j };
  206.                 }
  207.                 else {
  208.                     j = putl(TID);
  209.                     //makelex(tID, j);
  210.                     TC = H;
  211.                     //find_cur_lex();
  212.                     return { tID, j };
  213.                 }; TC = H;
  214.             };
  215.             break;
  216.         case COM:
  217.             if (c == '}')
  218.             {
  219.                 c = fgetc(fp);
  220.                 TC = H;
  221.             }
  222.             else if (c == EOF)
  223.                 TC = ER;
  224.             else
  225.                 c = fgetc(fp);
  226.  
  227.             break;
  228.         case NUM:
  229.             if (isdigit(c)) {
  230.                 d = d * 10 + (c - '0');
  231.                 c = fgetc(fp);
  232.             }
  233.             else
  234.             {
  235.                 if (isalpha(c))
  236.                 {
  237.                     TC = ER;
  238.  
  239.                     continue;
  240.                 }
  241.                 //makelex(tNUM, );
  242.                 TC = H;
  243.                 buf = to_string(d);
  244.                 if (j = look(TNUM))
  245.                 {
  246.                     //makelex(tW, j);
  247.                     //TC = H;
  248.                     //find_cur_lex();
  249.                     return { tNUM, j };
  250.                 }
  251.  
  252.                 return { tNUM, putnum() };
  253.            
  254.             }
  255.             break;
  256.         case DLM:
  257.             clear();
  258.             add();
  259.             c = fgetc(fp);
  260.             if (j = look(TD))
  261.             {
  262.                 //makelex(tD, j);
  263.                 TC = H;
  264.                 //find_cur_lex();
  265.                 return { tD, j };
  266.            
  267.             }
  268.             else
  269.             {
  270.                 TC = ER;
  271.             }
  272.        
  273.             break;
  274.             default:
  275.                 c = fgetc(fp);
  276.         }
  277.  
  278.     } while (TC != FIN && TC != ER);
  279.  
  280.     if (TC == ER)
  281.     {
  282.         printf("ERROR!!!\n\n");
  283.         return{-1,-1};
  284.     }
  285.     else
  286.     {
  287.         printf("O.K.!!!\n\n");
  288.         return { 2,1 };
  289.     }
  290.     //print_tables();
  291. }
  292. void clear(void)
  293. {
  294.     buf.clear();
  295. }
  296. void add(void)
  297. {
  298.     buf.push_back(c);
  299. }
  300. int look(ptabl t)
  301. {
  302.     for (int i = 0; i < t->v.size(); i++)
  303.         if (buf == t->v[i])
  304.             return j = (i+1);
  305.     return 0;
  306. }
  307. int putl(ptabl t)
  308. {
  309.     int ex = look(t);
  310.     if (ex)
  311.         return ex;
  312.  
  313.     t->v.push_back(buf);
  314.     return t->v.size();
  315. }
  316. int putnum()
  317. {
  318.     TNUM->v.push_back(to_string(d));
  319.     return TNUM->v.size();
  320. }
  321. void makelex(table t, int n)
  322. {
  323.     n--;
  324.     switch (t)
  325.     {
  326.     case tID:
  327.         printf("(TID, %2d)  : %s\n", n, TID->v[n].c_str());
  328.         break;
  329.     case tNUM:
  330.         printf("(TNUM, %2d) : %s\n", n, TNUM->v[n].c_str());
  331.         break;
  332.     case tD:
  333.         printf("(TD, %2d)   : %s\n", n, TD->v[n][0] == EOF ? "End Of File" : TD->v[n].c_str());
  334.         break;
  335.     case tW:
  336.         printf("(TW, %2d)   : %s\n", n, TW->v[n].c_str());
  337.         break;
  338.     }
  339. }
  340. void load_TD()
  341. {
  342.     string s;
  343.     s.push_back(EOF);
  344.     TD->v.push_back(s);
  345. //  TD->v.push_back(":");
  346.     TD->v.push_back(";");
  347.     TD->v.push_back(":=");
  348.     TD->v.push_back("!=");
  349.     TD->v.push_back("+");
  350.     TD->v.push_back("-");
  351.     TD->v.push_back("=");
  352.     TD->v.push_back("*");
  353.     TD->v.push_back("/");
  354.     TD->v.push_back("(");
  355.     TD->v.push_back(")");
  356.     TD->v.push_back(">");
  357.     TD->v.push_back("<");
  358.  
  359. }
  360. void load_TW()
  361. {
  362.     //TW->v.push_back("if");
  363.     TW->v.push_back("do");
  364.     TW->v.push_back("not");
  365.     TW->v.push_back("or");
  366.     TW->v.push_back("and");
  367.     TW->v.push_back("loop");
  368.     TW->v.push_back("while");
  369.     //TW->v.push_back("begin");
  370.     //TW->v.push_back("end");
  371.     //TW->v.push_back("end.");
  372. }
  373.  
  374. void print_tables()
  375. {
  376.     for (int i = 1; i <= TW->v.size(); i++)
  377.         makelex(tW, i);
  378.     printf("\n\n");
  379.     for (int i = 1; i <= TD->v.size(); i++)
  380.         makelex(tD, i);
  381.     printf("\n\n");
  382.     for (int i = 1; i <= TID->v.size(); i++)
  383.         makelex(tID, i);
  384.     printf("\n\n");
  385.     for (int i = 1; i <= TNUM->v.size(); i++)
  386.         makelex(tNUM, i);
  387.     printf("\n\n");
  388. }
  389. bool is_id()
  390. {
  391.     return (cur_lex.t == 1);
  392.  
  393. }
  394. bool is_num()
  395. {
  396.     return cur_lex.t == 3;
  397. }
  398.  
  399. bool equal(string s)
  400. {
  401.     if (cur_lex.t == tW)
  402.         return s == searchInTable(TW, cur_lex.ind);
  403.     if (cur_lex.t == tNUM)
  404.         return s == searchInTable(TNUM, cur_lex.ind);
  405.     if (cur_lex.t == tD)
  406.         return s == searchInTable(TD, cur_lex.ind);
  407.     if (cur_lex.t == tID)
  408.         return s == searchInTable(TID, cur_lex.ind);
  409. }
  410.  
  411. string searchInTable(ptabl t, int i)
  412. {
  413.     i--;
  414.     return t->v[i];
  415. }
  416. void O()
  417. {
  418.     OP();
  419.     if (equal(";"))
  420.     {
  421.         cur_lex = get_lex();
  422.         find_cur_lex();
  423.         O();
  424.     }
  425.     //cur_lex = scan();
  426.     //find_cur_lex();
  427. }
  428. void OP()
  429. {
  430.     if (!is_id())
  431.     {
  432.         printf("ERRROR ID expected\n");
  433.         exit(0);
  434.     }
  435.     cur_lex = get_lex();
  436.     find_cur_lex();
  437.     if(!equal(":="))
  438.     {
  439.         printf("ERRROR := expected\n");
  440.         exit(0);
  441.     }
  442.     cur_lex = get_lex();
  443.     find_cur_lex();
  444.     AR();
  445. }
  446. void AR()
  447. {
  448.     if (equal("("))
  449.     {
  450.         cur_lex = get_lex();
  451.         find_cur_lex();
  452.         AR();
  453.         if (!equal(")"))
  454.         {
  455.             printf("ERRROR ')' expected\n");
  456.             exit(0);
  457.         }
  458.         cur_lex = get_lex();
  459.         find_cur_lex();
  460.  
  461.         return;
  462.  
  463.     }
  464.  
  465.     if (!OPERAND())
  466.         return;
  467.     if (AR_op())
  468.     {
  469.         AR();
  470.     }
  471.  
  472.     //cur_lex = scan();
  473. }
  474. bool AR_op()
  475. {
  476.     if(!equal("*") && !equal("/") && !equal("+") && !equal("-"))
  477.     {
  478.         return false;
  479.         /*if (!equal(":="))
  480.         {
  481.             printf("ERRROR arithmetical operation expected expected\n");
  482.             exit(0);
  483.         }*/
  484.  
  485.     }
  486.     cur_lex = get_lex();
  487.     find_cur_lex();
  488.     return true;
  489. }
  490. bool OPERAND()
  491. {
  492.     if (!is_id() && !is_num())
  493.     {
  494.         //printf("ERRROR Operand expected\n");
  495.         //exit(0);
  496.         return false;
  497.     }
  498.  
  499.     cur_lex = get_lex();
  500.     find_cur_lex();
  501.     return true;
  502. }
  503. string find_cur_lex()
  504. {
  505.     if (cur_lex.t == tW)
  506.         return current_lex = searchInTable(TW, cur_lex.ind);
  507.     if (cur_lex.t == tNUM)
  508.         return current_lex = searchInTable(TNUM, cur_lex.ind);
  509.     if (cur_lex.t== tD)
  510.         return current_lex = searchInTable(TD, cur_lex.ind);
  511.     if (cur_lex.t == tID)
  512.         return current_lex = searchInTable(TID, cur_lex.ind);
  513.  
  514. }
  515.  
  516. void L()
  517. {
  518.     Un();
  519.     SR();
  520.     if (Bin())
  521.         L();
  522. }
  523.  
  524. void SR()
  525. {
  526.  
  527.     if (!OPERAND())
  528.     {
  529.         printf("ERRROR Operand  expected\n");
  530.         exit(0);
  531.     }
  532.  
  533.     if (!SR_op())
  534.         return;
  535.  
  536.     if (!OPERAND())
  537.     {
  538.         printf("ERRROR Operand  expected\n");
  539.         exit(0);
  540.     }
  541. }
  542.  
  543. bool Un()
  544. {
  545.     if (equal("not"))
  546.     {
  547.         cur_lex = get_lex();
  548.         find_cur_lex();
  549.         return true;
  550.     }
  551.  
  552.     return false;
  553. }
  554.  
  555. bool Bin()
  556. {
  557.     if (equal("and") || equal("or"))
  558.     {
  559.         cur_lex = get_lex();
  560.         find_cur_lex();
  561.         return true;
  562.     }
  563.  
  564.     return false;
  565. }
  566.  
  567. bool SR_op()
  568. {
  569.     if (equal(">") || equal("<") || equal("=") || equal("!="))
  570.     {
  571.         cur_lex = get_lex();
  572.         find_cur_lex();
  573.         return true;
  574.     }
  575.     return false;
  576. }
RAW Paste Data
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!
 
Top