API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 13th, 2018
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.59 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #define GRIZRAZ "Izraz"
  6. #define DUGAKONST "String"
  7. #define OCEKIVANO "Ocekivano "
  8. #define IMEFUN "Ime funkcije"
  9. #define DEFFUN "Def. funkcije"
  10. #define OCEKDOD "Dodjeljivanje"
  11. #define PSL "Ime varijable"
  12. #define FALSE 0
  13. #define TRUE 1
  14.  
  15. FILE *ulaz, *izlaz;
  16. long pozicija, trenlabela, brojaclinija;
  17. char znak;
  18. char linija[256], aktivnafunkcija[256];
  19. int DodjelaKarakteru;
  20. void IzrazDodjeljivanja(void);
  21. void Blok(void);
  22.  
  23. void NovaLabela(char *ImeLabele) {
  24. trenlabela++;
  25. sprintf(ImeLabele, "%d", trenlabela);
  26. }
  27.  
  28. void Greska(char *poruka) {
  29. puts(poruka);
  30. fprintf(stderr,"%d:%s\n",
  31. brojaclinija, linija);
  32. if (ulaz != NULL)
  33. fclose(ulaz);
  34. ulaz = NULL;
  35. if (izlaz != NULL)
  36. fclose(izlaz);
  37. izlaz = NULL;
  38. exit(0);
  39. }
  40.  
  41. void Emit(char *st) {
  42. fprintf(izlaz, "%s\r\n", st);
  43. }
  44.  
  45. void Novi(void) {
  46. char *TEMP;
  47. char STR1[256];
  48. do {
  49. pozicija++;
  50. if (pozicija>strlen(linija))
  51. {
  52. brojaclinija++;
  53. if (!feof(ulaz)) {
  54. fgets(linija,256, ulaz);
  55. TEMP=
  56. strchr(linija,'\n');
  57. if (TEMP != NULL)
  58. *TEMP = 0;
  59. }
  60. sprintf(STR1,";%s",linija);
  61. Emit(STR1);
  62. pozicija = 1;
  63. }
  64. if (*linija != '\0')
  65. znak = linija[pozicija-1];
  66. else
  67. znak = ' ';
  68. if(znak == '>'){
  69. if(linija[pozicija] == '=')
  70. {
  71. pozicija++;
  72. znak = -1;
  73. }
  74. }
  75. if (znak == '`')
  76. pozicija = strlen(linija);
  77. } while (!((znak > ' ' && znak != '`') | feof(ulaz) | (znak == -1)));
  78. }
  79.  
  80. void MoraBiti(char z) {
  81. char STR1[12];
  82. if (znak != z) {
  83. sprintf(STR1, "%s%c",
  84. OCEKIVANO, z);
  85. Greska(STR1);
  86. }
  87. Novi();
  88. }
  89.  
  90. long UzmiKonstantu(void) {
  91. long rezult = 0;
  92. while (isdigit(znak)) {
  93. rezult=rezult*10+znak-'0';
  94. Novi();
  95. }
  96. return rezult;
  97. }
  98.  
  99. void UzmiIme(char *Ime) {
  100. *Ime = '\0';
  101. while (isalpha(znak)) {
  102. sprintf(Ime+strlen(Ime),"%c",
  103. znak);
  104. Novi();
  105. }
  106. }
  107.  
  108. int Slijedi(char * ocekivano) {
  109. char STR1[256];
  110. int i,n,len1,len2;
  111. len1=strlen(linija);
  112. len2=strlen(ocekivano);
  113. i=pozicija-1;
  114. n=0;
  115. while(linija[i]==ocekivano[n])
  116. {
  117. i++; n++;
  118. }
  119. if (ocekivano[n]==0) {
  120. pozicija+=strlen(ocekivano)-1;
  121. return TRUE;
  122. }
  123. else
  124. return FALSE;
  125. }
  126.  
  127. void EmitGetVal(int ChrIzraz) {
  128. if (ChrIzraz) {
  129. Emit(" MOV AL,[EBX]");
  130. Emit(" AND EAX,255");
  131. } else
  132. Emit(" MOV EAX,[EBX]");
  133. }
  134.  
  135. void PokazivacINiz(int ChrIzraz) {
  136. Novi();
  137. Emit(" PUSH EAX");
  138. IzrazDodjeljivanja();
  139. Emit(" POP EBX");
  140. if (!ChrIzraz)
  141. Emit(" SAL EAX,2");
  142. Emit(" ADD EBX,EAX");
  143. EmitGetVal(ChrIzraz);
  144. MoraBiti(']');
  145. }
  146.  
  147. void StringKonstanta(void) {
  148. char strtekst[256], lab[256];
  149. char STR1[256], STR2[256];
  150. NovaLabela(strtekst);
  151. Emit("section .data");
  152. sprintf(lab, "L%s", strtekst);
  153. pozicija++;
  154. do {
  155. if (pozicija>strlen(linija))
  156. Greska(DUGAKONST);
  157. znak = linija[pozicija-1];
  158. pozicija++;
  159. if (znak != '"') {
  160. sprintf(STR2,
  161. "%s DB %d", lab, znak);
  162. Emit(STR2);
  163. *lab = '\0';
  164. }
  165. } while (znak != '"');
  166. pozicija--;
  167. Novi();
  168. sprintf(STR2, "%s DB 0", lab);
  169. Emit(STR2);
  170. Emit("section .text");
  171. sprintf(STR1," LEA EAX,[L%s]",
  172. strtekst);
  173. Emit(STR1);
  174. }
  175.  
  176. void PozivFunkcije(void) {
  177. long lokalnih = 0;
  178. char ImeFunkcije[256], staddr[256];
  179. char STR1[256], STR2[256];
  180. UzmiIme(ImeFunkcije);
  181. if (znak==' ' || znak == '`')
  182. Novi();
  183. MoraBiti('(');
  184. NovaLabela(staddr);
  185. sprintf(STR1, " SUB ESP,L%s",
  186. staddr);
  187. Emit(STR1);
  188. while (znak != ')') {
  189. IzrazDodjeljivanja();
  190. sprintf(STR2,
  191. " MOV [ESP+%d],EAX",
  192. lokalnih);
  193. Emit(STR2);
  194. lokalnih += 4;
  195. if (znak != ')')
  196. MoraBiti(',');
  197. }
  198. MoraBiti(')');
  199. sprintf(STR2, "L%s EQU %d",
  200. staddr, lokalnih);
  201. Emit(STR2);
  202. sprintf(STR1, "_%s@%d",
  203. ImeFunkcije,lokalnih);
  204. strcpy(ImeFunkcije,STR1);
  205.  
  206. sprintf(STR2, " CALL %s",
  207. ImeFunkcije);
  208. Emit(STR2);
  209. }
  210.  
  211. void Varijabla(void) {
  212. char ImeVarijable[256], znak1;
  213. int chrIzraz;
  214. char STR1[256], STR2[256];
  215. chrIzraz = FALSE;
  216. znak1 = znak;
  217. UzmiIme(ImeVarijable);
  218. switch (znak1) {
  219. case 'l':
  220. case 'p':
  221. sprintf(STR1,
  222. " LEA EBX,[EBP+%s%s]",
  223. aktivnafunkcija,
  224. ImeVarijable);
  225. Emit(STR1);
  226. break;
  227. default:
  228. sprintf(STR2," LEA EBX,[%s]"
  229. , ImeVarijable);
  230. Emit(STR2);
  231. chrIzraz = (znak1 == 'c');
  232. break;
  233. }
  234. if (znak != '[') {
  235. EmitGetVal(FALSE);
  236. return;
  237. }
  238. Emit(" MOV EAX,[EBX]");
  239. PokazivacINiz(chrIzraz);
  240. if (znak == ':' && chrIzraz)
  241. DodjelaKarakteru = TRUE;
  242. }
  243.  
  244. void Faktor(void) {
  245. long rezultat;
  246. char STR1[256];
  247. switch (znak) {
  248. case '-':
  249. Novi();
  250. Faktor();
  251. Emit(" NEG EAX");
  252. break;
  253. case '~':
  254. Novi();
  255. Faktor();
  256. Emit(" NOT EAX");
  257. break;
  258. case '&':
  259. Novi();
  260. Faktor();
  261. Emit(" MOV EAX,EBX");
  262. break;
  263. case '*':
  264. Novi();
  265. Faktor();
  266. Emit(" MOV EBX,EAX");
  267. Emit(" MOV EAX,[EBX]");
  268. break;
  269. case '!':
  270. Novi();
  271. Faktor();
  272. Emit(" CMP EAX,0");
  273. Emit(" SETE AL");
  274. Emit(" AND EAX,0FFh");
  275. break;
  276. case '"':
  277. StringKonstanta();
  278. break;
  279. case '(':
  280. Novi();
  281. IzrazDodjeljivanja();
  282. MoraBiti(')');
  283. break;
  284. default:
  285. if (isdigit(znak)) {
  286. rezultat =UzmiKonstantu();
  287. sprintf(STR1,
  288. " MOV EAX,%d",rezultat);
  289. Emit(STR1);
  290. } else if (isupper(znak))
  291. PozivFunkcije();
  292. else if (islower(znak))
  293. Varijabla();
  294. else
  295. Greska(GRIZRAZ);
  296. break;
  297. }
  298. }
  299. void Clan(void) {
  300. char z;
  301. Faktor();
  302. while (znak == '%' ||
  303. znak == '/' ||
  304. znak == '*') {
  305. z = znak;
  306. Emit(" PUSH EAX");
  307. Novi();
  308. Faktor();
  309. switch (z) {
  310. case '*':
  311. Emit(" POP EBX");
  312. Emit(" IMUL EBX");
  313. break;
  314. case '/':
  315. case '%':
  316. Emit(" MOV EBX,EAX");
  317. Emit(" POP EAX");
  318. Emit(" CDQ");
  319. Emit(" IDIV EBX");
  320. if (z == '%')
  321. Emit(" MOV EAX,EDX");
  322. break;
  323. }
  324. }
  325. }
  326.  
  327. void Izraz(void) {
  328. char z;
  329. Clan();
  330. while (znak == '^' || znak ==
  331. '|' || znak == '&' ||
  332. znak == '-' ||
  333. znak == '+') {
  334. Emit(" PUSH EAX");
  335. z = znak;
  336. Novi();
  337. Clan();
  338. switch (z) {
  339. case '+':
  340. Emit(" POP EBX");
  341. Emit(" ADD EAX,EBX");
  342. break;
  343. case '-':
  344. Emit(" MOV EBX,EAX");
  345. Emit(" POP EAX");
  346. Emit(" SUB EAX,EBX");
  347. break;
  348. case '&':
  349. Emit(" POP EBX");
  350. Emit(" AND EAX,EBX");
  351. break;
  352. case '|':
  353. Emit(" POP EBX");
  354. Emit(" OR EAX,EBX");
  355. break;
  356. case '^':
  357. Emit(" POP EBX");
  358. Emit(" XOR EAX,EBX");
  359. break;
  360. }
  361. }
  362. }
  363.  
  364. void IzrazDodjeljivanja(void) {
  365. char z;
  366. int ChrIzraz;
  367. DodjelaKarakteru = FALSE;
  368. Izraz();
  369. switch (znak) {
  370. case ':':
  371. if (!Slijedi(":="))
  372. Greska(OCEKDOD);
  373. Emit(" PUSH EBX");
  374. Novi();
  375. ChrIzraz = DodjelaKarakteru;
  376. IzrazDodjeljivanja();
  377. Emit(" POP EBX");
  378. if (ChrIzraz)
  379. Emit(" MOV [EBX],AL");
  380. else
  381. Emit(" MOV [EBX],EAX");
  382. break;
  383. case '=':
  384. case -1:
  385. case '>':
  386. case '<':
  387. case '#':
  388. Emit(" PUSH EAX");
  389. z = znak;
  390. Novi();
  391. Izraz();
  392. Emit(" POP EBX");
  393. Emit(" CMP EBX,EAX");
  394. switch (z) {
  395. case '=':
  396. Emit(" SETE AL");
  397. break;
  398. case -1:
  399. Emit("SETGE AL");
  400. break;
  401. case '>':
  402. Emit(" SETG AL");
  403. break;
  404. case '<':
  405. Emit(" SETL AL");
  406. break;
  407. case '#':
  408. Emit(" SETNE AL");
  409. break;
  410. }
  411. Emit(" AND EAX,0FFh");
  412. break;
  413. }
  414. }
  415. void Uslov(void) {
  416. char sonda[256], sinace[256],
  417. skraj[256];
  418. char STR1[256], STR2[256];
  419. Novi();
  420. IzrazDodjeljivanja();
  421. Emit(" CMP EAX,0");
  422. NovaLabela(sonda);
  423. NovaLabela(sinace);
  424. NovaLabela(skraj);
  425. sprintf(STR1," JNE L%s",
  426. sonda);
  427. Emit(STR1);
  428. sprintf(STR1," JMP L%s",
  429. sinace);
  430. Emit(STR1);
  431. MoraBiti('{');
  432. sprintf(STR2, "L%s:", sonda);
  433. Emit(STR2);
  434. Blok();
  435. sprintf(STR2, " JMP L%s",
  436. skraj);
  437. Emit(STR2);
  438. sprintf(STR1, "L%s:", sinace);
  439. Emit(STR1);
  440. if (Slijedi("inace")) {
  441. Novi();
  442. MoraBiti('{');
  443. Blok();
  444. }
  445. sprintf(STR2, "L%s:", skraj);
  446. Emit(STR2);
  447. }
  448.  
  449. void Asembler(void) {
  450. char *TEMP;
  451. do {
  452. fgets(linija, 256, ulaz);
  453. TEMP = strchr(linija, '\n');
  454. if (TEMP != NULL)
  455. *TEMP = 0;
  456. if (strcmp(linija, "\\"))
  457. Emit(linija);
  458. if (feof(ulaz))
  459. strcpy(linija, "\\");
  460. } while (linija[0] != '\\');
  461. pozicija = 1;
  462. znak = linija[pozicija-1];
  463. MoraBiti('\\');
  464. }
  465.  
  466. void Petlja(void) {
  467. char sdok[256], skraj [256],
  468. suslov[256];
  469. char STR1[256], STR2[256];
  470. Novi();
  471. NovaLabela(suslov);
  472. sprintf(STR2, "L%s:", suslov);
  473. Emit(STR2);
  474. IzrazDodjeljivanja();
  475. Emit(" CMP EAX,0");
  476. NovaLabela(sdok);
  477. NovaLabela(skraj);
  478. sprintf(STR2, " JNE L%s", sdok);
  479. Emit(STR2);
  480. sprintf(STR2,
  481. " JMP L%s",skraj);
  482. Emit(STR2);
  483. MoraBiti('{');
  484. sprintf(STR1, "L%s:", sdok);
  485. Emit(STR1);
  486. Blok();
  487. sprintf(STR1," JMP L%s",
  488. suslov);
  489. Emit(STR1);
  490. sprintf(STR2,"L%s:",skraj);
  491. Emit(STR2);
  492. }
  493.  
  494. void Blok(void) {
  495. while (znak != '}') {
  496. if (Slijedi("dok")) {
  497. Petlja();
  498. continue;
  499. }
  500. if (Slijedi("ako"))
  501. Uslov();
  502. else if(Slijedi("asembler"))
  503. Asembler();
  504. else {
  505. IzrazDodjeljivanja();
  506. MoraBiti(';');
  507. }
  508. }
  509. MoraBiti('}');
  510. }
  511. void DefFunkcija(void) {
  512. char ImeFunkcije[256],
  513. ImeVarijable[256];
  514. long paradresa = 0;
  515. long lokadresa;
  516. char STR1[256];
  517. if (znak < 'A' || znak > 'Z')
  518. Greska(IMEFUN);
  519. UzmiIme(ImeFunkcije);
  520. strcpy(aktivnafunkcija,
  521. ImeFunkcije);
  522. MoraBiti('(');
  523. while (znak != ')') {
  524. if (znak != 'p')
  525. Greska(PSL);
  526. UzmiIme(ImeVarijable);
  527. paradresa += 4;
  528. sprintf(STR1, "%s%s EQU %d",
  529. ImeFunkcije, ImeVarijable,
  530. paradresa + 4);
  531. Emit(STR1);
  532. if (znak != ')')
  533. MoraBiti(',');
  534. }
  535. MoraBiti(')');
  536. switch (znak) {
  537. case '{':
  538. MoraBiti('{');
  539. lokadresa = 0;
  540. if (Slijedi("varijable")) {
  541. Novi();
  542. do {
  543. if (islower(znak)) {
  544. if (znak != 'l')
  545. Greska(PSL);
  546. UzmiIme(ImeVarijable);
  547. lokadresa += 4;
  548. sprintf(STR1,
  549. "%s%s EQU %d",
  550. ImeFunkcije,
  551. ImeVarijable,
  552. -lokadresa);
  553. Emit(STR1);
  554. if (znak != ';')
  555. MoraBiti(',');
  556. }
  557. } while (znak != ';');
  558. MoraBiti(';');
  559. }
  560. sprintf(STR1, "_%s@%d",
  561. ImeFunkcije,paradresa);
  562. strcpy(ImeFunkcije,STR1);
  563. sprintf(STR1, "GLOBAL %s",
  564. ImeFunkcije);
  565. Emit(STR1);
  566. sprintf(STR1,"%s:",ImeFunkcije);
  567. Emit(STR1);
  568. Emit(" PUSH EBP");
  569. Emit(" MOV EBP,ESP");
  570. sprintf(STR1, " SUB ESP,%d",
  571. lokadresa);
  572. Emit(STR1);
  573. Blok();
  574. Emit(" MOV ESP,EBP");
  575. Emit(" POP EBP");
  576. sprintf(STR1, " RET %d",
  577. paradresa);
  578. Emit(STR1);
  579. break;
  580. case ';':
  581. sprintf(STR1,"extern _%s@%d",
  582. ImeFunkcije,paradresa);
  583. Emit(STR1);
  584. MoraBiti(';');
  585. break;
  586. default:
  587. Greska(DEFFUN);
  588. break;
  589. }
  590. }
  591.  
  592. void Prevedi(void) {
  593. char imevarijable[256];
  594. char STR1[256];
  595. Emit("EXTERN _ExitProcess@4");
  596. Emit("section .data");
  597. pozicija = 0;
  598. Novi();
  599. if (Slijedi("varijable")) {
  600. Novi();
  601. do {
  602. if (islower(znak)) {
  603. UzmiIme(imevarijable);
  604. sprintf(STR1, "%s DD 0",
  605. imevarijable);
  606. Emit(STR1);
  607. if (znak != ';')
  608. MoraBiti(',');
  609. }
  610. } while (znak != ';');
  611. MoraBiti(';');
  612. }
  613. Emit("section .text");
  614. while (Slijedi("funkcija")) {
  615. Novi();
  616. DefFunkcija();
  617. }
  618. *aktivnafunkcija = '\0';
  619. MoraBiti('{');
  620. if (znak == '}') {
  621. return;
  622. }
  623. Emit(" global start");
  624. Emit("start:");
  625. Blok();
  626. Emit(" PUSH 0");
  627. Emit(" CALL _ExitProcess@4");
  628. }
  629.  
  630. void Glavni(void) {
  631. char linija[256];
  632. char STR1[256];
  633. trenlabela = 0;
  634. brojaclinija = 0;
  635. *linija = '\0';
  636. Prevedi();
  637. fclose(ulaz);
  638. fclose(izlaz);
  639. printf("Prevedeno! \n");
  640. }
  641.  
  642. int main(int argc,char *argv[]){
  643. if (argc == 3) {
  644. if(!(ulaz=fopen(argv[1],"rb")))
  645. {
  646. fprintf(stderr,
  647. "Necitljiva %s \n", argv[1]);
  648. exit(0);
  649. }
  650. if(!(izlaz=fopen(argv[2],"wb"))){
  651. fprintf(stderr,
  652. "Neupisiva %s \n", argv[2]);
  653. exit(0);
  654. }
  655. }
  656. else {
  657. fprintf(stderr,
  658. "KOMP ime.fil ime.asm \n");
  659. exit(0);
  660. }
  661. Glavni();
  662. fclose(ulaz);
  663. fclose(izlaz);
  664. return(0);
  665. }
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!