API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 21st, 2017
63
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.41 KB | None | 0 0
raw download clone embed print report
  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. */
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!