API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 18th, 2019
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.94 KB | None | 0 0
raw download clone embed print report
  1. int program()
  2. {
  3. int start=idxCrtAtomi;
  4. for(;;)
  5. {
  6. if(defVar())
  7. {
  8.  
  9. }
  10. else if(defFunc())
  11. {
  12.  
  13. }
  14. else if(block())
  15. {
  16.  
  17.  
  18. }
  19. else
  20. {
  21. break;
  22. }
  23. }
  24. if(consume(FINISH))
  25. {
  26. return 1;
  27. }
  28. else
  29. {
  30. eroare1("lipseste FINISH!");
  31. return 0;
  32. }
  33. idxCrtAtomi=start;
  34. return 0;
  35. }
  36.  
  37. int defVar()
  38. {
  39. int start=idxCrtAtomi;
  40. if(consume(VAR))
  41. {
  42. if(consume(ID))
  43. {
  44. if(consume(COLON))
  45. {
  46. if(base_Type())
  47. {
  48. if(consume(SEMICOLON))
  49. {
  50. return 1;
  51. }
  52. else
  53. {
  54. eroare1("lipseste ; ");
  55. }
  56. }
  57. else
  58. {
  59. eroare1("lipseste tipul ");
  60. }
  61. }
  62. else
  63. {
  64. eroare1("lipsesc : ");
  65. }
  66. }
  67. else
  68. {
  69. eroare1("Lipseste ID !!");
  70. }
  71. }
  72. idxCrtAtomi=start;
  73. return 0;
  74. }
  75.  
  76. int base_Type()
  77. {
  78. if(consume(TYPE_INT))
  79. {
  80. return 1;
  81. }
  82. else if(consume(TYPE_REAL))
  83. {
  84. return 1;
  85. }
  86. else if(consume(TYPE_STR))
  87. {
  88. return 1;
  89. }
  90. else
  91. {
  92. return 0;
  93. }
  94. }
  95.  
  96. int defFunc()
  97. {
  98. int start=idxCrtAtomi;
  99. if(consume(FUNCTION))
  100. {
  101. if(consume(ID))
  102. {
  103. if(consume(LPAR))
  104. {
  105. if(funcParams())
  106. {
  107.  
  108. if(consume(RPAR))
  109. {
  110. if(consume(COLON))
  111. {
  112. if(base_Type())
  113. {
  114. for(;;)
  115. {
  116. if(defVar())
  117. {
  118.  
  119. }
  120. else
  121. {
  122. break;
  123. }
  124. }
  125. if(block())
  126. {
  127. if(consume(END))
  128. {
  129. return 1;
  130. }
  131. else
  132. {
  133. eroare1("lipseste END .");
  134. }
  135. }
  136. else
  137. {
  138. eroare1("lipseste blocul .");
  139. }
  140. }
  141. else
  142. {
  143. eroare1("lipseste tipul .");
  144. }
  145. }
  146. else
  147. {
  148. eroare1("lipsesc : .");
  149. }
  150. }
  151. else
  152. {
  153. eroare1("lipseste ) .");
  154. }
  155. }
  156. else
  157. {
  158. eroare1("lipsesc parametri .");
  159. }
  160. }
  161. else
  162. {
  163. eroare1("lipseste ( .");
  164. }
  165. }
  166. else
  167. {
  168. eroare1("lipseste ID .");
  169. }
  170. }
  171. idxCrtAtomi=start;
  172. return 0;
  173. }
  174.  
  175. int block()
  176. {
  177. int start=idxCrtAtomi;
  178. if(instr())
  179. {
  180. for(;;)
  181. {
  182. if(instr())
  183. {
  184.  
  185. }
  186. else
  187.  
  188. {
  189. break;
  190. }
  191. }
  192. return 1;
  193. }
  194. idxCrtAtomi=start;
  195. return 0;
  196. }
  197.  
  198. int funcParams()
  199. {
  200. int start=idxCrtAtomi;
  201. if(funcParam())
  202. {
  203. for(;;)
  204. {
  205. if(consume(COMMA))
  206. {
  207. if(funcParam())
  208. {
  209.  
  210. }
  211. }
  212. else
  213. {
  214. break;
  215. }
  216. }
  217. return 1;
  218. }
  219. idxCrtAtomi=start;
  220. return 0;
  221. }
  222.  
  223. int funcParam()
  224. {
  225. int start=idxCrtAtomi;
  226. if(consume(ID))
  227. {
  228. if(consume(COLON))
  229. {
  230. if(base_Type())
  231. {
  232. return 1;//intreb
  233. }
  234. else
  235. {
  236. eroare1("lipseste tipul .");
  237. }
  238. }
  239. else
  240. {
  241. eroare1("lipsesc : .");
  242. }
  243. }
  244. idxCrtAtomi=start;
  245. return 0;
  246. }
  247. int instr()
  248. {
  249. int start=idxCrtAtomi;
  250. if(expr())
  251. {
  252. if(consume(SEMICOLON))
  253. {
  254. return 1;
  255. }
  256. else
  257. {
  258. eroare1("lipseste ; .");
  259. }
  260. }
  261. else if(consume(IF))
  262. {
  263. if(consume(LPAR))
  264. {
  265. if(expr())
  266. {
  267. if(consume(RPAR))
  268. {
  269. if(block())
  270. {
  271. if(consume(ELSE))
  272. {
  273. if(block())
  274. {
  275. if(consume(END))
  276. {
  277. return 1;
  278. }
  279. else
  280. {
  281. eroare1("lipseste END dupa ramura ELSE .");
  282. }
  283.  
  284. }
  285. else
  286. {
  287. eroare1("lipseste blocul la ramura ELSE .");
  288. }
  289. }
  290. else if(consume(END))
  291. {
  292. return 1;
  293. }
  294. else
  295. {
  296. eroare1("lipseste END la finalul IF .");
  297. }
  298. }
  299. else
  300. {
  301. eroare1("lipseste blocul din IF .");
  302. }
  303. }
  304. else
  305. {
  306. eroare1("lipseste ) .");
  307. }
  308. }
  309. else
  310. {
  311. eroare1("lipseste expresia .");
  312. }
  313. }
  314. else
  315. {
  316. eroare1("lipseste ( .");
  317. }
  318. }
  319. else if(consume(RETURN))
  320. {
  321. if(expr())
  322. {
  323. if(consume(SEMICOLON))
  324. {
  325. return 1;
  326. }
  327. else
  328. {
  329. eroare1("lipseste ; dupa expr din RETURN .");
  330. }
  331. }
  332. else
  333. {
  334. eroare1("lipseste expr dupa RETURN .");
  335. }
  336. }
  337. else if(consume(WHILE))
  338. {
  339. if(consume(LPAR))
  340. {
  341. if(expr())
  342. {
  343. if(consume(RPAR))
  344. {
  345.  
  346. if(block())
  347. {
  348.  
  349. if(consume(END))
  350. {
  351. return 1;
  352. }
  353. else
  354. {
  355. eroare1("lipseste END .");
  356. }
  357. }
  358. else
  359. {
  360. eroare1("lipseste blocul .");
  361. }
  362. }
  363. else
  364. {
  365. eroare1("lipseste ) .");
  366. }
  367. }
  368. else
  369. {
  370. eroare1("lipseste expr .");
  371. }
  372. }
  373. else
  374. {
  375. eroare1("lipseste ( .");
  376. }
  377. }
  378. idxCrtAtomi=start;
  379. return 0;
  380. }
  381. int expr()
  382. {
  383. int start=idxCrtAtomi;
  384. if(expr_Logic())
  385. {
  386. return 1;
  387. }
  388. idxCrtAtomi=start;
  389. return 0;
  390. }
  391. int expr_Logic()
  392. {
  393. int start=idxCrtAtomi;
  394. if(expr_Assign())
  395. {
  396. for(;;)
  397. {
  398. if(consume(AND))
  399. {
  400.  
  401. if(expr_Assign())
  402. {
  403.  
  404.  
  405. }
  406. else
  407. {
  408. eroare1("lipseste expr_Assign .");
  409. }
  410. }
  411. else if(consume(OR))
  412. {
  413. if(expr_Assign())
  414. {
  415.  
  416. }
  417. else
  418. {
  419. eroare1("lipseste expr_Assign .");
  420. }
  421. }
  422. else
  423. {
  424. break;
  425. }
  426. }
  427. return 1;
  428. }
  429. idxCrtAtomi=start;
  430. return 0;
  431. }
  432. int expr_Assign()
  433. {
  434. int start=idxCrtAtomi;
  435. if(consume(ID))
  436. {
  437. if(consume(ASSIGN))
  438. {
  439. if(expr_Comp())
  440. {
  441. return 1;
  442. }
  443. else
  444. {
  445. eroare1("lipseste expr_Comp .");
  446. }
  447. }
  448. else
  449. {
  450. idxCrtAtomi=start;
  451. if(expr_Comp())
  452. {
  453. return 1;
  454. }
  455. else
  456. {
  457. return 0;
  458. }
  459. }
  460. }
  461. else
  462. {
  463. if(expr_Comp())
  464. {
  465. return 1;
  466. }
  467. else
  468. {
  469. return 0;
  470. }
  471. }
  472.  
  473. }
  474. int expr_Comp()
  475. {
  476. int start=idxCrtAtomi;
  477. if(expr_Add())
  478. {
  479. if(consume(LESS))
  480. {
  481. if(expr_Add())
  482. {
  483. return 1;
  484. }
  485. else
  486. {
  487. eroare1("lipseste expr_Add dupa LESS .");
  488. }
  489. }
  490. else if(consume(EQUAL))
  491. {
  492. if(expr_Add())
  493. {
  494. return 1;
  495. }
  496. else
  497. {
  498. eroare1("lipseste expr_Add dupa EQUAL .");
  499. }
  500. }
  501. return 1;
  502. }
  503. idxCrtAtomi=start;
  504. return 0;
  505. }
  506. int expr_Add()
  507. {
  508. int start=idxCrtAtomi;
  509. if(expr_Mul())
  510. {
  511. for(;;)
  512. {
  513. if(consume(ADD))
  514. {
  515. if(expr_Mul())
  516. {
  517.  
  518. }
  519. else
  520. {
  521. eroare1("lipseste expr_Mul dupa ADD .");
  522. }
  523. }
  524. else if(consume(SUB))
  525. {
  526. if(expr_Mul())
  527. {
  528.  
  529. }
  530. else
  531. {
  532. eroare1("lipseste expr_Mul dupa SUB .");
  533. }
  534. }
  535. else
  536. {
  537. break;
  538. }
  539. }
  540. return 1;
  541. }
  542. idxCrtAtomi=start;
  543. return 0;
  544. }
  545. int expr_Mul()
  546. {
  547. int start=idxCrtAtomi;
  548. if(expr_Prefix())
  549. {
  550. for(;;)
  551. {
  552. if(consume(MUL))
  553. {
  554. if(expr_Prefix())
  555. {
  556.  
  557. }
  558. else
  559. {
  560. eroare1("lipseste expr_Prefix dupa MUL .");
  561. }
  562. }
  563. else if(consume(DIV))
  564. {
  565. if(expr_Prefix())
  566. {
  567.  
  568. }
  569. else
  570. {
  571. eroare1("lipseste expr_Prefix dupa DIV .");
  572. }
  573. }
  574. else
  575. {
  576. break;
  577. }
  578. }
  579. return 1;
  580. }
  581. idxCrtAtomi=start;
  582. return 0;
  583. }
  584. int expr_Prefix()
  585. {
  586. int start=idxCrtAtomi;
  587. if(consume(SUB))
  588. {
  589. if(factor())
  590. {
  591. return 1;
  592. }
  593. else
  594. {
  595. eroare1("lipseste factor dupa SUB .");
  596. }
  597. }
  598. else if(consume(NOT))
  599. {
  600. if(factor())
  601. {
  602. return 1;
  603. }
  604. else
  605. {
  606. eroare1("lipseste factor dupa NOT .");
  607. }
  608. }
  609. else if(factor())
  610. {
  611. return 1;
  612. }
  613. start=idxCrtAtomi;
  614. return 0;
  615. }
  616.  
  617. int factor()
  618. {
  619. int start=idxCrtAtomi;
  620. if(consume(INT))
  621. {
  622. return 1;
  623. }
  624. else if(consume(REAL))
  625. {
  626. return 1;
  627. }
  628. else if(consume(STR))
  629. {
  630. return 1;
  631. }
  632. else if(consume((LPAR)))
  633. {
  634. if(expr())
  635. {
  636. if(consume(RPAR))
  637. {
  638.  
  639. return 1;
  640. }
  641. else
  642. {
  643. eroare1("lipseste ) .");
  644. }
  645. }
  646. else
  647. {
  648. eroare1("lipseste expr .");
  649. }
  650. }
  651. else if(consume(ID))
  652. {
  653. if(consume(LPAR))
  654. {
  655. if(expr())
  656. {
  657. for(;;)
  658. {
  659. if(consume(COMMA))
  660. {
  661. if(expr())
  662. {
  663.  
  664. }
  665. else
  666. {
  667. eroare1("lipseste expr dupa , .");
  668. }
  669. }
  670. else
  671. {
  672. break;
  673. }
  674. }
  675. if(consume(RPAR))
  676. {
  677. return 1;
  678. }
  679. else
  680. {
  681. eroare1("lipseste ) .");
  682. }
  683. }
  684. else if(consume(RPAR))
  685. {
  686. return 1;
  687. }
  688. }
  689. return 1;
  690. }
  691. idxCrtAtomi=start;
  692. return 0;
  693. }
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!