SHARE
TWEET

Untitled

a guest Apr 21st, 2017 47 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <assert.h>
  2. #include <stdio.h>
  3. #include "lexer.h"
  4. #include "generator.h"
  5. #include "interpret.h"
  6. #include <stdlib.h>
  7. #include <math.h>
  8. #include <string.h>
  9.  
  10. KeySet H_Command = E PRINT | E READ | E WHILE | E ASSIGN;
  11. KeySet H_Term = E VALUE | E ID | E LPAR;
  12. KeySet H_Expr = E PLUS | E MINUS;
  13. KeySet H_Mul = E MUL | E DIV;
  14. KeySet H_Comp = E LT | E GT | E LE | E GE | E EQ | E NE;
  15. KeySet H_Decl = E ID | E COMMA;
  16. KeySet H_Init = E ID | E ASSIGN | E VALUE | E COMMA;
  17. KeySet H_Stat = E ID | E COMMA | E ASSIGN | E VALUE | E COMMA | E PRINT | E READ ;
  18. KeySet H_Seq =  E ID | E COMMA | E ASSIGN | E VALUE | E COMMA | E PRINT | E READ | E SEMICOLON;
  19.  
  20. int variables[LEX_IDS_MAX];
  21.  
  22. //pocitadlo chyb
  23. int errorCounter = 0;
  24.  
  25. int match(const Symbol expected, KeySet K);
  26. void read_variable(int id_idx);
  27. void error(const char *msg, KeySet K);
  28. int expr(KeySet K);
  29. int term(KeySet K);
  30. void read(KeySet K);
  31. void print(KeySet K);
  32. int power(KeySet K);
  33. void program(KeySet K);
  34. int comp(KeySet K);
  35. void funIf(KeySet K);
  36. void funWhile(KeySet K);
  37. char code_list[200]; // TODO temporary
  38.  
  39. // zmenenie hodnoty bze
  40. void set_value_in_address(short address, short value) {
  41.     code_list[address] = value;
  42. }
  43.  
  44. void set_variable(int id_idx, int value) {
  45.     variables[id_idx] = value;
  46.     //set_var_value(id_idx);
  47.     set_value(id_idx);
  48. }
  49.  
  50. int is_var_declared(int value){
  51.     int count = sizeof(variables)/sizeof(variables[0]);
  52.     int i;
  53.     for (i = 0; i < count; i++){
  54.         printf("%d\n", variables[i]);
  55.         if (variables[i] == value){
  56.             return 0;
  57.         }
  58.     }
  59.     return 1;
  60. }
  61.  
  62. int match(const Symbol expected, KeySet K) {
  63.     if (lex_symbol == expected) {
  64.     int attr = lex_attr;
  65.     next_symbol();
  66.     return attr;
  67.     } else {
  68.     char *msg = malloc(100);
  69.     snprintf(msg, 100, "Ocakavany symbol %s, namiesto toho sa vyskytol %s",
  70.         symbol_name(expected), symbol_name(lex_symbol));
  71.     error(msg, expected | K);
  72.     free(msg);
  73.     return 0;
  74.     }
  75. }
  76.  
  77. void error(const char *msg, KeySet K) {
  78.     errorCounter++;
  79.     fprintf(stderr, "CHYBA: %s\n", msg);
  80.  
  81.     while (!(E lex_symbol & K))
  82.     next_symbol();
  83. }
  84.  
  85. void check(const char *msg, KeySet K) {
  86.   if (!(E lex_symbol & K))
  87.     error(msg, K);
  88. }
  89.  
  90. void read_variable(int id_idx) {
  91.     int value;
  92.     printf("%s = ", lex_ids[id_idx]);
  93.     scanf("%d", &value);
  94.     variables[id_idx] = value;
  95.     write_ask_var(id_idx, lex_ids[id_idx]);
  96. }
  97.  
  98. //Print → "print" Comp ";"
  99. void print(KeySet K){
  100.     match(PRINT, K | E SEMICOLON);
  101.     int result = comp(H_Comp | K);
  102.     printf("Vysledok: %d\n", result);
  103.     write_result();
  104. }
  105.  
  106. void assign(KeySet K) {
  107.     match(ASSIGN, K);
  108.     int id = lex_attr;
  109.     next_symbol();
  110.     match(EQ, K);
  111.     int value = comp(K);
  112.     set_variable(id, value);
  113. }
  114.  
  115. //Read → "read" ID {"," ID} ";"
  116. void read(KeySet K) {
  117.     match(READ, K | E ID | E COMMA | E ID | E SEMICOLON);
  118.     match(ID, K | E COMMA | E ID | E SEMICOLON);
  119.     read_variable(lex_attr);
  120.     //next_symbol();
  121.     while((E lex_symbol) & (E COMMA)){
  122.         match(COMMA, K | E ID | E SEMICOLON);
  123.         read_variable(lex_attr);
  124.         printf("VARIABLES %d AND LEX_attr %d\n",variables[lex_attr],lex_attr);
  125.         next_symbol();
  126.         if(is_var_declared(variables[lex_attr]) == 1){
  127.             fprintf(stderr, "CHYBA: premenna %s uz je zadeklarovana.\n", lex_ids[lex_attr]);
  128.         }
  129.     }
  130.     match(SEMICOLON, K);
  131. }
  132. //Term → VALUE | ID | "(" Expr ")"
  133. int term(KeySet K) {
  134.     printf("TERM LEX Symbol: %s\n", symbol_name(lex_symbol));
  135.     int value;
  136.     switch (lex_symbol & (E ID | E LPAR | E VALUE)) {
  137.     case VALUE:
  138.         value = lex_attr;
  139.         write_number(lex_attr);
  140.         next_symbol();
  141.         break;
  142.     case ID:
  143.         value = variables[lex_attr];
  144.         write_var(lex_attr);
  145.         if(is_var_declared(lex_attr) == 1) {
  146.             fprintf(stderr, "CHYBA: premenná %s nebola zadeklarovaná.\n", lex_ids[lex_attr]);
  147.         }
  148.         next_symbol();
  149.         break;
  150.     case LPAR:
  151.         next_symbol();
  152.         value = expr(H_Term | H_Expr | K);
  153.         match(RPAR, K);
  154.         break;
  155.     default:
  156.         fprintf(stderr, "CHYBA: Chyba operand, namiesto toho sa vyskytol %s\n.",
  157.                 symbol_name(lex_symbol));
  158.         exit(1);
  159.     }
  160.     return value;
  161. }
  162.  
  163. void command(KeySet K) {
  164.     printf("COMMAND LEX Symbol: %s\n", symbol_name(lex_symbol));
  165.     switch (lex_symbol) {
  166.         case PRINT:
  167.             print(K);
  168.             break;
  169.         case ASSIGN:
  170.             assign(K);
  171.             break;
  172.         case WHILE:
  173.             funWhile(K);
  174.             break;
  175.         case IF:
  176.             funIf(K);
  177.             break;
  178.         default:
  179.             assert("Neocakavany operator v command()");
  180.     }
  181. }
  182. //Comp → Expr [( "<" | ">" [=] )| "!=" | "==" ) Expr]
  183. int comp(KeySet K) {
  184.     int value = -1;
  185.     int leftOp, rightOp;
  186.     Symbol operator;
  187.     leftOp = expr(H_Term | H_Expr | K);
  188.     printf("COMP LEX Symbol: %s\n", symbol_name(lex_symbol));
  189.     //match(LPAR, K | E GT | E NE | E GE | E LE | E EQ | E LT | E RPAR);
  190.     value = leftOp;
  191.     if (E lex_symbol & H_Comp) {
  192.         operator = lex_symbol;
  193.         next_symbol();
  194.         rightOp = expr(H_Term | H_Expr | K);
  195.         switch (operator) {
  196.             case GT:
  197.                 if(leftOp > rightOp){
  198.                     value = 1;
  199.                 }
  200.                 else{
  201.                     value = 0;
  202.                 }
  203.                 write_gt();
  204.                 break;
  205.             case NE:
  206.                 if(leftOp != rightOp){
  207.                     value = 1;
  208.                 }
  209.                 else{
  210.                     value = 0;
  211.                 }
  212.                 write_ne();
  213.                 break;
  214.             case GE:
  215.                 if(leftOp >= rightOp){
  216.                     value = 1;
  217.                 }
  218.                 else{
  219.                     value = 0;
  220.                 }
  221.                 write_ge();
  222.                 break;
  223.             case LE:
  224.                 if(leftOp <= rightOp){
  225.                     value = 1;
  226.                 }
  227.                 else{
  228.                     value = 0;
  229.                 }
  230.                 write_le();
  231.                 break;
  232.             case EQ:
  233.                 if(leftOp == rightOp){
  234.                     value = 1;
  235.                 }
  236.                 else{
  237.                     value = 0;
  238.                 }
  239.                 write_eq();
  240.                 break;
  241.             case LT:
  242.                 if(leftOp < rightOp){
  243.                     value = 1;
  244.                 }
  245.                 else{
  246.                     value = 0;
  247.                 }
  248.                 write_lt();
  249.                 break;
  250.             default:
  251.                 error("comp: neocakavany operand", K);
  252.         }
  253.     } else if(E lex_symbol & EOF) {
  254.         return value;
  255.     } else {
  256.         error("comp: ocakava sa < / > / <= / >= / == / != nasledovany s expr", H_Term | H_Expr | K);
  257.     }
  258.     return value;
  259. }
  260.  
  261. // If → "if" "(" Comp ")" "{" {Command ";"} "}" ["else "{" {Command ";"} "}"]
  262. void funIf(KeySet K) {
  263.     match(IF, K | E LPAR | H_Comp | E RPAR | E LBRC | H_Command | E RBRC | E ELSE);
  264.     match(LPAR, K | H_Comp | E RPAR | E LBRC | H_Command | E RBRC | E ELSE);
  265.     comp(K  | E RPAR | E LBRC | H_Command | E RBRC | E ELSE);
  266.     match(RPAR, K | E LBRC | H_Command | E RBRC | E ELSE);
  267.     match(LBRC, K | H_Command | E RBRC | E ELSE);
  268.     write_bze(0);
  269.     int bze_address = get_address();
  270.     while((E lex_symbol) & (E PRINT | E ASSIGN | E WHILE | E IF)) {
  271.         command(K | E SEMICOLON | E RBRC | E ELSE);
  272.         match(SEMICOLON, K);
  273.     }
  274.     match(RBRC, K | E RBRC | E ELSE);
  275.     write_jump(0);
  276.     int bze_value = get_address();
  277.     set_value_in_address(bze_address-1, bze_value);
  278.  
  279.     if ((E lex_symbol) & (E ELSE)) {
  280.         next_symbol();
  281.         match(LBRC, K | H_Command | E RBRC);
  282.         while((E lex_symbol) & (E PRINT | E ASSIGN | E WHILE | E IF)) {
  283.             command(K | E SEMICOLON | E RBRC);
  284.             match(SEMICOLON, K);
  285.         }
  286.         match(RBRC, K);
  287.     }
  288.     int jump_value = get_address();
  289.     set_value_in_address(bze_value-1, jump_value);
  290. }
  291.  
  292. // While → "while" "(" Comp ")" "{" {Command ";"} "}"
  293. void funWhile(KeySet K) {
  294.     int expr_address = get_address();
  295.     match(LPAR, K | H_Comp | E RPAR | E LBRC | H_Command | E RBRC);
  296.     comp(K | E RPAR | E LBRC | H_Command | E RBRC);
  297.     match(RPAR, K | E LBRC | H_Command | E RBRC);
  298.     match(LBRC, K | H_Command | E RBRC);
  299.     write_bze(0);
  300.     int bze_address = get_address();
  301.     while((E lex_symbol) & (E PRINT | E ASSIGN | E WHILE | E IF)) {
  302.         command(K | E SEMICOLON | E RBRC);
  303.         match(SEMICOLON, K);
  304.     }
  305.     match(RBRC, K);
  306.     write_jump(expr_address);
  307.     int bze_value = get_address();
  308.     set_value_in_address(bze_address-1, bze_value);
  309. }
  310.  
  311. //Mul → Power {( "*" | "/" ) Power}
  312. int mul(KeySet K) {
  313.     int leftOp, rightOp;
  314.     Symbol operator;
  315.     leftOp = power(H_Mul | E POWER | K);
  316.     //check("mul/div: ocakava sa operand *, /, ^", H_Mul | E POWER | H_Term | K);
  317.     while (E lex_symbol & (H_Mul | E POWER)) {
  318.         operator = lex_symbol;
  319.         next_symbol();
  320.         rightOp = power(H_Mul | E POWER | K);
  321.         printf("MUL LEX Symbol: %s\n", symbol_name(lex_symbol));
  322.         switch (operator) {
  323.             case DIV:
  324.                 leftOp = leftOp / rightOp;
  325.                 write_div();
  326.             break;
  327.             case MUL:
  328.                 leftOp = leftOp * rightOp;
  329.                 write_mul();
  330.             break;
  331.             default:
  332.                 error("div/mul: neocakavany operand", K);
  333.         }
  334.         //check("div/mul: ocakava sa operand *, /, ^", H_Mul | E POWER | H_Term | K);
  335.     }
  336.     return leftOp;
  337. }
  338. //Expr → Mul {( "+" | "-" ) Mul}
  339. int expr(KeySet K) {
  340.     int leftOp, rightOp;
  341.     Symbol operator;
  342.     leftOp = mul(K);
  343.     //check("expr: ocakava sa jeden z operandov +, -, *, /, ^", H_Expr | H_Mul | K);
  344.     printf("EXPR LEX Symbol: %s\n", symbol_name(lex_symbol));
  345.     while (E lex_symbol & (H_Expr | H_Mul)) {
  346.         operator = lex_symbol;
  347.         next_symbol();
  348.         rightOp = mul(K);
  349.         printf("EXPR LEX Symbol: %s\n", symbol_name(lex_symbol));
  350.         switch (operator) {
  351.         case PLUS:
  352.             printf("CASE PLUS\n");
  353.             write_add();
  354.             leftOp = leftOp + rightOp;
  355.             break;
  356.         case MINUS:
  357.             write_sub();
  358.             leftOp = leftOp - rightOp;
  359.             break;
  360.         default:
  361.             assert("Neocakavany operator v expr()");
  362.         }
  363.             //check("expr: ocakava sa +, -, *, /, ^", H_Expr | H_Mul | K);
  364.     }
  365.  
  366.     return leftOp;
  367. }
  368.  
  369. //Power → Term {( "^" ) Power}
  370. int power(KeySet K) {
  371.     printf("POWER LEX Symbol: %d\n", lex_symbol);
  372.     int leftOp, rightOp;
  373.     Symbol operator;
  374.     leftOp = term(E POWER | H_Term | K);
  375.     //check("pow: ocakava sa operand ^", E POWER | H_Term | K);
  376.     if (E lex_symbol & E POWER){
  377.         operator = lex_symbol;
  378.         next_symbol();
  379.         rightOp = power(E POWER | H_Term | K);
  380.         switch (operator) {
  381.             case POWER:
  382.                 leftOp = pow(leftOp,rightOp);
  383.                 break;
  384.             default:
  385.             error("pow: neocakavany operand", K);
  386.         }
  387.     }
  388.     return (int)leftOp;
  389. }
  390.  
  391. void program(KeySet K) {
  392.     if (lex_symbol == READ){
  393.         read(K);
  394.     }
  395.     while(E lex_symbol & (H_Stat | E SEMICOLON)) {
  396.         command(K);
  397.         match(SEMICOLON, K | E ID);
  398.         //match(ID, K);
  399.     }
  400.     printf("Pocet chyb: %d\n", errorCounter);
  401.     match(SEOF, K);
  402. }
  403.  
  404.  
  405. /*
  406.  * Gramatika:
  407. Program → [Read] { Command }
  408. Read → "read" ID {"," ID} ";"
  409. Command → Print | While | If| Init
  410. Print → "print" Comp ";"
  411. While → "while" "(" Comp ")" "{" Command ";""}""
  412. If → "if" "(" Comp ")" "{" Command ";""}" ["else "{" Command ";""}"]
  413. Init → "decl" ID ":=" VALUE {"," Init} ";"
  414. Comp → Expr [( "<" | ">" [=] )| "!=" | "==" ) Expr]
  415. Expr → Mul {( "+" | "-" ) Mul}
  416. Mul → Power {( "*" | "/" ) Power}
  417. Power → Term {( "^" ) Power}
  418. Term → VALUE | ID | "(" Expr ")"
  419.  */
  420. /*
  421. -----------------------------------------------------------------------------
  422. |   alternatíva
  423. {}  opakovanie 0 alebo viac krát
  424. []  voliteľnosť
  425. -----------------------------------------------------------------------------
  426. A → ...   Definícia A() { ... }
  427. Neterminal A    Volánie A()
  428. Terminal a  if (symbol == a) next_symbol();
  429. { X }   while (symbol == first(X)) { ... }
  430. [ X ]   if (symbol == first(X)) { ... }
  431. X | Y | Z   switch (symbol) { case first(X): ... }
  432.  
  433. // If → "if" "(" Comp ")" "{" {Command ";"} "}" ["else "{" {Command ";"} "}"]
  434.  
  435.  
  436. -------------------------------------------------------------------------------
  437. read a; print a;
  438.  
  439. read a; print a; assign a = a + 5; print a;
  440.  
  441. read a,b,c; print a * (b + c);
  442.  
  443. read a,b,c; print a + b / c;
  444.  
  445. read a; while(a < 5){print a; assign a := a + 1; if(a == 4){print a*2;};};
  446.  
  447. read a; if(a >= 5){print 5;}else{print 0;};
  448. */
RAW Paste Data
Top