API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 30th, 2020
120
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.19 KB | None | 0 0
raw download clone embed print report
  1. %{
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include "tabelas.h"
  6. #define YYDEBUG 1
  7. extern int yydebug;
  8. extern int numcolunas;
  9. extern int yylineno;
  10. extern int yyleng;
  11. extern int flagString;
  12. extern char s[500];
  13. extern char* yytext;
  14. noErro * erros=NULL;
  15. int contadorErros;
  16. int yylex(void);
  17. void yyerror (char *st);
  18.  
  19. int flagLex=0;
  20. int flagArvore=0;
  21. int flagErro=0;
  22. int flagSemantica=0;
  23. /* Inicializa tabela de símbolos global */
  24. elemento_tabelag *tg = NULL;
  25.  
  26. %}
  27. %union{
  28. char cval;
  29. int intval;
  30. char *string;
  31. double d;
  32. struct node *ponteiro;
  33. struct nodeAuxiliar *p;
  34. }
  35.  
  36.  
  37. %token <string> OR
  38. %token <string> AND
  39. %token <string> LT
  40. %token <string> GT
  41. %token <string> EQ
  42. %token <string> NE
  43. %token <string> LE
  44. %token <string> GE
  45. %token <string> PLUS
  46. %token <string> MINUS
  47. %token <string> STAR
  48. %token <string> DIV
  49. %token <string> MOD
  50. %token <string> NOT
  51. %token <string> INTLIT
  52. %token <string> REALLIT
  53. %token <p> ID
  54. %token <string> RESERVED
  55. %token <string> LPAR
  56. %token <string> RPAR
  57. %token <string> SEMICOLON
  58.  
  59. %token <string> RSQ
  60. %token <string> FOR
  61. %token <string> CMDARGS
  62. %token <string> BLANKID
  63. %token <string> FUNC
  64. %token <string> RBRACE
  65. %token <string> LSQ
  66. %token <string> ASSIGN
  67. %token <string> IF
  68. %token <string> RETURN
  69. %token <string> LBRACE
  70. %token <string> PARSEINT
  71. %token <string> COMMA
  72. %token <string> STRLIT
  73. %token <string> ELSE
  74. %token <string> PRINT
  75. %token <string> FLOAT32
  76. %token <string> STRING
  77. %token <string> BOOL
  78. %token <string> INT
  79. %token <string> PACKAGE
  80. %token <string> VAR
  81.  
  82. %token IFELSE
  83. /*
  84. vai ser preciso quase de certeza
  85.  
  86.  
  87.  
  88. %type <ponteiro> Program Declarations VarDeclaration VarSpec teste Type FuncDeclaration Parameters AuxParameters FuncBody VarsAndStatements Statement AuxStatement1 AuxStatement2 ParseArgs FuncInvocation AuxFuncInvocation Expr
  89. */
  90.  
  91. %type <ponteiro> Program Declarations VarDeclaration VarSpec teste Type FuncDeclaration Parameters AuxParameters FuncBody VarsAndStatements Statement AuxStatement1 ParseArgs FuncInvocation AuxFuncInvocation Expr
  92.  
  93.  
  94.  
  95.  
  96. %left COMMA
  97. %right ASSIGN
  98. %left OR
  99. %left AND
  100. %left GE GT LE LT EQ NE
  101. %left PLUS MINUS
  102. %left STAR DIV MOD
  103. %left NOT
  104. %left LPAR RPAR LBRACE RBRACE
  105. %nonassoc IFELSE
  106.  
  107.  
  108. %%
  109.  
  110.  
  111. Program: PACKAGE ID SEMICOLON Declarations {
  112. if($4!=NULL){
  113. $$=criaNoPai(Raiz,"Program");
  114. adicionaFilho2($$,$4);
  115. if(flagErro!=1&&flagArvore!=0){
  116.  
  117. imprimeTralha($$,0);
  118.  
  119.  
  120. }
  121.  
  122. }
  123. else{
  124. $$=criaNoPai(Raiz,"Program");
  125. if(flagErro!=1&&flagArvore!=0){
  126.  
  127. imprimeTralha($$,0);
  128.  
  129. }
  130.  
  131. }
  132.  
  133. criaTabelas($$);
  134. //anota
  135. if(flagSemantica==1){
  136.  
  137. if(erros==NULL){
  138. imprime_tabelaGlobal();
  139. imprimeASTanotada($$,0,0);
  140. }
  141.  
  142.  
  143. //createFile();
  144.  
  145. }
  146. //DeclaredNotUsed();
  147. imprimeListaErros(erros);
  148. }
  149. ;
  150.  
  151. Declarations: Declarations VarDeclaration SEMICOLON {
  152. if($1!=NULL){
  153. $$=$1;
  154. adicionaIrmao2($$,$2);
  155. }
  156. else{
  157. $$=$2;
  158. }
  159.  
  160. }
  161. | Declarations FuncDeclaration SEMICOLON {
  162.  
  163. if($1!=NULL){
  164. $$=$1;
  165. adicionaIrmao2($$,$2);
  166. }
  167. else{
  168. $$=$2;
  169. }
  170.  
  171.  
  172. }
  173. | /* empty */ {$$=NULL;}
  174. ;
  175.  
  176. VarDeclaration: VAR VarSpec {
  177. $$=$2;
  178. }
  179. | VAR LPAR VarSpec SEMICOLON RPAR {
  180. $$=$3;
  181. }
  182. ;
  183.  
  184. VarSpec: ID teste Type {
  185. if($2!=NULL){
  186. $$=adicionaIrmaoInicio($2,criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha));
  187. $$=juntarCenas($$,$3->string);
  188.  
  189.  
  190. }
  191. else{
  192. $$=criaNoPai(DecVariaveis,"VarDecl");
  193. adicionaFilho2($$,$3);
  194. adicionaIrmao2($$->filho,criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha));
  195. }
  196. };
  197. ;
  198.  
  199. teste: teste COMMA ID {
  200. if($1!=NULL){
  201. $$=$1;
  202. adicionaIrmao2($$,criaNoPai2(Terminal,juntaStrings("Id(",$3->string,")"),$3->coluna,$3->linha));
  203. }
  204. else{
  205. $$=criaNoPai2(Terminal,juntaStrings("Id(",$3->string,")"),$3->coluna,$3->linha);
  206. }
  207. }
  208. | /* empty */ {$$=NULL;}
  209. ;
  210.  
  211. Type: INT {$$=criaNoPai(Terminal,"Int");}
  212. | BOOL {$$=criaNoPai(Terminal,"Bool");}
  213. | STRING {$$=criaNoPai(Terminal,"String");}
  214. | FLOAT32 {$$=criaNoPai(Terminal,"Float32");}
  215. ;
  216.  
  217. FuncDeclaration: FUNC ID LPAR RPAR FuncBody {
  218. nodeDefault *aux,*aux2,*aux3;
  219. $$=criaNoPai(DecFuncoes,"FuncDecl");
  220. aux=criaNoPai(DecFuncoes,"FuncHeader");
  221. adicionaFilho2($$,aux);
  222. aux2=criaNoPai2(Terminal,juntaStrings("Id(",$2->string,")"),$2->coluna,$2->linha);
  223. adicionaFilho2(aux,aux2);
  224. aux3=criaNoPai(DecFuncoes,"FuncParams");
  225. adicionaIrmao2(aux->filho,aux3);
  226. adicionaIrmao2($$->filho,$5);
  227.  
  228. //elemento_tabelag* newel=insert_el($2, none);
  229. }
  230. | FUNC ID LPAR Parameters RPAR FuncBody {
  231. nodeDefault *aux,*aux2;
  232. $$=criaNoPai(DecFuncoes,"FuncDecl");
  233. aux=criaNoPai(DecFuncoes,"FuncHeader");
  234. adicionaFilho2($$,aux);
  235. aux2=criaNoPai2(Terminal,juntaStrings("Id(",$2->string,")"),$2->coluna,$2->linha);
  236. adicionaFilho2(aux,aux2);
  237. adicionaIrmao2(aux->filho,$4);
  238. adicionaIrmao2($$->filho,$6);
  239.  
  240. //elemento_tabelag* newel=insert_el($2, none);
  241. //insertTipos($2, $4);
  242. }
  243. | FUNC ID LPAR Parameters RPAR Type FuncBody {
  244. nodeDefault *aux,*aux2;
  245. $$=criaNoPai(DecFuncoes,"FuncDecl");
  246. aux=criaNoPai(DecFuncoes,"FuncHeader");
  247. adicionaFilho2($$,aux);
  248. aux2=criaNoPai2(Terminal,juntaStrings("Id(",$2->string,")"),$2->coluna,$2->linha);
  249. adicionaFilho2(aux,aux2);
  250. adicionaIrmao2(aux->filho,$6);
  251. adicionaIrmao2(aux->filho,$4);
  252. adicionaIrmao2($$->filho,$7);
  253. }
  254. | FUNC ID LPAR RPAR Type FuncBody {
  255. nodeDefault *aux,*aux2;
  256. $$=criaNoPai(DecFuncoes,"FuncDecl");
  257. aux=criaNoPai(DecFuncoes,"FuncHeader");
  258. adicionaFilho2($$,aux);
  259. aux2=criaNoPai2(Terminal,juntaStrings("Id(",$2->string,")"),$2->coluna,$2->linha);
  260. adicionaFilho2(aux,aux2);
  261.  
  262. adicionaIrmao2(aux->filho,$5);//dar double checkkkkk
  263.  
  264. adicionaIrmao2($$->filho,$6);
  265. adicionaIrmao2(aux->filho,criaNoPai(DecFuncoes,"FuncParams"));
  266. }
  267. ;
  268. Parameters: ID Type AuxParameters {
  269. if ($3!=NULL){
  270. nodeDefault *aux1,*aux2;
  271. aux1=criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha);
  272. aux2=criaNoPai(DecFuncoes,"ParamDecl");
  273. adicionaFilho2(aux2,$2);
  274. adicionaIrmao2(aux2->filho,aux1);
  275. adicionaIrmaoInicio($3,aux2);
  276. $$=criaNoPai(DecFuncoes,"FuncParams");
  277. adicionaFilho2($$,aux2);
  278.  
  279.  
  280.  
  281. }
  282. else{
  283. nodeDefault *aux1,*aux2;
  284. aux1=criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha);
  285. aux2=criaNoPai(DecFuncoes,"ParamDecl");
  286. adicionaFilho2(aux2,$2);
  287. adicionaIrmao2(aux2->filho,aux1);
  288. $$=criaNoPai(DecFuncoes,"FuncParams");
  289. adicionaFilho2($$,aux2);
  290. }
  291. }
  292. ;
  293.  
  294. AuxParameters: AuxParameters COMMA ID Type {
  295. if($1!=NULL){
  296. $$=$1;
  297. nodeDefault *aux1,*aux2;
  298. aux1=criaNoPai2(Terminal,juntaStrings("Id(",$3->string,")"),$3->coluna,$3->linha);
  299. aux2=criaNoPai(DecFuncoes,"ParamDecl");
  300. adicionaFilho2(aux2,$4);
  301. adicionaIrmao2(aux2->filho,aux1);
  302. adicionaIrmao2($$,aux2);
  303. }
  304. else{
  305. nodeDefault *aux1,*aux2;
  306. aux1=criaNoPai2(Terminal,juntaStrings("Id(",$3->string,")"),$3->coluna,$3->linha);
  307. aux2=criaNoPai(DecFuncoes,"ParamDecl");
  308. adicionaFilho2(aux2,$4);
  309. adicionaIrmao2(aux2->filho,aux1);
  310. $$=aux2;
  311. }
  312. }
  313. | /* empty */ {$$=NULL;}
  314. ;
  315.  
  316. FuncBody: LBRACE VarsAndStatements RBRACE {
  317. if($2!=NULL){
  318.  
  319. $$=criaNoPai(DecFuncoes,"FuncBody");
  320. adicionaFilho2($$,$2);
  321. }
  322. else{
  323. $$=criaNoPai(DecFuncoes,"FuncBody");
  324. }
  325. }
  326. ;
  327.  
  328. VarsAndStatements: VarsAndStatements SEMICOLON {
  329. if ($1!=NULL){
  330. $$=$1;
  331. }
  332. else{
  333. $$=NULL;
  334. }
  335. }
  336. | VarsAndStatements VarDeclaration SEMICOLON {
  337. if($1!=NULL){
  338. $$=$1;
  339. adicionaIrmao2($1,$2);
  340. }
  341. else{
  342. $$=$2;
  343. }
  344. }
  345. | VarsAndStatements Statement SEMICOLON {
  346. if($1!=NULL){
  347. $$=$1;
  348. adicionaIrmao2($1,$2);
  349. }
  350. else{
  351. $$=$2;
  352. }
  353. }
  354. | /* empty */ {$$=NULL;}
  355. ;
  356.  
  357. Statement: PRINT LPAR Expr RPAR {$$=criaNoPai(Statements,"Print");adicionaFilho2($$,$3);}
  358. | PRINT LPAR STRLIT RPAR {$$=criaNoPai(Statements,"Print");adicionaFilho2($$,criaNoPai(Terminal,juntaStrings("StrLit(\"",$3,"\")")));}
  359. | error {$$=NULL;}
  360. | FuncInvocation {$$=$1;}
  361. | ParseArgs {$$=$1;}
  362. | RETURN {$$=criaNoPai(Statements,"Return");}
  363. | RETURN Expr {$$=criaNoPai(Statements,"Return");adicionaFilho2($$,$2);}
  364. | FOR Expr LBRACE AuxStatement1 RBRACE {
  365.  
  366. if($4!=NULL){
  367. nodeDefault *aux;
  368. $$=criaNoPai(Statements,"For");
  369. adicionaFilho2($$,$2);
  370. aux=criaNoPai(Statements,"Block");
  371. adicionaFilho2(aux,$4);
  372. adicionaIrmao2($$->filho,aux);
  373. }
  374. else{
  375. nodeDefault *aux;
  376. $$=criaNoPai(Statements,"For");
  377. adicionaFilho2($$,$2);
  378. aux=criaNoPai(Statements,"Block");
  379. adicionaIrmao2($$->filho,aux);
  380. }
  381.  
  382. }
  383. | FOR LBRACE AuxStatement1 RBRACE {
  384. if($3!=NULL){
  385. nodeDefault *aux;
  386. $$=criaNoPai(Statements,"For");
  387. aux=criaNoPai(Statements,"Block");
  388. adicionaFilho2(aux,$3);
  389. adicionaFilho2($$,aux);
  390. }
  391. else{
  392. nodeDefault *aux;
  393. $$=criaNoPai(Statements,"For");
  394. aux=criaNoPai(Statements,"Block");
  395. adicionaFilho2($$,aux);
  396. }
  397. }
  398. | ID ASSIGN Expr {
  399. $$=criaNoPai(Operadores,"Assign");
  400. adicionaFilho2($$,criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha));
  401. adicionaIrmao2($$->filho,$3);
  402. }
  403. | IF Expr LBRACE AuxStatement1 RBRACE {
  404. if($4!=NULL){
  405. nodeDefault *aux;
  406. $$=criaNoPai(Statements,"If");
  407. adicionaFilho2($$,$2);
  408. aux=criaNoPai(Statements,"Block");
  409. adicionaFilho2(aux,$4);
  410. adicionaIrmao2($$->filho,aux);
  411. adicionaIrmao2($$->filho,criaNoPai(Statements,"Block"));
  412. }
  413. else{
  414. nodeDefault *aux;
  415. $$=criaNoPai(Statements,"If");
  416. adicionaFilho2($$,$2);
  417. aux=criaNoPai(Statements,"Block");
  418. adicionaIrmao2($$->filho,aux);
  419. adicionaIrmao2($$->filho,criaNoPai(Statements,"Block"));
  420. }
  421. }
  422. | IF Expr LBRACE AuxStatement1 RBRACE ELSE LBRACE AuxStatement1 RBRACE %prec IFELSE{
  423. //NENHUM NULL
  424. if($4!=NULL && $8!=NULL){
  425. nodeDefault *aux,*aux2;
  426. $$=criaNoPai(Statements,"If");
  427. adicionaFilho2($$,$2);
  428. aux=criaNoPai(Statements,"Block");
  429. adicionaFilho2(aux,$4);
  430. adicionaIrmao2($$->filho,aux);
  431. aux2=criaNoPai(Statements,"Block");
  432. adicionaIrmao2($$->filho,aux2);
  433. adicionaFilho2(aux2,$8);
  434. }
  435. // $4 NULL E $8 NÃO NULL
  436. if($4==NULL && $8!=NULL){
  437. nodeDefault *aux,*aux2;
  438. $$=criaNoPai(Statements,"If");
  439. adicionaFilho2($$,$2);
  440. aux=criaNoPai(Statements,"Block");
  441. adicionaIrmao2($$->filho,aux);
  442. aux2=criaNoPai(Statements,"Block");
  443. adicionaIrmao2($$->filho,aux2);
  444. adicionaFilho2(aux2,$8);
  445. }
  446. // $4 NÃO NULL E $8 NULL
  447. if($4!=NULL && $8==NULL){
  448. nodeDefault *aux,*aux2;
  449. $$=criaNoPai(Statements,"If");
  450. adicionaFilho2($$,$2);
  451. aux=criaNoPai(Statements,"Block");
  452. adicionaFilho2(aux,$4);
  453. adicionaIrmao2($$->filho,aux);
  454. aux2=criaNoPai(Statements,"Block");
  455. adicionaIrmao2($$->filho,aux2);
  456. }
  457. // $4 NULL E $8 NULL
  458. if($4==NULL && $8==NULL){
  459. nodeDefault *aux,*aux2;
  460. $$=criaNoPai(Statements,"If");
  461. adicionaFilho2($$,$2);
  462. aux=criaNoPai(Statements,"Block");
  463. adicionaIrmao2($$->filho,aux);
  464. aux2=criaNoPai(Statements,"Block");
  465. adicionaIrmao2($$->filho,aux2);
  466. }
  467.  
  468. }
  469. | LBRACE AuxStatement1 RBRACE { /* Dúvida */
  470. if($2!=NULL){
  471. if(contaIrmao($2)>1){ // Se for maior ou igual a 2 cria Block
  472. $$=criaNoPai(Statements,"Block");
  473. adicionaFilho2($$,$2);
  474.  
  475. }
  476. else{ // Caso contrário não cria, mas não é preciso adicionar também?
  477. $$=$2;
  478. }
  479. }
  480. else{
  481. $$=NULL;
  482. }
  483. }
  484. ;
  485.  
  486. AuxStatement1: AuxStatement1 Statement SEMICOLON {
  487. if($1!=NULL){
  488. $$=adicionaIrmao2($1,$2);// vai receber o irmao à esquerda do novo
  489. }
  490. else{
  491. $$=$2;
  492. }
  493. }
  494. | /* empty */ {$$=NULL;}
  495. ;
  496.  
  497. ParseArgs: ID COMMA BLANKID ASSIGN PARSEINT LPAR CMDARGS LSQ Expr RSQ RPAR {
  498. $$=criaNoPai(Statements,"ParseArgs");
  499. adicionaFilho2($$,criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha));
  500. adicionaIrmao2($$->filho,$9);
  501. }
  502. | ID COMMA BLANKID ASSIGN PARSEINT LPAR error RPAR {$$=NULL;}
  503. ;
  504.  
  505. FuncInvocation: ID LPAR error RPAR {$$=NULL;}
  506. | ID LPAR RPAR {$$=criaNoPai(Statements,"Call");adicionaFilho2($$,criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha));} /* Não sabemos o Type a pôr aqui */
  507. | ID LPAR Expr AuxFuncInvocation RPAR {
  508. if($4!=NULL){
  509. $$=criaNoPai(Statements,"Call");
  510. adicionaFilho2($$,criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha));
  511. adicionaIrmao2($3,$4);
  512. adicionaIrmao2($$->filho,$3);
  513. }
  514. else{
  515. nodeDefault *aux;
  516. aux=criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha);
  517. $$=criaNoPai(Statements,"Call");
  518. adicionaIrmao2(aux,$3);
  519. adicionaFilho2($$,aux);
  520. }
  521. }
  522. ;
  523.  
  524.  
  525. AuxFuncInvocation: AuxFuncInvocation COMMA Expr {if($1!=NULL){$$=$1;adicionaIrmao2($1,$3);}else{$$=$3;}}
  526. | /* empty */ {$$=NULL;}
  527. ;
  528.  
  529. Expr: Expr OR Expr {$$=criaNoPai(Operadores,"Or");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  530. | ID {$$=criaNoPai2(Terminal,juntaStrings("Id(",$1->string,")"),$1->coluna,$1->linha);}
  531. | REALLIT {$$=criaNoPai(Terminal,juntaStrings("RealLit(",$1,")"));}
  532. | INTLIT {$$=criaNoPai(Terminal,juntaStrings("IntLit(",$1,")"));}
  533. | Expr AND Expr {$$=criaNoPai(Operadores,"And");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  534. | Expr PLUS Expr {$$=criaNoPai(Operadores,"Add");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  535. | Expr LT Expr {$$=criaNoPai(Operadores,"Lt");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  536. | Expr MINUS Expr {$$=criaNoPai(Operadores,"Sub");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  537. | Expr GT Expr {$$=criaNoPai(Operadores,"Gt");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  538. | Expr MOD Expr {$$=criaNoPai(Operadores,"Mod");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  539. | Expr DIV Expr {$$=criaNoPai(Operadores,"Div");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  540. | Expr GE Expr {$$=criaNoPai(Operadores,"Ge");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  541. | Expr STAR Expr {$$=criaNoPai(Operadores,"Mul");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  542. | Expr EQ Expr {$$=criaNoPai(Operadores,"Eq");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  543. | Expr NE Expr {$$=criaNoPai(Operadores,"Ne");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  544. | Expr LE Expr {$$=criaNoPai(Operadores,"Le");adicionaFilho2($$,$1);adicionaIrmao2($$->filho,$3);}
  545. | LPAR Expr RPAR {$$=$2;}
  546. | MINUS Expr %prec STAR {$$=criaNoPai(Operadores,"Minus");adicionaFilho2($$,$2);}
  547. | PLUS Expr %prec STAR {$$=criaNoPai(Operadores,"Plus");adicionaFilho2($$,$2);}
  548. | NOT Expr %prec STAR {$$=criaNoPai(Operadores,"Not");adicionaFilho2($$,$2);}
  549. | FuncInvocation {$$=$1;}
  550. | LPAR error RPAR {$$=NULL;}
  551. ;
  552.  
  553.  
  554.  
  555. %%
  556.  
  557.  
  558.  
  559. void yyerror (char *st) {
  560. flagErro=1;
  561. if(flagString==0){
  562.  
  563. printf ("Line %d, column %d: %s: %s\n", yylineno, numcolunas-(int)strlen(yytext), st, yytext);
  564.  
  565. }
  566. else{
  567.  
  568. printf ("Line %d, column %d: %s: \"%s\"\n", yylineno, numcolunas-(int)strlen(s)-2, st, s);
  569. flagString=0;
  570. }
  571.  
  572. }
  573.  
  574. char * juntaStrings(char *tipo,char *valor, char *parenteses){
  575. char *aux;
  576. aux = (char*)malloc(sizeof(char)*300);
  577. strcpy(aux,tipo);
  578. strcat(aux,valor);
  579. strcat(aux, parenteses);
  580.  
  581. return aux;
  582. }
  583. nodeDefault * criaNoPai(nodeType tipo, char *str){
  584. nodeDefault *ponteiro;
  585. if ((ponteiro=malloc(sizeof(nodeDefault)))== NULL)
  586. printf("Estoirou!\n");
  587. ponteiro->filho=NULL;
  588. ponteiro->irmao=NULL;
  589. ponteiro->string=str;
  590. ponteiro->tipo=tipo;
  591. ponteiro->tipos=NULL;
  592. ponteiro->linha=yylineno;
  593. ponteiro->coluna=numcolunas-yyleng;
  594. return ponteiro;
  595. }
  596.  
  597. nodeDefault * criaNoPai2(nodeType tipo, char *str,int coluna,int linha){
  598. nodeDefault *ponteiro;
  599. if ((ponteiro=malloc(sizeof(nodeDefault)))== NULL)
  600. printf("Estoirou!\n");
  601. ponteiro->filho=NULL;
  602. ponteiro->irmao=NULL;
  603. ponteiro->string=str;
  604. ponteiro->tipo=tipo;
  605. ponteiro->tipos=NULL;
  606. ponteiro->linha=linha;
  607. ponteiro->coluna=coluna;
  608. return ponteiro;
  609. }
  610. nodeDefault * adicionaFilho(nodeDefault * pai,nodeType tipo, char *str){
  611. nodeDefault *novo;
  612. novo=criaNoPai(tipo, str);
  613. pai->filho=novo;
  614. return novo;
  615. }
  616.  
  617. nodeDefault * adicionaIrmao(nodeDefault * atual,nodeType tipo, char *str){
  618. //Temos de adicionar no mais à direita
  619. nodeDefault *novo;
  620. nodeDefault *iterador;
  621. iterador=atual;
  622. while(iterador->irmao!=NULL){
  623. iterador=iterador->irmao;
  624. }
  625. novo=criaNoPai(tipo, str);
  626. iterador->irmao=novo;
  627. return novo;
  628. }
  629.  
  630.  
  631. int imprimeTralha(nodeDefault *raiz,int depth){
  632. nodeDefault *iterador;
  633. int i;
  634. for(i=0;i<depth;i++){
  635. printf("..");
  636. }
  637. printf("%s\n",raiz->string);
  638. //printf("%s %d %d\n",raiz->string,raiz->linha,raiz->coluna);
  639. if(raiz->filho!=NULL){
  640. imprimeTralha(raiz->filho,depth+1);
  641. iterador=raiz->filho->irmao;
  642. while(iterador!=NULL){
  643. imprimeTralha(iterador,depth+1);
  644. iterador=iterador->irmao;
  645. }
  646. }
  647.  
  648. return 0;
  649.  
  650. }
  651. nodeDefault * adicionaIrmao2(nodeDefault * atual,nodeDefault *novo){
  652. nodeDefault *iterador;
  653. iterador=atual;
  654. while(iterador->irmao!=NULL){
  655. iterador=iterador->irmao;
  656. }
  657. iterador->irmao=novo;
  658.  
  659.  
  660. return atual;
  661. }
  662. nodeDefault * adicionaFilho2(nodeDefault * pai,nodeDefault *novo){
  663. pai->filho=novo;
  664. return novo;
  665. }
  666.  
  667. nodeDefault * adicionaIrmaoInicio(nodeDefault * atual,nodeDefault *novo){
  668. //Temos de adicionar no inicio
  669. novo->irmao=atual;
  670. return novo;
  671. }
  672. nodeDefault * juntarCenas(nodeDefault * alvo,char* string){
  673. //Temos de adicionar no inicios
  674. nodeDefault *final,*iterador,*aux;
  675. iterador=alvo;
  676. final=criaNoPai(DecVariaveis,"VarDecl");
  677. adicionaFilho2(final,criaNoPai(Terminal,string));
  678. adicionaIrmao2(final->filho,criaNoPai2(Terminal,alvo->string,alvo->coluna,alvo->linha));
  679. iterador=iterador->irmao;
  680. while(iterador!=NULL){
  681. aux=criaNoPai(DecVariaveis,"VarDecl");
  682. adicionaFilho2(aux,criaNoPai(Terminal,string));
  683. adicionaIrmao2(aux->filho,criaNoPai2(Terminal,iterador->string,iterador->coluna,iterador->linha));
  684.  
  685. adicionaIrmao2(final,aux);
  686. iterador=iterador->irmao;
  687.  
  688. }
  689.  
  690.  
  691. return final;
  692. }
  693.  
  694.  
  695. int contaIrmao(nodeDefault * alvo){
  696. nodeDefault * iterador;
  697. int sum=1;
  698. iterador=alvo;
  699. while(iterador->irmao!=NULL){
  700. sum++;
  701. iterador=iterador->irmao;
  702.  
  703. }
  704. return sum;
  705.  
  706. }
  707.  
  708.  
  709. int main(int argc, char **argv) {
  710. /*
  711. yydebug=1;
  712. */
  713. contadorErros=0;
  714. if(argc>1){
  715. if (strcmp(argv[1],"-l")==0){
  716. flagArvore=0;
  717. flagLex=1;
  718. while(yylex()){
  719.  
  720. }
  721. }
  722. else{
  723. if (strcmp(argv[1],"-t")==0){
  724. flagArvore=1;
  725. flagLex=0;
  726. yyparse();
  727. }
  728. if (strcmp(argv[1],"-s")==0){
  729. flagArvore=0;
  730. flagLex=0;
  731. flagSemantica=1;
  732. yyparse();
  733. }
  734. }
  735.  
  736. }
  737. else{
  738. yyparse();
  739. flagArvore=0;
  740. //imprime_tabelaGlobal();
  741. }
  742. return 0;
  743. }
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!