API tools faq
paste
Advertisement
Guest User

Untitled

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