API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 16th, 2017
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.80 KB | None | 0 0
raw download clone embed print report
  1. %option noyywrap c++ yylineno
  2.  
  3. %{
  4. #include <iostream>
  5. #include <cstdlib>
  6. #include "Parserbase.h"
  7. %}
  8.  
  9. SZAMJEGY [0-9]
  10. WS [ \t\n]
  11. BETU [a-zA-Z]
  12.  
  13. %%
  14.  
  15. #[^#]*# // nem kell semmit csinalni
  16.  
  17. {SZAMJEGY}+ return Parser::SZAMKONSTANS;
  18.  
  19. PROGRAM return Parser::PROGRAM;
  20. VALTOZOK: return Parser::VALTOZOK;
  21. UTASITASOK: return Parser::UTASITASOK;
  22. PROGRAM_VEGE return Parser::PROGRAM_VEGE;
  23. HA return Parser::HA;
  24. AKKOR return Parser::AKKOR;
  25. KULONBEN return Parser::KULONBEN;
  26. HA_VEGE return Parser::HA_VEGE;
  27. CIKLUS return Parser::CIKLUS;
  28. AMIG return Parser::AMIG;
  29. CIKLUS_VEGE return Parser::CIKLUS_VEGE;
  30. BE: return Parser::BE;
  31. KI: return Parser::KI;
  32. EGESZ return Parser::EGESZ;
  33. LOGIKAI return Parser::LOGIKAI;
  34. IGAZ return Parser::IGAZ;
  35. HAMIS return Parser::HAMIS;
  36. SKIP return Parser::SKIP;
  37.  
  38. ":=" return Parser::ERTEKADAS;
  39. "=" return Parser::EGYENLO;
  40. "<" return Parser::KISEBB;
  41. ">" return Parser::NAGYOBB;
  42. "+" return Parser::PLUSZ;
  43. "-" return Parser::MINUSZ;
  44. "*" return Parser::SZORZAS;
  45. "/" return Parser::OSZTAS;
  46. "%" return Parser::MARADEK;
  47. ES return Parser::ES;
  48. VAGY return Parser::VAGY;
  49. NEM return Parser::NEM;
  50. "(" return Parser::BALZAROJEL;
  51. ")" return Parser::JOBBZAROJEL;
  52.  
  53. {BETU}({BETU}|{SZAMJEGY})* return Parser::AZONOSITO;
  54.  
  55. {WS}+ // feher szokozok: semmi teendo
  56.  
  57. . {
  58. std::cerr << "lexikalis hiba" << std::endl;
  59. exit(1);
  60. }
  61.  
  62. %%
  63. ####
  64. %baseclass-preinclude "semantics.h"
  65.  
  66. %lsp-needed
  67.  
  68. %token <szoveg> SZAMKONSTANS
  69. %token PROGRAM
  70. %token VALTOZOK
  71. %token UTASITASOK
  72. %token PROGRAM_VEGE
  73. %token HA
  74. %token AKKOR
  75. %token KULONBEN
  76. %token HA_VEGE
  77. %token CIKLUS
  78. %token AMIG
  79. %token CIKLUS_VEGE
  80. %token BE
  81. %token KI
  82. %token EGESZ
  83. %token LOGIKAI
  84. %token ERTEKADAS
  85. %token BALZAROJEL
  86. %token JOBBZAROJEL
  87. %token <szoveg> AZONOSITO
  88. %token IGAZ
  89. %token HAMIS
  90. %token SKIP
  91.  
  92. %left VAGY
  93. %left ES
  94. %left NEM
  95. %left EGYENLO
  96. %left KISEBB NAGYOBB
  97. %left PLUSZ MINUSZ
  98. %left SZORZAS OSZTAS MARADEK
  99.  
  100. %type <kif> kifejezes
  101. %type <utasitas> ertekadas
  102. %type <utasitas> be
  103. %type <utasitas> ki
  104. %type <utasitas> elagazas
  105. %type <utasitas> ciklus
  106. %type <utasitas> utasitas
  107. %type <utasitas> utasitasok
  108. %type <utasitas> utasitaslista
  109. %type <utasitas> deklaracio
  110. %type <utasitas> deklaraciok
  111. %type <utasitas> valtozolista
  112. %type <utasitas> kezdes
  113. %type <utasitas> befejezes
  114.  
  115. %union
  116. {
  117. std::string *szoveg;
  118. kifejezes_leiro *kif;
  119. utasitas_leiro *utasitas;
  120. }
  121.  
  122. %%
  123.  
  124. start:
  125. kezdes deklaraciok utasitasok befejezes
  126. {
  127. std::cout << "extern be_egesz" << std::endl
  128. << "extern ki_egesz" << std::endl
  129. << "extern be_logikai" << std::endl
  130. << "extern ki_logikai" << std::endl
  131. << "global main" << std::endl << std::endl
  132. << "section .bss" << std::endl
  133. << $3->code << std::endl
  134. << "section .text" << std::endl
  135. << "main:" << std::endl
  136. << $4->code
  137. << "ret" << std::endl;
  138. delete $1;
  139. delete $2;
  140. delete $3;
  141. delete $4;
  142. }
  143. ;
  144.  
  145. kezdes:
  146. PROGRAM AZONOSITO
  147. {
  148. $$ = new utasitas_leiro( d_loc__.first_line );
  149. }
  150. ;
  151.  
  152. befejezes:
  153. PROGRAM_VEGE
  154. {
  155. $$ = new utasitas_leiro( d_loc__.first_line );
  156. }
  157. ;
  158.  
  159. deklaraciok:
  160. // ures
  161. {
  162. $$ = new utasitas_leiro( d_loc__.first_line );
  163. }
  164. |
  165. VALTOZOK valtozolista
  166. {
  167. $$ = new utasitas_leiro( d_loc__.first_line );
  168. delete $2;
  169. }
  170. ;
  171.  
  172. valtozolista:
  173. deklaracio
  174. |
  175. deklaracio valtozolista
  176. {
  177. $$ = new utasitas_leiro( $1->sor, $1->code + $2->code );
  178. delete $1;
  179. delete $2;
  180. }
  181. ;
  182.  
  183. deklaracio:
  184. EGESZ AZONOSITO
  185. {
  186. if( szimb_tabla.count(*$2) > 0 )
  187. {
  188. std::cerr << d_loc__.first_line << ".: A(z) '" << *$2 << "' valtozo mar definialva volt a "
  189. << szimb_tabla[*$2].def_sora << ". sorban." << std::endl;
  190. exit(1);
  191. }
  192. else
  193. {
  194. szimb_tabla[*$2] = valtozo_leiro(d_loc__.first_line,Egesz, counter++);
  195. $$ = new utasitas_leiro( d_loc__.first_line, szimb_tabla[*$2].cimke + "resd 4\n" );
  196. }
  197. delete $2;
  198. }
  199. |
  200. LOGIKAI AZONOSITO
  201. {
  202. if( szimb_tabla.count(*$2) > 0 )
  203. {
  204. std::cerr << d_loc__.first_line << ": A(z) '" << *$2 << "' valtozo mar definialva volt a "
  205. << szimb_tabla[*$2].def_sora << ". sorban." << std::endl;
  206. exit(1);
  207. }
  208. else
  209. {
  210. szimb_tabla[*$2] = valtozo_leiro(d_loc__.first_line,Logikai, counter++);
  211. $$ = new utasitas_leiro( d_loc__.first_line, szimb_tabla[*$2].cimke + "resb 1\n");
  212. }
  213. delete $2;
  214. }
  215. ;
  216.  
  217. utasitasok:
  218. UTASITASOK utasitas utasitaslista
  219. {
  220. $$ = new utasitas_leiro( d_loc__.first_line );
  221. delete $2;
  222. delete $3;
  223. }
  224. ;
  225.  
  226. utasitaslista:
  227. // epsilon
  228. {
  229. $$ = new utasitas_leiro( d_loc__.first_line );
  230. }
  231. |
  232. utasitas utasitaslista
  233. {
  234. $$ = new utasitas_leiro( $1->sor );
  235. delete $1;
  236. delete $2;
  237. }
  238. ;
  239.  
  240. utasitas:
  241. SKIP
  242. {
  243. $$ = new utasitas_leiro( d_loc__.first_line );
  244. }
  245. |
  246. ertekadas
  247. |
  248. be
  249. |
  250. ki
  251. |
  252. elagazas
  253. |
  254. ciklus
  255. ;
  256.  
  257. ertekadas:
  258. AZONOSITO ERTEKADAS kifejezes
  259. {
  260. if( szimb_tabla.count( *$1 ) == 0 )
  261. {
  262. std::cerr << d_loc__.first_line << ": A(z) '" << *$1 << "' valtozo nincs deklaralva." << std::endl;
  263. exit(1);
  264. }
  265. else if( szimb_tabla[*$1].vtip != $3->ktip )
  266. {
  267. std::cerr << d_loc__.first_line << ": Az ertekadas jobb- es baloldalan kulonbozo tipusu kifejezesek allnak." << std::endl;
  268. exit(1);
  269. }
  270. else
  271. {
  272. std::string reg;
  273. if($3->ktip == Egesz)
  274. reg = "eax";
  275. else
  276. reg = "al";
  277. $$ = new utasitas_leiro( d_loc__.first_line,$3->code
  278. + "mov [" + szimb_tabla[*$1].cimke + "]," + reg + "\n");
  279. }
  280. delete $3;
  281. }
  282. ;
  283.  
  284. be:
  285. BE AZONOSITO
  286. {
  287. if( szimb_tabla.count( *$2 ) == 0 )
  288. {
  289. std::cerr << d_loc__.first_line << ": A(z) '" << *$2 << "' valtozo nincs deklaralva." << std::endl;
  290. exit(1);
  291. }
  292. else
  293. {
  294. std::string metodus, reg;
  295. if(szimb_tabla[*$2].vtip == Egesz)
  296. {
  297. metodus = "be_egesz";
  298. reg = "eax";
  299. }
  300. else
  301. {
  302. metodus = "be_logikai";
  303. reg = "al";
  304. }
  305. $$ = new utasitas_leiro( d_loc__.first_line, "call " + metodus + "\n"
  306. + "mov [" + szimb_tabla[*$2].cimke + "]," + reg + "\n");
  307. }
  308. delete $2;
  309. }
  310. ;
  311.  
  312. ki:
  313. KI kifejezes
  314. {
  315. std::string metodus, reg;
  316. if($2->ktip == Egesz)
  317. {
  318. metodus = "be_egesz";
  319. reg = "eax";
  320. }
  321. else
  322. {
  323. metodus = "be_logikai";
  324. reg = "al";
  325. }
  326. $$ = new utasitas_leiro( d_loc__.first_line,$2->code + "push\n" + reg + "\n" + "call\n" + metodus + "\n" + "add esp,4\n");
  327. delete $2;
  328. }
  329. ;
  330.  
  331. elagazas:
  332. HA kifejezes AKKOR utasitaslista HA_VEGE
  333. {
  334. if( $2->ktip != Logikai )
  335. {
  336. std::cerr << d_loc__.first_line << ": Nem logikai tipusu az elagazas feltetele." << std::endl;
  337. exit(1);
  338. }
  339. else
  340. {
  341. std::stringstream out1;
  342. out1 << "Cimke" << Parser::counter++;
  343. std::string akkor = out1.str();
  344. std::stringstream out2;
  345. out2 << "Cimke" << Parser::counter++;
  346. std::string vege = out2.str();
  347. $$ = new utasitas_leiro( $2->sor
  348. , $2->code
  349. + "cmp al,1\n"
  350. + "je " + akkor + "\n"
  351. + "jmp " + vege + "\n"
  352. + akkor + ":\n"
  353. + $4->code
  354. + vege + ":\n");
  355. }
  356. delete $2;
  357. delete $4;
  358. }
  359. |
  360. HA kifejezes AKKOR utasitaslista KULONBEN utasitaslista HA_VEGE
  361. {
  362. if( $2->ktip != Logikai )
  363. {
  364. std::cerr << d_loc__.first_line << ": Nem logikai tipusu az elagazas feltetele." << std::endl;
  365. exit(1);
  366. }
  367. else
  368. {
  369. std::stringstream out1;
  370. out1 << "Cimke" << Parser::counter++;
  371. std::string akkor = out1.str();
  372. std::stringstream out2;
  373. out2 << "Cimke" << Parser::counter++;
  374. std::string vege = out2.str();
  375. std::stringstream out3;
  376. out3 << "Cimke" << Parser::counter++;
  377. std::string kulonben = out3.str();
  378. $$ = new utasitas_leiro( $2->sor
  379. , $2->code
  380. + "cmp al,1\n"
  381. + "je " + akkor + "\n"
  382. + "jmp" + kulonben + "\n"
  383. + akkor + ":\n"
  384. + $4->code
  385. + "jmp " + vege + "\n"
  386. + kulonben + ":\n"
  387. + $6->code
  388. + vege + ":\n");
  389. }
  390. delete $2;
  391. delete $4;
  392. delete $6;
  393. }
  394. ;
  395.  
  396. ciklus:
  397. CIKLUS AMIG kifejezes utasitaslista CIKLUS_VEGE
  398. {
  399. if( $3->ktip != Logikai )
  400. {
  401. std::cerr << d_loc__.first_line << ": Nem logikai tipusu a ciklus feltetele." << std::endl;
  402. exit(1);
  403. }
  404. else
  405. {
  406. std::stringstream out1;
  407. out1 << "Cimke" << Parser::counter++;
  408. std::string eleje = out1.str();
  409. std::stringstream out2;
  410. out2 << "Cimke" << Parser::counter++;
  411. std::string kozepe = out2.str();
  412. std::stringstream out3;
  413. out3 << "Cimke" << Parser::counter++;
  414. std::string vege = out3.str();
  415. $$ = new utasitas_leiro(
  416. $3->sor
  417. , eleje + ":\n"
  418. + $3->code
  419. + "cmp al,1\n"
  420. + "je " + kozepe + "\n"
  421. + "jmp " + vege + "\n"
  422. + kozepe + ":\n"
  423. + $4->code
  424. + "jmp " + eleje + "\n"
  425. + vege + ":\n"
  426. );
  427. }
  428. delete $3;
  429. delete $4;
  430. }
  431. ;
  432.  
  433. kifejezes:
  434. SZAMKONSTANS
  435. {
  436. $$ = new kifejezes_leiro( d_loc__.first_line, Egesz , "mov eax" + *$1 + "\n");
  437. delete $1;
  438. }
  439. |
  440. IGAZ
  441. {
  442. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai ,"mov al 1\n");
  443. }
  444. |
  445. HAMIS
  446. {
  447. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, "mov al 0\n");
  448. }
  449. |
  450. AZONOSITO
  451. {
  452. if( szimb_tabla.count( *$1 ) == 0 )
  453. {
  454. std::cerr << d_loc__.first_line << ": A(z) '" << *$1 << "' valtozo nincs deklaralva." << std::endl;
  455. exit(1);
  456. }
  457. else
  458. {
  459. valtozo_leiro vl = szimb_tabla[*$1];
  460. std::string reg;
  461. if(vl.vtip == Logikai)
  462. reg = "al";
  463. else
  464. reg = "eax";
  465. $$ = new kifejezes_leiro( vl.def_sora, vl.vtip, "mov" + reg + "["+vl.cimke+"]\n");
  466. delete $1;
  467. }
  468. }
  469. |
  470. kifejezes PLUSZ kifejezes
  471. {
  472. if( $1->ktip != Egesz )
  473. {
  474. std::cerr << $1->sor << ": A '+' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  475. exit(1);
  476. }
  477. if( $3->ktip != Egesz )
  478. {
  479. std::cerr << $3->sor << ": A '+' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  480. exit(1);
  481. }
  482. std::string c = $3->code +
  483. "push eax\n" +
  484. $1->code +
  485. "pop edx\n" +
  486. "add eax,edx\n";
  487. $$ = new kifejezes_leiro( d_loc__.first_line, Egesz, c);
  488. delete $1;
  489. delete $3;
  490. }
  491. |
  492. kifejezes MINUSZ kifejezes
  493. {
  494. if( $1->ktip != Egesz )
  495. {
  496. std::cerr << $1->sor << ": A '-' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  497. exit(1);
  498. }
  499. if( $3->ktip != Egesz )
  500. {
  501. std::cerr << $3->sor << ": A '-' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  502. exit(1);
  503. }
  504. std::string c = $3->code +
  505. "push eax\n" +
  506. $1->code +
  507. "pop ebx\n" +
  508. "sub eax,ebx\n";
  509. $$ = new kifejezes_leiro( d_loc__.first_line, Egesz, c);
  510. delete $1;
  511. delete $3;
  512. }
  513. |
  514. kifejezes SZORZAS kifejezes
  515. {
  516. if( $1->ktip != Egesz )
  517. {
  518. std::cerr << $1->sor << ": A '*' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  519. exit(1);
  520. }
  521. if( $3->ktip != Egesz )
  522. {
  523. std::cerr << $3->sor << ": A '*' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  524. exit(1);
  525. }
  526. std::string c = $3->code +
  527. "push eax\n" +
  528. $1->code +
  529. "pop ebx\n" +
  530. "mov edx,0" +
  531. "mul ebx\n";
  532. $$ = new kifejezes_leiro( d_loc__.first_line, Egesz, c);
  533. delete $1;
  534. delete $3;
  535. }
  536. |
  537. kifejezes OSZTAS kifejezes
  538. {
  539. if( $1->ktip != Egesz )
  540. {
  541. std::cerr << $1->sor << ": A '/' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  542. exit(1);
  543. }
  544. if( $3->ktip != Egesz )
  545. {
  546. std::cerr << $3->sor << ": A '/' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  547. exit(1);
  548. }
  549. std::string c = $3->code +
  550. "push eax\n" +
  551. $1->code +
  552. "pop ebx\n" +
  553. "mov edx,0" +
  554. "div ebx\n";
  555.  
  556. $$ = new kifejezes_leiro( d_loc__.first_line, Egesz, c);
  557. delete $1;
  558. delete $3;
  559. }
  560. |
  561. kifejezes MARADEK kifejezes
  562. {
  563. if( $1->ktip != Egesz )
  564. {
  565. std::cerr << $1->sor << ": A '%' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  566. exit(1);
  567. }
  568. if( $3->ktip != Egesz )
  569. {
  570. std::cerr << $3->sor << ": A '%' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  571. exit(1);
  572. }
  573. std::string c = $3->code +
  574. "push eax\n" +
  575. $1->code +
  576. "pop ebx\n" +
  577. "mov edx,0" +
  578. "div ebx\n" +
  579. "mov eax,edx";
  580. $$ = new kifejezes_leiro( d_loc__.first_line, Egesz, c);
  581. delete $1;
  582. delete $3;
  583. }
  584. |
  585. kifejezes KISEBB kifejezes
  586. {
  587. if( $1->ktip != Egesz )
  588. {
  589. std::cerr << $1->sor << ": A '<' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  590. exit(1);
  591. }
  592. if( $3->ktip != Egesz )
  593. {
  594. std::cerr << $3->sor << ": A '<' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  595. exit(1);
  596. }
  597. std::string c = $3->code +
  598. "push eax\n" +
  599. $3->code +
  600. "pop ebx\n" +
  601. "cmp eax,ebx\n" +
  602. "setl al\n";
  603. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, c);
  604. delete $1;
  605. delete $3;
  606. }
  607. |
  608. kifejezes NAGYOBB kifejezes
  609. {
  610. if( $1->ktip != Egesz )
  611. {
  612. std::cerr << $1->sor << ": A '>' operator baloldalan nem egesz tipusu kifejezes all." << std::endl;
  613. exit(1);
  614. }
  615. if( $3->ktip != Egesz )
  616. {
  617. std::cerr << $3->sor << ": A '>' operator jobboldalan nem egesz tipusu kifejezes all." << std::endl;
  618. exit(1);
  619. }
  620. std::string c = $3->code +
  621. "push eax\n" +
  622. $3->code +
  623. "pop ebx\n" +
  624. "cmp eax,ebx\n" +
  625. "setl al\n";
  626. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, c);
  627. delete $1;
  628. delete $3;
  629. }
  630. |
  631. kifejezes EGYENLO kifejezes
  632. {
  633. if( $1->ktip != $3->ktip )
  634. {
  635. std::cerr << $1->sor << ": Az '=' operator jobb- es baloldalan kulonbozo tipusu kifejezesek allnak." << std::endl;
  636. exit(1);
  637. }
  638. std::string c = $3->code +
  639. "push eax\n" +
  640. $3->code +
  641. "pop ebx\n" +
  642. "cmp eax,ebx\n" +
  643. "sete al\n";
  644. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, c);
  645. delete $1;
  646. delete $3;
  647. }
  648. |
  649. kifejezes ES kifejezes
  650. {
  651. if( $1->ktip != Logikai )
  652. {
  653. std::cerr << $1->sor << ": Az 'ES' operator baloldalan nem logikai tipusu kifejezes all." << std::endl;
  654. exit(1);
  655. }
  656. if( $3->ktip != Logikai )
  657. {
  658. std::cerr << $3->sor << ": Az 'ES' operator jobboldalan nem logikai tipusu kifejezes all." << std::endl;
  659. exit(1);
  660. }
  661. std::string c = $1->code +
  662. "push ax\n" +
  663. $3->code +
  664. "pop bx\n" +
  665. "and al,bl\n";
  666. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, c);
  667. delete $1;
  668. delete $3;
  669. }
  670. |
  671. kifejezes VAGY kifejezes
  672. {
  673. if( $1->ktip != Logikai )
  674. {
  675. std::cerr << $1->sor << ": A 'VAGY' operator baloldalan nem logikai tipusu kifejezes all." << std::endl;
  676. exit(1);
  677. }
  678. if( $3->ktip != Logikai )
  679. {
  680. std::cerr << $3->sor << ": A 'VAGY' operator jobboldalan nem logikai tipusu kifejezes all." << std::endl;
  681. exit(1);
  682. }
  683. std::string c = $1->code +
  684. "push ax\n" +
  685. $3->code +
  686. "pop bx\n" +
  687. "or al,bl\n";
  688. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, c);
  689. delete $1;
  690. delete $3;
  691. }
  692. |
  693. NEM kifejezes
  694. {
  695. if( $2->ktip != Logikai )
  696. {
  697. std::cerr << $2->sor << ": A 'NEM' operator utan nem logikai tipusu kifejezes all." << std::endl;
  698. exit(1);
  699. }
  700. $$ = new kifejezes_leiro( d_loc__.first_line, Logikai, $2->code + "xor al,1\n");
  701. delete $2;
  702. }
  703. |
  704. BALZAROJEL kifejezes JOBBZAROJEL
  705. {
  706. $$ = $2;
  707. }
  708. ;
  709.  
  710. ####
  711. #ifndef Parser_h_included
  712. #define Parser_h_included
  713.  
  714. #include <map>
  715. #include <string>
  716. #include <FlexLexer.h>
  717. #include "Parserbase.h"
  718. #include "semantics.h"
  719.  
  720. #undef Parser
  721. class Parser: public ParserBase
  722. {
  723.  
  724. public:
  725. Parser(std::istream& inFile) : lexer( &inFile, &std::cerr ) {}
  726. int parse();
  727.  
  728. private:
  729. yyFlexLexer lexer;
  730. static int counter;
  731. void error(char const *msg); // called on (syntax) errors
  732. int lex(); // returns the next token from the
  733. // lexical scanner.
  734. void print(); // use, e.g., d_token, d_loc
  735. std::map<std::string,valtozo_leiro> szimb_tabla;
  736. int sorszam;
  737.  
  738. // support functions for parse():
  739. void executeAction(int ruleNr);
  740. void errorRecovery();
  741. int lookup(bool recovery);
  742. void nextToken();
  743. void print__();
  744. void exceptionHandler__(std::exception const &exc);
  745. };
  746.  
  747.  
  748. #endif
  749. ####
  750. // Generated by Bisonc++ V4.09.02 on Tue, 24 Oct 2017 21:29:10 +0200
  751.  
  752. // Include this file in the sources of the class Parser.
  753.  
  754. // $insert class.h
  755. #include "Parser.h"
  756. #include <cstdlib>
  757.  
  758.  
  759. inline void Parser::error(char const *msg)
  760. {
  761. std::cerr << "line " << d_loc__.first_line << ": " << msg << '\n';
  762. exit(1);
  763. }
  764.  
  765. // $insert lex
  766. inline int Parser::lex()
  767. {
  768. int ret = lexer.yylex();
  769. d_loc__.first_line = lexer.lineno();
  770. if( ret == Parser::AZONOSITO || ret == Parser::SZAMKONSTANS )
  771. d_val__.szoveg = new std::string(lexer.YYText());
  772. return ret;
  773. }
  774.  
  775. inline void Parser::print()
  776. {
  777. print__(); // displays tokens if --print was specified
  778. }
  779.  
  780. inline void Parser::exceptionHandler__(std::exception const &exc)
  781. {
  782. throw; // re-implement to handle exceptions thrown by actions
  783. }
  784.  
  785. // Add here includes that are only required for the compilation
  786. // of Parser's sources.
  787.  
  788.  
  789.  
  790. // UN-comment the next using-declaration if you want to use
  791. // int Parser's sources symbols from the namespace std without
  792. // specifying std::
  793.  
  794. //using namespace std;
  795. ####
  796. #ifndef SEMANTICS_H
  797. #define SEMANTICS_H
  798.  
  799. #include <string>
  800. #include <iostream>
  801. #include <sstream>
  802.  
  803. enum tipus { Egesz, Logikai };
  804.  
  805. struct valtozo_leiro
  806. {
  807. int def_sora;
  808. tipus vtip;
  809. std::string cimke;
  810. valtozo_leiro( int s = 0, tipus t = Egesz, int sz = 0)
  811. : def_sora(s), vtip(t)
  812. {
  813. std::stringstream out;
  814. out << "Cimke" << sz;
  815. cimke = out.str();
  816. }
  817. };
  818.  
  819. struct kifejezes_leiro
  820. {
  821. int sor;
  822. tipus ktip;
  823. std::string code;
  824. kifejezes_leiro( int s, tipus t , const std::string &c)
  825. : sor(s), ktip(t), code(c)
  826. {}
  827. };
  828.  
  829. struct utasitas_leiro
  830. {
  831. int sor;
  832. std::string code;
  833. utasitas_leiro( int s, const std::string &c="" )
  834. : sor(s), code(c)
  835. {}
  836. };
  837.  
  838.  
  839. #endif //SEMANTICS_H
  840. ####
  841. #include <iostream>
  842. #include <fstream>
  843. #include <sstream>
  844. #include <cstdlib>
  845. #include "Parser.h"
  846.  
  847. using namespace std;
  848. int Parser::counter = 0;
  849.  
  850. void input_handler( ifstream& in, int argc, char* argv[] );
  851.  
  852. int main( int argc, char* argv[] )
  853. {
  854. ifstream in;
  855. input_handler( in, argc, argv );
  856. Parser pars( in );
  857. pars.parse();
  858. return 0;
  859. }
  860.  
  861. void input_handler( ifstream& in, int argc, char* argv[] )
  862. {
  863. if( argc < 2 )
  864. {
  865. cerr << "A forditando fajl nevet parancssori parameterben kell megadni." << endl;
  866. exit(1);
  867. }
  868. in.open( argv[1] );
  869. if( !in )
  870. {
  871. cerr << "A " << argv[1] << "fajlt nem sikerult megnyitni." << endl;
  872. exit(1);
  873. }
  874. }
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!