API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 29th, 2017
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.02 KB | None | 0 0
raw download clone embed print report
  1. #include<stdio.h>
  2. #include <stdlib.h>
  3. #include <stdarg.h>
  4. #include <ctype.h>
  5. #include <string.h>
  6. #include <unistd.h>
  7.  
  8. #define SAFEALLOC(var,Type) if((var=(Type*)malloc(sizeof(Type)))==NULL) err("not enough memory");
  9.  
  10. char input[50001];
  11. int line;
  12. char *pCtrCh;
  13.  
  14. enum {ID, BREAK, CHAR, DOUBLE, ELSE, FOR, IF, INT, RETURN, STRUCT, VOID, WHILE, CT_INT, CT_REAL, CT_CHAR, CT_STRING, COMMA, SEMICOLON, LPAR, RPAR, LBRACKET, RBRACKET, LACC, RACC, ADD, SUB, MUL, DIV, DOT, AND, OR, NOT, ASSIGN, EQUAL, NOTEQ, LESS, LESSEQ, GREATER, GREATEREQ, SPACE, LINECOMMENT, COMMENT, END };
  15.  
  16. char *word[43] = {"ID", "BREAK", "CHAR", "DOUBLE", "ELSE", "FOR", "IF", "INT", "RETURN", "STRUCT", "VOID", "WHILE", "CT_INT", "CT_REAL", "CT_CHAR", "CT_STRING", "COMMA", "SEMICOLON", "LPAR", "RPAR", "LBRACKET", "RBRACKET", "LACC", "RACC", "ADD", "SUB", "MUL", "DIV", "DOT", "AND", "OR", "NOT", "ASSIGN", "EQUAL", "NOTEQ", "LESS", "LESSEQ", "GREATER", "GREATEREQ", "SPACE", "LINECOMMENT", "COMMENT", "END" };;
  17. typedef struct _Token {
  18. int code;
  19. union {
  20. char *text;
  21. long int i;
  22. double r;
  23. };
  24. int line;
  25. struct _Token *next;
  26. } Token;
  27.  
  28. Token *tokens, *lastToken;
  29.  
  30. void err(const char *fmt,...) {
  31. va_list va;
  32. va_start(va,fmt);
  33. fprintf(stderr,"error: ");
  34. vfprintf(stderr,fmt,va);
  35. fputc('\n',stderr);
  36. va_end(va);
  37. exit(-1);
  38. }
  39.  
  40. Token *addTk(int code) {
  41. Token *tk;
  42. SAFEALLOC(tk,Token)
  43. tk->code=code;
  44. tk->line=line;
  45. tk->next=NULL;
  46. if(lastToken){
  47. lastToken->next=tk;
  48. }else{
  49. tokens=tk;
  50. }
  51. lastToken=tk;
  52. return tk;
  53. }
  54.  
  55.  
  56.  
  57.  
  58. void tkerr(const Token *tk,const char *fmt,...) {
  59. va_list va;
  60. va_start(va,fmt);
  61. fprintf(stderr,"error in line %d: ",tk->line);
  62. vfprintf(stderr,fmt,va);
  63. fputc('\n',stderr);
  64. va_end(va);
  65. exit(-1);
  66. }
  67.  
  68. char *createString(const char *pStartCh, char *pCtrCh){
  69.  
  70.  
  71. int len = pCtrCh-pStartCh;
  72. char *c = (char*)malloc(sizeof(char)*(len+1));
  73. snprintf(c, len, "%s", pStartCh);
  74. //strncpy(c, pStartCh, len);
  75. c[len] = '\0';
  76.  
  77. return c;
  78. }
  79.  
  80. int getNextToken() {
  81. int state=0, nCh;
  82. char ch;
  83. const char *pStartCh;
  84. Token *tk;
  85.  
  86. while(1){
  87. ch=*pCtrCh;
  88.  
  89. switch(state){
  90.  
  91. case 0:
  92. if (ch>='1' && ch<='9'){
  93. pStartCh=pCtrCh;
  94. pCtrCh++;
  95. state=1;
  96. }
  97. else if (ch=='0') {
  98. pStartCh=pCtrCh;
  99. pCtrCh++;
  100. state=2;
  101. }
  102. else if (isalpha(ch) || ch=='_'){
  103. pStartCh=pCtrCh;
  104. pCtrCh++;
  105. state=29;
  106. }
  107. else if (ch=='"'){
  108. pStartCh=pCtrCh;
  109. pCtrCh++;
  110. state=18;
  111.  
  112. }
  113. else if (ch=='\''){
  114. pStartCh=pCtrCh;
  115. pCtrCh++;
  116. state=13;
  117. }
  118. else if (ch=='/'){
  119. pCtrCh++;
  120. state=23;
  121. }
  122. else if (ch==','){
  123. pCtrCh++;
  124. state=32;
  125. }
  126. else if (ch==';'){
  127. pCtrCh++;
  128. state=33;
  129. }
  130. else if (ch=='('){
  131. pCtrCh++;
  132. state=34;
  133. }
  134. else if (ch==')'){
  135. pCtrCh++;
  136. state=35;
  137. }
  138. else if (ch=='{'){
  139. pCtrCh++;
  140. state=36;
  141. }
  142. else if (ch=='}'){
  143. pCtrCh++;
  144. state=37;
  145. }
  146. else if (ch=='['){
  147. pCtrCh++;
  148. state=38;
  149. }
  150. else if (ch==']'){
  151. pCtrCh++;
  152. state=39;
  153. }
  154. else if (ch=='+'){
  155. pCtrCh++;
  156. state=40;
  157. }
  158. else if (ch=='-'){
  159. pCtrCh++;
  160. state=41;
  161. }
  162. else if (ch=='*'){
  163. pCtrCh++;
  164. state=42;
  165. }
  166. else if (ch=='.'){
  167. pCtrCh++;
  168. state=43;
  169. }
  170. else if (ch=='&'){
  171. pCtrCh++;
  172. state=44;
  173. }
  174. else if (ch=='|'){
  175. pCtrCh++;
  176. state=46;
  177. }
  178. else if (ch=='='){
  179.  
  180. pCtrCh++;
  181. state=48;
  182. }
  183. else if (ch=='!'){
  184. pCtrCh++;
  185. state=49;
  186. }
  187. else if (ch=='<'){
  188. pCtrCh++;
  189. state=50;
  190. }
  191. else if (ch=='>'){
  192. pCtrCh++;
  193. state=51;
  194. }
  195. else if (ch==' '||ch=='\r'||ch=='\t'){
  196. pCtrCh++;
  197. }
  198. else if (ch=='\n'){
  199. line++;
  200. pCtrCh++;
  201. }
  202. else if (ch==0){
  203. addTk(END);
  204. return END;
  205. }
  206. else
  207. tkerr(addTk(END),"caracter invalid11");
  208. break;
  209. case 1:
  210. if (ch=='.'){
  211. pCtrCh++;
  212. state=7;
  213. }
  214. else if (ch=='e'||ch=='E'){
  215. pCtrCh++;
  216. state=9;
  217. }
  218. else if (ch>='0' && ch<='9'){
  219. pCtrCh++;
  220.  
  221. }
  222. else
  223. state=6;
  224. break;
  225. case 2:
  226. if (ch=='x'){
  227. pCtrCh++;
  228. state=4;
  229. }
  230. else{
  231. state=3;
  232. }
  233. break;
  234. case 3:
  235. if (ch=='.'){
  236. pCtrCh++;
  237. state=7;
  238. }
  239. else if (ch=='e'|| ch=='E'){
  240. pCtrCh++;
  241. state=9;
  242.  
  243.  
  244. }
  245. else if (ch>='0' && ch<='7'){
  246. pCtrCh++;
  247. }
  248. else
  249.  
  250. state=6;
  251. break;
  252.  
  253. case 4:
  254. if (isalnum(ch)){
  255. pCtrCh++;
  256. state=5;
  257. }
  258. else
  259. tkerr(addTk(END),"caracter invalid");
  260. break;
  261. case 5:
  262. if (isalnum(ch)){
  263. pCtrCh++;
  264. }
  265. else
  266. state=6;
  267. break;
  268. case 6:
  269. tk=addTk(CT_INT);
  270. tk->i=atoi(createString(pStartCh,pCtrCh));
  271. return tk->code;
  272. // addTk(CT_INT);
  273. // return CT_INT;
  274. case 7:
  275. if (ch>='0' && ch<='9'){
  276.  
  277. pCtrCh++;
  278. state=8;
  279. }
  280. else
  281. tkerr(addTk(END),"caracter invalid");
  282. break;
  283. case 8:
  284. if (ch>='0' && ch<='9'){
  285. pCtrCh++;
  286. }
  287. else if (ch =='e' || ch =='E'){
  288. pCtrCh++;
  289. state=9;
  290. }
  291. else
  292. state = 12;
  293. break;
  294. case 9:
  295. if (ch =='+' || ch =='-'){
  296. pCtrCh++;
  297. state=10;
  298. }
  299. else
  300. state=10;
  301. break;
  302. case 10:
  303. if (ch>='0' && ch<='9'){
  304. pCtrCh++;
  305. state=11;
  306. }
  307. else
  308. tkerr(addTk(END),"caracter invalid");
  309. break;
  310. case 11:
  311. if (ch>='0' && ch<='9'){
  312. pCtrCh++;
  313. }
  314. else
  315. state=12;
  316. break;
  317. case 12:
  318. tk=addTk(CT_REAL);
  319. tk->r=strtod(createString(pStartCh,pCtrCh),NULL);
  320. return tk->code;
  321. // addTk(CT_REAL);
  322. // return CT_REAL;
  323. case 13:
  324. if (ch =='\\'){
  325. pCtrCh++;
  326. state=15;
  327. }
  328. else if (ch !='\'' && ch !='\\'){
  329. pCtrCh++;
  330. state=16;
  331. }
  332. else
  333. tkerr(addTk(END),"caracter invalid");
  334. break;
  335. case 15:
  336. if (ch =='a' || ch =='b' || ch =='f' || ch =='n' || ch =='r' || ch =='t' || ch =='v' || ch =='\'' || ch =='?' || ch =='"' || ch =='\0' || ch == '\\'){
  337. pCtrCh++;
  338. state=16;
  339. }
  340. else
  341. tkerr(addTk(END),"caracter invalid");
  342. break;
  343. case 16:
  344. if (ch =='\''){
  345. pCtrCh++;
  346. state=17;
  347. }
  348. else
  349. tkerr(addTk(END),"caracter invalid");
  350. break;
  351. case 17:
  352. tk=addTk(CT_CHAR);
  353. tk->i=createString(pStartCh,pCtrCh)[1];
  354. return tk->code;
  355. //addTk(CT_CHAR);
  356. //return CT_CHAR;
  357. case 18:
  358. if (ch =='\\'){
  359. pCtrCh++;
  360. state=20;
  361. }
  362. else if (ch !='"' && ch !='\\'){
  363. pCtrCh++;
  364.  
  365. state=21;
  366. }
  367. else if (ch == '"'){
  368. pCtrCh++;
  369. state=22;
  370. }
  371. else
  372. tkerr(addTk(END),"caracter invalid2");
  373. break;
  374. case 20:
  375. if (ch =='a' || ch =='b' || ch =='f' || ch =='n' || ch =='r' || ch =='t' || ch =='v' || ch =='\'' || ch =='?' || ch =='"' || ch =='\0'){
  376.  
  377. pCtrCh++;
  378.  
  379. state=21;
  380. }
  381. else
  382. tkerr(addTk(END),"caracter invalid3");
  383. break;
  384. case 21:
  385. if (ch =='"'){
  386. pCtrCh++;
  387. state=22;
  388. }
  389. else {
  390. // pCtrCh++;
  391. state=18;
  392.  
  393. }
  394. break;
  395. case 22:
  396. tk=addTk(CT_STRING);
  397. tk->text=createString(pStartCh,pCtrCh);
  398. return tk->code;
  399. // addTk(CT_STRING);
  400. // return CT_STRING;
  401. case 23:
  402. if (ch =='/'){
  403. pCtrCh++;
  404. state=27;
  405. }
  406. else if (ch =='*'){
  407. pCtrCh++;
  408. state=24;
  409. }
  410. else
  411. state=31;
  412. break;
  413. case 24:
  414. if (ch =='*'){
  415. pCtrCh++;
  416. state=25;
  417. }
  418. else if (ch !='*'){
  419. pCtrCh++;
  420. }
  421. else
  422. tkerr(addTk(END),"caracter1111 invalid");
  423. break;
  424. case 25:
  425. if (ch =='/'){
  426. pCtrCh++;
  427. state=0;
  428. }
  429. else if (ch =='*'){
  430. pCtrCh++;
  431. }
  432. else if (ch !='*' && ch!='/' ){
  433. pCtrCh++;
  434. state = 24;
  435. }
  436. else
  437. tkerr(addTk(END),"caracter2222 invalid");
  438. break;
  439. case 27:
  440. if (ch !='\n' && ch !='\r' && ch !='\0'){
  441. pCtrCh++;
  442. }
  443. else
  444. state = 0;
  445. break;
  446. case 29:
  447. if (isalnum(ch) || ch =='_'){
  448. pCtrCh++;
  449. }
  450. else
  451. state=30;
  452. break;
  453. case 30:
  454. nCh=pCtrCh-pStartCh;//lungimea cuvantului gasit
  455. //teste cuvinte cheie
  456. if(nCh==5 && !memcmp(pStartCh,"break",5))
  457. tk=addTk(BREAK);
  458. else if (nCh==4 && !memcmp(pStartCh,"char",4))
  459. tk=addTk(CHAR);
  460. else if (nCh==6 && !memcmp(pStartCh,"double",6))
  461. tk=addTk(DOUBLE);
  462. else if (nCh==4 && !memcmp(pStartCh,"else",4))
  463. tk=addTk(ELSE);
  464. else if (nCh==3 && !memcmp(pStartCh,"for",3))
  465. tk=addTk(FOR);
  466. else if (nCh==2 && !memcmp(pStartCh,"if",2))
  467. tk=addTk(IF);
  468. else if (nCh==3 && !memcmp(pStartCh,"int",3))
  469. tk=addTk(INT);
  470. else if (nCh==6 && !memcmp(pStartCh,"return",6))
  471. tk=addTk(RETURN);
  472. else if (nCh==6 && !memcmp(pStartCh,"struct",6))
  473. tk=addTk(STRUCT);
  474. else if (nCh==4 && !memcmp(pStartCh,"void",4))
  475. tk=addTk(VOID);
  476. else if (nCh==5 && !memcmp(pStartCh,"while",5))
  477. tk=addTk(WHILE);
  478. //... toate cuvintele cheie ...
  479. else { // daca nu este un cuvant cheie, atunci e un ID
  480. tk=addTk(ID);
  481. tk->text=createString(pStartCh,pCtrCh);
  482. }
  483. return tk->code;
  484. case 31:
  485. addTk(DIV);
  486. return DIV;
  487. case 32:
  488.  
  489. addTk(COMMA);
  490. return COMMA;
  491. case 33:
  492.  
  493. addTk(SEMICOLON);
  494. return SEMICOLON;
  495. case 34:
  496.  
  497. tk = addTk(LPAR);
  498. tk->text = 0;
  499. return tk->code;
  500. case 35:
  501.  
  502. addTk(RPAR);
  503. return RPAR;
  504. case 36:
  505.  
  506. addTk(LACC);
  507. return LACC;
  508. case 37:
  509.  
  510. addTk(RACC);
  511. return RACC;
  512. case 38:
  513.  
  514. addTk(LBRACKET);
  515. return LBRACKET;
  516. case 39:
  517.  
  518. addTk(RBRACKET);
  519. return RBRACKET;
  520. case 40:
  521.  
  522. addTk(ADD);
  523. return ADD;
  524. case 41:
  525.  
  526. addTk(SUB);
  527. return SUB;
  528. case 42:
  529. addTk(MUL);
  530. return MUL;
  531.  
  532. case 43:
  533. addTk(DOT);
  534. return DOT;
  535.  
  536. case 44:
  537. if (ch =='&'){
  538. pCtrCh++;
  539. state=45;
  540. }
  541. else
  542. tkerr(addTk(END),"caracter invalid");
  543. break;
  544. case 45:
  545.  
  546. addTk(AND);
  547. return AND;
  548. case 46:
  549. if (ch =='|'){
  550. pCtrCh++;
  551. state=47;
  552. }
  553. else
  554. tkerr(addTk(END),"caracter invalid");
  555. break;
  556. case 47:
  557.  
  558. addTk(OR);
  559. return OR;
  560. case 48:
  561. if (ch =='='){
  562. pCtrCh++;
  563. state=52;
  564. }
  565. else {
  566.  
  567. state=53;
  568. }
  569. break;
  570. case 49:
  571. if (ch =='='){
  572. pCtrCh++;
  573. state=54;
  574. }
  575. else {
  576.  
  577. state=55;
  578. }
  579. break;
  580. case 50:
  581. if (ch =='='){
  582. pCtrCh++;
  583. state=57;
  584. }
  585. else {
  586.  
  587. state=56;
  588. }
  589. break;
  590. case 51:
  591. if (ch =='='){
  592. pCtrCh++;
  593. state=58;
  594. }
  595. else {
  596.  
  597. state=59;
  598. }
  599. break;
  600. case 52:
  601.  
  602. addTk(EQUAL);
  603. return EQUAL;
  604. case 53:
  605.  
  606.  
  607. addTk(ASSIGN);
  608. return ASSIGN;
  609. case 54:
  610.  
  611. addTk(NOTEQ);
  612. return NOTEQ;
  613. case 55:
  614.  
  615. addTk(NOT);
  616. return NOT;
  617. case 56:
  618.  
  619. addTk(LESS);
  620. return LESS;
  621. case 57:
  622.  
  623. addTk(LESSEQ);
  624. return LESSEQ;
  625. case 58:
  626.  
  627. addTk(GREATEREQ);
  628. return GREATEREQ;
  629. case 59:
  630.  
  631. addTk(GREATER);
  632. return GREATER;
  633. }
  634. }
  635. }
  636.  
  637. // Analizator sintactic
  638.  
  639.  
  640.  
  641.  
  642.  
  643.  
  644.  
  645.  
  646.  
  647.  
  648.  
  649. int main(){
  650.  
  651. FILE *fis;
  652.  
  653. if ((fis=fopen("8.c","r"))==NULL){
  654. perror("citire fisier");
  655. exit(1);
  656. }
  657. else {
  658. int nc=fread(input,1,50000,fis);
  659. input[nc]='\0';
  660. pCtrCh=input;
  661. fclose(fis);
  662.  
  663.  
  664. while(getNextToken()!=END){}
  665. Token *tk;
  666. for(tk=tokens; tk->code != 42;tk=tk->next) {
  667. if (tk->code == ID)
  668. printf("%s : %s ", word[tk->code], tk->text);
  669. else if (tk->code == CT_STRING)
  670. printf("%s : %s ", word[tk->code], tk->text);
  671.  
  672. else if (tk->code == CT_CHAR)
  673. printf("%s : %c", word[tk->code], (int)tk->i);
  674. else if (tk->code == CT_INT)
  675. printf("%s : %ld ", word[tk->code], tk->i);
  676. else if (tk->code == CT_REAL)
  677. printf("%s : %f ", word[tk->code], tk->r);
  678. else
  679. printf("%s ", word[tk->code]);
  680. }
  681. printf("%s \n",word[tk->code]);
  682. }
  683.  
  684. printf("...");
  685. char *c = (char*)malloc(sizeof(char)*(6));
  686. snprintf(c, 8, "%s", "111\t\t222");
  687. printf("%s",c);
  688.  
  689. printf("...");
  690.  
  691. }
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!