CES-41 COMPILADORES Aulas Práticas - 2014 Capítulo III Análise Semântica no Yacc.

CES-41 CES-41 COMPILADORESCOMPILADORES

Aulas Práticas - 2014Aulas Práticas - 2014

Capítulo III Capítulo III Análise Semântica Análise Semântica

no Yaccno Yacc

Neste capítulo, será vista a Neste capítulo, será vista a construção da construção da tabela de símbolostabela de símbolos e a e a análise semânticaanálise semântica para linguagens de programaçãopara linguagens de programação

A tabela de símbolos é fundamental para A tabela de símbolos é fundamental para análise semânticaanálise semântica e para geração do e para geração do código código intermediáriointermediário

Além disso pode ser devidamente aproveitada Além disso pode ser devidamente aproveitada durante a durante a interpretaçãointerpretação e a construção do e a construção do código objetocódigo objeto

A A complexidadecomplexidade das linguagens pode ser abordada das linguagens pode ser abordada progressivamente:progressivamente:

1.1. Inicialmente sem subprogramas, só Inicialmente sem subprogramas, só variáveis variáveis escalaresescalares e e comandos de atribuiçãocomandos de atribuição

2.2. Acrescenta-se Acrescenta-se comandos condicionaiscomandos condicionais, , repetitivosrepetitivos e de e de entrada e saídaentrada e saída

3.3. Acrescenta-se Acrescenta-se variáveis indexadasvariáveis indexadas

4.4. Acrescenta-se Acrescenta-se subprogramassubprogramas e e variáveis variáveis globaisglobais

5.5. Acrescenta-se Acrescenta-se blocosblocos e e aninhamento de aninhamento de subprogramassubprogramas

6.6. Acrescenta-se Acrescenta-se estruturas estruturas e e ponteirosponteiros, etc., etc.

Abordagem do projeto

Estrutura de dados para a tabela de símbolos:Estrutura de dados para a tabela de símbolos:

Será usada a estrutura de Será usada a estrutura de hashing abertohashing aberto

FunçãoFunção para o para o hashinghashing::

Onde: Onde: – NCLASSHASHNCLASSHASH é o é o número de classesnúmero de classes..– nn é o número de caracteres de é o número de caracteres de x x (sem o (sem o ‘\‘\0’0’))

Exemplo: Tabela de símbolos (hashing) do programa do fatorial (NCLASSHASH = 23)

Declarações para a tabela de símbolos:

typedef struct celsimb celsimb;typedef celsimb *simbolo;struct celsimb {

char *cadeia;int tid, tvar;logic inic, ref;simbolo prox;

};

Variáveis globais:

simbolo simb;simbolo tabsimb[NCLASSHASH];

Programa 3.1: Programa 3.1: gramática sem subprogramas, só gramática sem subprogramas, só variáveis escalares e comandos de atribuiçãovariáveis escalares e comandos de atribuição

A gramática a seguir é uma A gramática a seguir é uma simplificaçãosimplificação daquela da linguagem daquela da linguagem COMP-ITA 2014COMP-ITA 2014

Seja ela chamada de Seja ela chamada de Sub-Set 2014Sub-Set 2014

ProgProg :: programprogram IDID LocDecls Stats LocDecls StatsLocDecls LocDecls :: | | locallocal { { DeclList DeclList }}DeclListDeclList :: Declaration | DeclList DeclarationDeclaration | DeclList DeclarationDeclaration Declaration :: Type ElemList Type ElemList ;; TypeType : : intint | | float float | | char char | | logiclogicElemList ElemList :: Elem | ElemList Elem | ElemList ,, Elem ElemElem Elem :: IDIDStats Stats : : statementsstatements CompStat CompStatCompStatCompStat : : { { StatList StatList }}StatListStatList :: | StatList Statement| StatList StatementStatement Statement : : CompStat | AssignStatCompStat | AssignStatAssignStat AssignStat : : Variable Variable == Expression Expression ;;

Elem:

Não-terminal prevendo variáveis indexadas

Expression Expression : : AuxExpr1 | Expression AuxExpr1 | Expression |||| AuxExpr1AuxExpr1

AuxExpr1 AuxExpr1 : : AuxExpr2 | AuxExpr1 AuxExpr2 | AuxExpr1 &&&& AuxExpr2AuxExpr2

AuxExpr2 AuxExpr2 : : AuxExpr3 | AuxExpr3 | !! AuxExpr3 AuxExpr3AuxExpr3 AuxExpr3 : : AuxExpr4 | AuxExpr4 AuxExpr4 | AuxExpr4 RELOPRELOP

AuxExpr4AuxExpr4AuxExpr4 AuxExpr4 :: Term | AuxExpr4 Term | AuxExpr4 ADOPADOP Term TermTerm Term : : Factor | Term Factor | Term MULTOPMULTOP Factor FactorFactorFactor : : Variable | Variable | INTCTINTCT | | FLOATCTFLOATCT

| | CHARCTCHARCT | | truetrue | | falsefalse | | ~~ FactorFactor

| | ( ( Expression Expression ))VariableVariable : : IDID

Variable:

Não-terminal prevendo variáveis indexadas

A seguir A seguir 3 arquivos3 arquivos fornecidos na aba de fornecidos na aba de ‘Códigos’‘Códigos’ da página do professor: da página do professor:

tsimb012014.y tsimb012014.y (analisador sintático)(analisador sintático) tsimb012014.l tsimb012014.l (analisador léxico) (analisador léxico) tsimb012014.dat tsimb012014.dat (programa a ser (programa a ser

analisado)analisado)

O primeiro deles contém O primeiro deles contém declaraçõesdeclarações e e funçõesfunções para montagem de uma para montagem de uma tabela de tabela de símbolossímbolos

Depois da sua Depois da sua apresentaçãoapresentação, seguem , seguem orientaçõesorientações para a para a montagem montagem da tabelada tabela

a) Arquivo tsimb012014.ya) Arquivo tsimb012014.y

%{%{

/* Inclusao de arquivos da biblioteca de C /* Inclusao de arquivos da biblioteca de C */*/

#include <stdio.h>#include <stdio.h>#include <stdlib.h>#include <stdlib.h>#include <string.h>#include <string.h>

/* /* Definicao dos atributos dos atomos operadores Definicao dos atributos dos atomos operadores */*/

#define #define LT LT 11#define #define LE LE 22#define#define GTGT 33#define#define GEGE 44#define#define EQEQ 55#define#define NENE 66#define#define MAIS MAIS 77#define#define MENOS MENOS 88#define#define MULT MULT 99#define#define DIV DIV 1010#define#define RESTO RESTO 1111

/* Definicao dos tipos de identificadores *//* Definicao dos tipos de identificadores */

#define #define IDPROGIDPROG 11#define #define IDVARIDVAR 22

/* Definicao dos tipos de variaveis *//* Definicao dos tipos de variaveis */

#define #define NAOVARNAOVAR 00#define #define INTEIROINTEIRO 11#define #define LOGICOLOGICO 22#define #define REALREAL 33#define #define CARACTERECARACTERE 44

/* Definicao de outras constantes *//* Definicao de outras constantes */

#define#define NCLASSHASHNCLASSHASH 2323#define#define VERDADEVERDADE 11#define#define FALSOFALSO 00

Para o caso de não ser um identificador de variável

/* Strings para nomes dos tipos de identificadores /* Strings para nomes dos tipos de identificadores */*/

char *nometipid[3] = {" ", "IDPROG", "IDVAR"};char *nometipid[3] = {" ", "IDPROG", "IDVAR"};

/* Strings para nomes dos tipos de variaveis *//* Strings para nomes dos tipos de variaveis */

char *nometipvar[5] = {"NAOVAR",char *nometipvar[5] = {"NAOVAR","INTEIRO", "LOGICO", "REAL", "CARACTERE""INTEIRO", "LOGICO", "REAL", "CARACTERE"

};};A serem usadas na função para escrever na tela a tabela de símbolos (ImprimeTabSimb)

/* Declaracoes para a tabela de simbolos *//* Declaracoes para a tabela de simbolos */

typedef struct celsimb celsimb;typedef struct celsimb celsimb;typedef celsimb *simbolo;typedef celsimb *simbolo;struct celsimb {struct celsimb {

char *cadeia;char *cadeia;int tid, tvar;int tid, tvar;char inic, ref;char inic, ref;simbolo prox;simbolo prox;

};};

/* Variaveis globais para a tabela de simbolos e /* Variaveis globais para a tabela de simbolos e analise semanticaanalise semantica

*/*/

simbolo tabsimb[NCLASSHASH];simbolo tabsimb[NCLASSHASH];simbolo simb;simbolo simb;

/*/*Prototipos das funcoes para a tabela de Prototipos das funcoes para a tabela de simbolossimbolos

e analise semanticae analise semantica */*/

void InicTabSimb (void);void InicTabSimb (void);void ImprimeTabSimb (void);void ImprimeTabSimb (void);simbolo InsereSimb (char *, int, int);simbolo InsereSimb (char *, int, int);int hash (char *);int hash (char *);simbolo ProcuraSimb (char *);simbolo ProcuraSimb (char *);void DeclaracaoRepetida (char *);void DeclaracaoRepetida (char *);void TipoInadequado (char *);void TipoInadequado (char *);void NaoDeclarado (char *);void NaoDeclarado (char *);%}%}

/* Definicao do tipo de yylval e dos atributos dos nao /* Definicao do tipo de yylval e dos atributos dos nao terminais */terminais */

%union {%union {char cadeia[50];char cadeia[50];int atr, valint;int atr, valint;float valreal;float valreal;char carac;char carac;

}}

/* Declaracao dos atributos dos tokens e dos nao-/* Declaracao dos atributos dos tokens e dos nao-terminais */terminais */

%token%token <cadeia><cadeia> IDID%token%token <carac><carac> CHARCTCHARCT%token%token <valint><valint> INTCTINTCT%token%token <valreal><valreal> FLOATCTFLOATCT%token%token OROR%token%token ANDAND%token%token NOTNOT%token%token <atr><atr> RELOPRELOP%token%token <atr><atr> ADOPADOP%token%token <atr><atr> MULTOPMULTOP%token%token NEGNEG

%token%token OPPAROPPAR%token%token CLPARCLPAR%token%token OPBRACEOPBRACE%token%token CLBRACECLBRACE%token%token COMMACOMMA%token%token SCOLONSCOLON%token%token ASSIGNASSIGN%token %token CHARCHAR%token %token FALSEFALSE%token %token FLOATFLOAT%token %token INT INT%token %token LOCALLOCAL%token %token LOGICLOGIC%token %token PROGRAMPROGRAM%token %token STATEMENTSSTATEMENTS%token %token TRUETRUE%token%token <carac> <carac> INVALINVAL%%%%

/* /* Producoes da gramatica:Producoes da gramatica:Os terminais sao escritos e, depois de alguns,Os terminais sao escritos e, depois de alguns,para alguma estetica, ha mudanca de linha para alguma estetica, ha mudanca de linha */*/

ProgProg :: PROGRAM ID PROGRAM ID {printf ("program %s\n", $2);}{printf ("program %s\n", $2);}LocDecls StatsLocDecls Stats

;;LocDecls LocDecls ::

|| LOCAL OPBRACE {printf ("local {\n");}LOCAL OPBRACE {printf ("local {\n");} DeclList CLBRACE {printf ("}\n");}DeclList CLBRACE {printf ("}\n");} ;;DeclListDeclList :: Declaration | DeclList DeclarationDeclaration | DeclList Declaration ;;

Declaration Declaration :: Type ElemList SCOLON Type ElemList SCOLON {printf (";\n");}{printf (";\n");}

;;TypeType : : INT {printf ("int ");}INT {printf ("int ");}

|| FLOAT {printf ("float ");}FLOAT {printf ("float ");} | | CHAR {printf ("char ");}CHAR {printf ("char ");} | | LOGIC {printf ("logic ");}LOGIC {printf ("logic ");} ;;ElemList ElemList :: ElemElem

|| ElemList COMMA {printf (", ElemList COMMA {printf (", ");} Elem");} Elem

;;Elem Elem :: ID {printf ("%s ", $1);}ID {printf ("%s ", $1);} ;;

Stats Stats : : STATEMENTS {printf STATEMENTS {printf ("statements ");} ("statements ");} CompStatCompStat

;;CompStatCompStat : : OPBRACE {printf ("{\n");} OPBRACE {printf ("{\n");}

StatList StatList CLBRACE CLBRACE {printf ("}\n");}{printf ("}\n");}

;;StatListStatList ::

| | StatList StatementStatList Statement ;;Statement Statement : : CompStatCompStat | | AssignStatAssignStat ;;AssignStat AssignStat : : Variable ASSIGN {printf ("= ");} Variable ASSIGN {printf ("= ");}

Expression SCOLON {printf (";\n");}Expression SCOLON {printf (";\n");} ;;

Expression Expression : : AuxExpr1AuxExpr1| | Expression OR {printf ("|| ");} Expression OR {printf ("|| ");}

AuxExpr1AuxExpr1 ;;AuxExpr1 AuxExpr1 : : AuxExpr2AuxExpr2

| | AuxExpr1 AND {printf ("&& AuxExpr1 AND {printf ("&& ");} AuxExpr2");} AuxExpr2

;;AuxExpr2 AuxExpr2 : : AuxExpr3AuxExpr3

| | NOT {printf ("! ");} AuxExpr3NOT {printf ("! ");} AuxExpr3 ;;

AuxExpr3 AuxExpr3 : : AuxExpr4AuxExpr4| | AuxExpr4 RELOP {AuxExpr4 RELOP {

switch ($2) {switch ($2) { case LT: printf ("< "); break;case LT: printf ("< "); break; case LE: printf ("<= "); break;case LE: printf ("<= "); break; case EQ: printf ("== "); break;case EQ: printf ("== "); break; case NE: printf ("!= "); break;case NE: printf ("!= "); break; case GT: printf ("> "); break;case GT: printf ("> "); break; case GE: printf (">= "); break;case GE: printf (">= "); break; }} } AuxExpr4} AuxExpr4 ;;

AuxExpr4 AuxExpr4 : : TermTerm| | AuxExpr4 ADOP {AuxExpr4 ADOP {

switch ($2) {switch ($2) { case MAIS: printf ("+ "); break;case MAIS: printf ("+ "); break; case MENOS: printf ("- "); break;case MENOS: printf ("- "); break; }} } Term} Term ;;Term Term : : FactorFactor

| | Term MULTOP {Term MULTOP { switch ($2) {switch ($2) { case MULT: printf ("* "); break;case MULT: printf ("* "); break; case DIV: printf ("/ "); break;case DIV: printf ("/ "); break; case RESTO: printf ("%% "); break;case RESTO: printf ("%% "); break; }} } Factor} Factor ;;

FactorFactor : : VariableVariable| | INTCT {printf ("%d ", $1);}INTCT {printf ("%d ", $1);}

| | FLOATCT {printf ("%g ", $1);}FLOATCT {printf ("%g ", $1);} | | CHARCT {printf ("\'%c\' ", $1);}CHARCT {printf ("\'%c\' ", $1);} | | TRUE {printf ("true ");}TRUE {printf ("true ");} | | FALSE {printf ("false ");}FALSE {printf ("false ");}

|| NEG {printf ("~ ");} FactorNEG {printf ("~ ");} Factor | | OPPAR {printf ("( ");} Expression OPPAR {printf ("( ");} Expression

CLPAR CLPAR {printf (") ");}{printf (") ");} ;;VariableVariable : : ID {printf ("%s ", $1);}ID {printf ("%s ", $1);} ;;%%%%

/* Inclusao do analisador lexico *//* Inclusao do analisador lexico */

#include "lex.yy.c"#include "lex.yy.c" /* InicTabSimb: Inicializa a tabela de simbolos *//* InicTabSimb: Inicializa a tabela de simbolos */

void InicTabSimb () {void InicTabSimb () {int i;int i;for (i = 0; i < NCLASSHASH; i++) for (i = 0; i < NCLASSHASH; i++)

tabsimb[i] = NULL;tabsimb[i] = NULL;}}

/*/*ProcuraSimb (cadeia): Procura cadeia na tabela ProcuraSimb (cadeia): Procura cadeia na tabela de simbolos;de simbolos;Caso ela ali esteja, retorna um ponteiro para sua Caso ela ali esteja, retorna um ponteiro para sua celula;celula;Caso contrario, retorna NULL.Caso contrario, retorna NULL.

*/*/

simbolo ProcuraSimb (char *cadeia) {simbolo ProcuraSimb (char *cadeia) {simbolo s; int i;simbolo s; int i;i = hash (cadeia);i = hash (cadeia);for (s = tabsimb[i]; (s!=NULL) && for (s = tabsimb[i]; (s!=NULL) && strcmp(cadeia, s->cadeia); strcmp(cadeia, s->cadeia); s = s->prox);s = s->prox);return s;return s;

}}

/*/*InsereSimb (cadeia, tid, tvar):InsereSimb (cadeia, tid, tvar): Insere Insere cadeiacadeia na tabela de na tabela desimbolos, com simbolos, com tidtid como tipo de identificador e com como tipo de identificador e com tvartvar comocomotipo de variavel; Retorna um ponteiro para a celula tipo de variavel; Retorna um ponteiro para a celula inseridainserida

*/*/

simbolo InsereSimb (char *cadeia, int tid, int tvar) {simbolo InsereSimb (char *cadeia, int tid, int tvar) {int i; simbolo aux, s;int i; simbolo aux, s;i = hash (cadeia); aux = tabsimb[i];i = hash (cadeia); aux = tabsimb[i];s = tabsimb[i] = (simbolo) malloc (sizeof (celsimb));s = tabsimb[i] = (simbolo) malloc (sizeof (celsimb));s->cadeia = (char*) malloc ((strlen(cadeia)+1) * s->cadeia = (char*) malloc ((strlen(cadeia)+1) * sizeof(char));sizeof(char));strcpy (s->cadeia, cadeia);strcpy (s->cadeia, cadeia);s->tid = tid;s->tid = tid; s->tvar = tvar;s->tvar = tvar;s->inic = FALSO;s->inic = FALSO; s->ref = FALSO;s->ref = FALSO;s->prox = aux;s->prox = aux; return s;return s;

}}

/*/*hash (cadeia): funcao que determina e retorna a hash (cadeia): funcao que determina e retorna a classeclassede cadeia na tabela de simbolos implementada de cadeia na tabela de simbolos implementada por hashingpor hashing

*/*/

int hash (char *cadeia) {int hash (char *cadeia) {int i, h;int i, h;for (h = i = 0; cadeia[i]; i++) {h += cadeia[i];}for (h = i = 0; cadeia[i]; i++) {h += cadeia[i];}h = h % NCLASSHASH;h = h % NCLASSHASH;return h;return h;

}}

/* ImprimeTabSimb: Imprime todo o conteudo da /* ImprimeTabSimb: Imprime todo o conteudo da tabela de simbolos */tabela de simbolos */

void ImprimeTabSimb () {void ImprimeTabSimb () {int i; simbolo s;int i; simbolo s;printf ("\n\n TABELA DE SIMBOLOS:\n\n");printf ("\n\n TABELA DE SIMBOLOS:\n\n");for (i = 0; i < NCLASSHASH; i++)for (i = 0; i < NCLASSHASH; i++)if (tabsimb[i]) {if (tabsimb[i]) {printf ("Classe %d:\n", i);printf ("Classe %d:\n", i);for (s = tabsimb[i]; s!=NULL; s = s->prox){for (s = tabsimb[i]; s!=NULL; s = s->prox){printf (" (%s, %s", s->cadeia, nometipid[s->tid]);printf (" (%s, %s", s->cadeia, nometipid[s->tid]);if (s->tid == IDVAR)if (s->tid == IDVAR)printf (", %s, %d, %d", printf (", %s, %d, %d", nometipvar[s->tvar], s->inic, s->ref);nometipvar[s->tvar], s->inic, s->ref);printf(")\n");printf(")\n");}}}}

}}

/* Mensagens de erros semanticos *//* Mensagens de erros semanticos */

void DeclaracaoRepetida (char *s) {void DeclaracaoRepetida (char *s) {printf ("\n\n***** Declaracao Repetida: %s *****\n\n", printf ("\n\n***** Declaracao Repetida: %s *****\n\n", s);s);

}}

void NaoDeclarado (char *s) {void NaoDeclarado (char *s) {printf ("\n\n***** Identificador Nao Declarado: %s *****\printf ("\n\n***** Identificador Nao Declarado: %s *****\

n\n", s);n\n", s);}}

void TipoInadequado (char *s) {void TipoInadequado (char *s) {printf printf ("\n\n***** Identificador de Tipo Inadequado: %s *****\n\("\n\n***** Identificador de Tipo Inadequado: %s *****\n\

n", s);n", s);}}

b) Arquivo tsimb012014.lb) Arquivo tsimb012014.l

%{%{void comentario (void);void comentario (void);char tratachar (char *);char tratachar (char *);%}%}delimdelim [ \t\n\r][ \t\n\r]wsws {delim}+{delim}+digitodigito [0-9][0-9]letraletra [A-Za-z][A-Za-z]ctintctint {digito}+{digito}+idid {letra}({letra}|{digito})*{letra}({letra}|{digito})*ctrealctreal {digito}+\.{digito}*([Ee][+-]?{digito}+\.{digito}*([Ee][+-]?

{digito}+)?{digito}+)?carac1carac1 \\.|[^\\']\\.|[^\\']ctcaracctcarac '{carac1}''{carac1}'%%%%

{ws}{ws} { ;}{ ;}"/*""/*"{comentario ();}{comentario ();}charchar {return CHAR;}{return CHAR;}falsefalse {return FALSE;}{return FALSE;}floatfloat {return FLOAT;}{return FLOAT;}intint {return INT;}{return INT;}locallocal {return LOCAL;}{return LOCAL;}logiclogic {return LOGIC;}{return LOGIC;}program program {return PROGRAM;}{return PROGRAM;}statements statements {return STATEMENTS;}{return STATEMENTS;}truetrue {return TRUE;}{return TRUE;}{id}{id} {strcpy (yylval.cadeia, yytext); return ID;}{strcpy (yylval.cadeia, yytext); return ID;}{ctcarac}{ctcarac} {yylval.carac = tratachar (yytext); {yylval.carac = tratachar (yytext);

return CHARCT;}return CHARCT;}{ctint}{ctint} {yylval.valint = atoi(yytext); return INTCT;}{yylval.valint = atoi(yytext); return INTCT;}{ctreal}{ctreal} {yylval.valreal = atof(yytext); return {yylval.valreal = atof(yytext); return

FLOATCT;}FLOATCT;}

"||""||" {return OR;}{return OR;}"&&""&&" {return AND;}{return AND;}"!""!" {return NOT;}{return NOT;}"<""<" {yylval.atr = LT; return RELOP;}{yylval.atr = LT; return RELOP;}"<=""<=" {yylval.atr = LE; return RELOP;}{yylval.atr = LE; return RELOP;}">"">" {yylval.atr = GT; return RELOP;}{yylval.atr = GT; return RELOP;}">="">=" {yylval.atr = GE; return RELOP;}{yylval.atr = GE; return RELOP;}"==""==" {yylval.atr = EQ; return RELOP;}{yylval.atr = EQ; return RELOP;}"!=""!=" {yylval.atr = NE; return RELOP;}{yylval.atr = NE; return RELOP;}"+""+" {yylval.atr = MAIS; return ADOP;}{yylval.atr = MAIS; return ADOP;}"-""-" {yylval.atr = MENOS; return ADOP;}{yylval.atr = MENOS; return ADOP;}"*""*" {yylval.atr = MULT; return {yylval.atr = MULT; return

MULTOP;}MULTOP;}"/""/" {yylval.atr = DIV; return MULTOP;}{yylval.atr = DIV; return MULTOP;}"%""%" {yylval.atr = RESTO; return {yylval.atr = RESTO; return

MULTOP;}MULTOP;}"~""~" {return NEG;}{return NEG;}

"(""(" {return OPPAR;}{return OPPAR;}")"")" {return CLPAR;}{return CLPAR;}"{""{" {return OPBRACE;}{return OPBRACE;}"}""}" {return CLBRACE;}{return CLBRACE;}";"";" {return SCOLON;}{return SCOLON;}",""," {return COMMA;}{return COMMA;}"=""=" {return ASSIGN;}{return ASSIGN;}.. {yylval.carac = yytext[0]; return {yylval.carac = yytext[0]; return

INVAL;}INVAL;}%%%%

/*/* comentario: le e descarta os comentarios do programa */comentario: le e descarta os comentarios do programa */

void comentario () {void comentario () {char c; int estado;char c; int estado;estado = 1;estado = 1;while (estado != 3) {while (estado != 3) {

switch (estado) {switch (estado) {case 1:case 1:

c = input ();c = input ();if (c == EOF) estado = 3;if (c == EOF) estado = 3;else if (c == '*') estado = 2; break;else if (c == '*') estado = 2; break;

case 2:case 2:c = input ();c = input ();if (c == EOF || c == '/') estado = 3;if (c == EOF || c == '/') estado = 3;else if (c != '*') estado = 1; break;else if (c != '*') estado = 1; break;

}}}}

}}

/*/*tratachar: retorna o codigo ASCII de uma tratachar: retorna o codigo ASCII de uma constante do tipo char, eliminando os apostrofos constante do tipo char, eliminando os apostrofos (') e as barras invertidas (\)(') e as barras invertidas (\)

*/*/

char tratachar (char *s) {char tratachar (char *s) {if (s[1] != '\\') return s[1];if (s[1] != '\\') return s[1];else switch (s[2]) {else switch (s[2]) {case 'a': case 'a': return 7;return 7; case '\\': case '\\': return 92;return 92;case 'b': case 'b': return 8;return 8; case 'r': case 'r': return 13;return 13;case '\"': case '\"': return 34;return 34; case 'f': case 'f': return 12;return 12;case 't': case 't': return 9;return 9; case 'n': case 'n': return 10;return 10;case '0': case '0': return 0;return 0; case '\'': case '\'': return 39;return 39;case 'v': case 'v': return 11;return 11;default:default: return s[2];return s[2];}}

}}

0 1 2 3 4' K ' \0

' n '\ \0

' K '\ \0S =

c) Arquivo tsimb012014.datc) Arquivo tsimb012014.dat

program testeprogram teste

local {local {int i, jjj, h, tb;int i, jjj, h, tb;logic n, m;logic n, m;float v, i;float v, i;char x, y, z, w;char x, y, z, w;

}}

statements {statements {x = n && m; v = 3.5 * v; y = '@';x = n && m; v = 3.5 * v; y = '@';v = h % tb; h = jjj % 4.2;v = h % tb; h = jjj % 4.2;{{ i = jjj*false; jjj = 0;i = jjj*false; jjj = 0;}}jjj = n + 1; i = i + 1;jjj = n + 1; i = i + 1;{{

i = !i; i = i + 1 + z;i = !i; i = i + 1 + z; {{ i = 0; jjj = 0;i = 0; jjj = 0; }} jjj = jjjj + teste;jjj = jjjj + teste;

}}

m = v + 2 > x;m = v + 2 > x;m = n != true;m = n != true;m = i >= n;m = i >= n;n = m == 4;n = m == 4;i = i + 1;i = i + 1;n = ~ m;n = ~ m;n = (!m && n) && (m && !n);n = (!m && n) && (m && !n);i = n / 5;i = n / 5;i = (!m && n) / 5;i = (!m && n) / 5;n = (!m || n) && (m || !n);n = (!m || n) && (m || !n);n = (!m || n) && (tb + v);n = (!m || n) && (tb + v);n = (tb + v) || (!m || n); n = (tb + v) || (!m || n); n = (~h + v) * (tb - jjj);n = (~h + v) * (tb - jjj);i = (!m || n) - 5;i = (!m || n) - 5;

}}Rodar tudo com o arquivo tsimb012014.dat

Exercício 3.1: Inserir no programa 3.1Exercício 3.1: Inserir no programa 3.1 programação para programação para montar a tabela dos montar a tabela dos símbolossímbolos dos programas analisados e realizar dos programas analisados e realizar alguns alguns testes semânticostestes semânticos simples, executando simples, executando as seguintes tarefas:as seguintes tarefas:

a)a)Inicializar Inicializar a tabela de símbolos, a tabela de símbolos, anulandoanulando os os ponteiros de todas as suas classes, e ponteiros de todas as suas classes, e imprimirimprimir o o conteúdo da tabela de símbolos (que deve ser conteúdo da tabela de símbolos (que deve ser vazio)vazio)

b)b)InserirInserir o nome do o nome do programa programa na tabela na tabela

c)c)InserirInserir os nomes das os nomes das variáveis declaradasvariáveis declaradas na na tabela, notificando os casos de tabela, notificando os casos de re-declaraçãore-declaração

Exercício 3.1: Inserir no programa 3.1Exercício 3.1: Inserir no programa 3.1 programação para programação para montar a tabela dos montar a tabela dos símbolossímbolos dos programas analisados e realizar dos programas analisados e realizar alguns alguns testes semânticostestes semânticos simples, simples, executando as seguintes tarefas:executando as seguintes tarefas:

d)d)Verificar se cada Verificar se cada identificador usadoidentificador usado foi foi

declaradodeclarado

e)e)Verificar se cada Verificar se cada identificador usado de identificador usado de variávelvariável é do tipo é do tipo IDVARIDVAR

f)f)MarcarMarcar as variáveis as variáveis referenciadasreferenciadas e e inicializadasinicializadas pelo programa e verificar se pelo programa e verificar se todas as variáveis têm essa marcatodas as variáveis têm essa marca

a)a) Inicializar Inicializar a tabela de símbolos, a tabela de símbolos, anulandoanulando os os ponteiros de todas as suas classes, e ponteiros de todas as suas classes, e imprimirimprimir o o conteúdo da tabela de símbolos (que deve ser vazio)conteúdo da tabela de símbolos (que deve ser vazio)

Colocar Colocar {InicTabSimb ();} {InicTabSimb ();} no início da no início da 1ª 1ª produçãoprodução

Colocar Colocar {ImprimeTabSimb ();} {ImprimeTabSimb ();} no final da no final da mesma produção mesma produção

Trocar Trocar $2 $2 por por $3 $3 , na mesma produção, na mesma produção

ProgProg : PROGRAM ID : PROGRAM ID {printf ("program %s ;\n", $2);} LocDecls {printf ("program %s ;\n", $2);} LocDecls Stats Stats ;; Rodar com o

arquivo tsimb012014.dat

b)b) InserirInserir o nome do o nome do programa programa na tabela na tabela

Na produção Na produção ProgProg, na ação depois de , na ação depois de IDID, , depois da chamada de depois da chamada de printfprintf, colocar , colocar

InsereSimb ($3, IDPROG, NAOVAR);InsereSimb ($3, IDPROG, NAOVAR);

ProgProg : : {- - - -} PROGRAM ID{- - - -} PROGRAM ID {printf ("program %s\n", $3); }{printf ("program %s\n", $3); }

LocDecls Stats {- - - -}LocDecls Stats {- - - -};;

Rodar com o arquivo tsimb012014.dat

c)c) InserirInserir os nomes das os nomes das variáveis declaradasvariáveis declaradas na na tabela, notificando os casos de tabela, notificando os casos de re-declaraçãore-declaração..

Declarar uma nova variável global inteira: Declarar uma nova variável global inteira: tipocorrentetipocorrente

Na produção Na produção ElemElem, na ação depois de , na ação depois de IDID, , depois do depois do printfprintf, colocar, colocar

if (ProcuraSimb ($1) != NULL)if (ProcuraSimb ($1) != NULL)DeclaracaoRepetida ($1);DeclaracaoRepetida ($1);elseelseInsereSimb ($1, IDVAR, tipocorrente);InsereSimb ($1, IDVAR, tipocorrente);

Elem Elem : ID {printf ("%s ", $1); }: ID {printf ("%s ", $1); };;

Nas produções Nas produções TypeType, atribuir valor à variável , atribuir valor à variável tipocorrentetipocorrente

tipocorrente = INTEIRO;tipocorrente = REAL;tipocorrente = CARACTERE;tipocorrente = LOGICO;

Type : INT {printf (- -); | FLOAT {printf (- -); | CHAR {printf (- -); | LOGIC {printf (- -);

}}} }


d)d) Verificar se cada Verificar se cada identificador usadoidentificador usado foi foi declaradodeclarado

e)e) Verificar se cada Verificar se cada identificador usado de identificador usado de variávelvariável é do tipo é do tipo IDVARIDVAR

Na produção Na produção VariableVariable, , na ação depois de na ação depois de IDID, , depois do depois do printfprintf, colocar, colocar

simb = ProcuraSimb ($1);simb = ProcuraSimb ($1);if (simb == NULL) NaoDeclarado ($1);if (simb == NULL) NaoDeclarado ($1);else if (simb->tid != IDVAR) TipoInadequado else if (simb->tid != IDVAR) TipoInadequado ($1);($1);

VariableVariable : ID {printf ("%s ", $1); }: ID {printf ("%s ", $1); };; Rodar com o arquivo

tsimb012014.dat

f)f) MarcarMarcar as variáveis as variáveis referenciadasreferenciadas e e inicializadasinicializadas pelo programa e verificar se todas pelo programa e verificar se todas as variáveis têm essa marcaas variáveis têm essa marca

Acrescentar o campo Acrescentar o campo simbsimb na declaração na declaração %union%union::

/* Definicao dos campos dos tipos dos atributos *//* Definicao dos campos dos tipos dos atributos */

%union {%union {char cadeia[50];char cadeia[50];int atr, valint;int atr, valint;float valreal;float valreal;char carac;char carac;

simbolo simb;simbolo simb;}}

Isso possibilita que terminais e/ou não-terminais tenham como atributo um ponteiro para uma célula da tabsimb

Declarar que o não-terminal Declarar que o não-terminal VariableVariable tem tem como atributo o campo como atributo o campo simbsimb da da %union%union, , colocando antes dos colocando antes dos tokenstokens::

%type%type <simb><simb> VariableVariable

/* Declaracao dos atributos dos tokens e /* Declaracao dos atributos dos tokens e dos nao-terminais */dos nao-terminais */

%token%token <cadeia><cadeia> IDID%token%token <cadeia><cadeia> CTCARACCTCARAC%token%token <valint><valint> CTINTCTINT

Na produção Na produção Variable Variable, no final da ação final, , no final da ação final, colocar:colocar:

$$ = simb;$$ = simb;

VariableVariable : ID {: ID {printf - - - - - printf - - - - - simb = ProcuraSimb ($1);simb = ProcuraSimb ($1);if - - - - - if - - - - - else if - - - - -else if - - - - -

}};;

O atributo do não-terminal Variable é um ponteiro para a célula correspondente a ID na tabsimb

Na produção Na produção Factor : Variable Factor : Variable, colocar, no , colocar, no final, a ação:final, a ação:

{if ($1 != NULL) $1->ref = VERDADE;}{if ($1 != NULL) $1->ref = VERDADE;}

FactorFactor : : VariableVariable

Na produção Na produção AssignStatAssignStat, colocar, depois de , colocar, depois de VariableVariable, a ação:, a ação:{if ($1 != NULL) $1->inic = $1->ref = {if ($1 != NULL) $1->inic = $1->ref = VERDADE;}VERDADE;}

AssignStat AssignStat : Variable ASSIGN {printf ("<- : Variable ASSIGN {printf ("<- ");} ");} Expression SCOLON {printf (";\ Expression SCOLON {printf (";\n");}n");} Rodar com o arquivo

tsimb012014.dat

Fazer uma função Fazer uma função VerificaInicRefVerificaInicRef, que , que percorra toda a percorra toda a tabsimbtabsimb, checando e , checando e avisando os casos de identificadores não-avisando os casos de identificadores não-inicializados e não-referenciadosinicializados e não-referenciados

– Não esquecer o Não esquecer o protótipoprotótipo

Chamar Chamar VerificaInicRefVerificaInicRef antes de antes de ImprimeTabSimbImprimeTabSimb, na ação final da produção , na ação final da produção ProgProg Rodar com o


Exercício 3.2: Inserir no programa 3.1Exercício 3.2: Inserir no programa 3.1 programação para verificar a compatibilidade programação para verificar a compatibilidade entre os operadores e os operandos das entre os operadores e os operandos das expressões, de acordo com a tabelaexpressões, de acordo com a tabela

Numa produção contendo um Numa produção contendo um operadoroperador de de expressões, os expressões, os operandosoperandos são são não-terminaisnão-terminais

Exemplo: Exemplo: seja a produçãoseja a produção

Term Term : Term : Term MULTOP MULTOP FactorFactor

No lado direito, No lado direito, TermTerm e e FactorFactor representam os representam os operandos de operandos de MULTOPMULTOP

É conveniente que esses É conveniente que esses não-terminaisnão-terminais e e todos aqueles relacionados com todos aqueles relacionados com expressõesexpressões tenham, como tenham, como atributoatributo o o tipotipo da sub- da sub-expressão que eles representamexpressão que eles representam

Acrescentar o campo Acrescentar o campo tipoexprtipoexpr na declaração na declaração %union%union::

%union {%union {

char cadeia[50];char cadeia[50]; int atr, valint;int atr, valint;float valreal;float valreal; char carac;char carac; simbolo simb; simbolo simb;int tipoexpr;int tipoexpr;

}} Declarar que todos os não-terminais relacionados Declarar que todos os não-terminais relacionados

com com expressões expressões têm como atributo o campo têm como atributo o campo tipoexprtipoexpr::

%type %type <tipoexpr> <tipoexpr> Expression AuxExpr1 AuxExpr2Expression AuxExpr1 AuxExpr2 AuxExpr3 AuxExpr4 Term FactorAuxExpr3 AuxExpr4 Term Factor

Em cada produção relacionada com Em cada produção relacionada com expressõesexpressões, deve ser calculado o atributo do , deve ser calculado o atributo do lado esquerdo (lado esquerdo ($$$$))

Nas produções contendo Nas produções contendo operadoresoperadores, devem , devem ser feitos testes de ser feitos testes de compatibilidadecompatibilidade

Exemplo: Exemplo: Teste de compatibilidade do operador Teste de compatibilidade do operador NEGNEG

No não terminal No não terminal VariableVariable, já está calculado o , já está calculado o valor de valor de $$$$::

VariableVariable : ID {: ID {printf ("%s ", $1);printf ("%s ", $1);simb = ProcuraSimb ($1);simb = ProcuraSimb ($1);if (simb == NULL) NaoDeclarado if (simb == NULL) NaoDeclarado

($1);($1);else if (simb->tid != IDVAR) else if (simb->tid != IDVAR)

TipoInadequado ($1);TipoInadequado ($1);$$ = simb;$$ = simb;

}};;

Calcular o valor de Calcular o valor de $$$$ em todas as produções de em todas as produções de FactorFactor e fazer teste de compatibilidade nas e fazer teste de compatibilidade nas produções cabíveis:produções cabíveis:

FactorFactor : Variable {: Variable {if ($1 != NULL) if ($1 != NULL) {{$1->ref = VERDADE; $1->ref = VERDADE; $$ = $1->tvar;$$ = $1->tvar;}} }}| INTCT {printf ("%d ", $1); | INTCT {printf ("%d ", $1); $$ = INTEIRO; $$ = INTEIRO; }}| FLOATCT {printf ("%g ", $1); | FLOATCT {printf ("%g ", $1); $$ = REAL;$$ = REAL; }}| CHARCT {printf ("%c ", $1); | CHARCT {printf ("%c ", $1); $$ = CARACTERE;$$ = CARACTERE; }}| TRUE {printf (“true "); | TRUE {printf (“true "); $$ = LOGICO;$$ = LOGICO; }}| FALSE {printf ("false "); | FALSE {printf ("false "); $$ = LOGICO;$$ = LOGICO; }}

Trocar o conteúdo da ação por

Calcular o valor de Calcular o valor de $$$$ em todas as produções de em todas as produções de FactorFactor e fazer teste de compatibilidade nas e fazer teste de compatibilidade nas produções cabíveis:produções cabíveis:

FactorFactor : NEG {printf ("~ ");} Factor : NEG {printf ("~ ");} Factor {{if ($3 != INTEIRO &&if ($3 != INTEIRO &&$3 != REAL && $3 != CARACTERE)$3 != REAL && $3 != CARACTERE)Incompatibilidade ("Operando improprio para Incompatibilidade ("Operando improprio para menos unario");menos unario");if ($3 == REAL) $$ = REAL;if ($3 == REAL) $$ = REAL;else $$ = INTEIRO;else $$ = INTEIRO; }}| OPPAR {printf ("\( ");} Expression CLPAR | OPPAR {printf ("\( ");} Expression CLPAR { printf (") "); { printf (") "); $$ = $3; $$ = $3; }};;

Criar a função Criar a função Incompatibilidade Incompatibilidade e seu e seu protótipo:protótipo:

void Incompatibilidade (char *);void Incompatibilidade (char *);

void Incompatibilidade (char *s) {void Incompatibilidade (char *s) {printf ("\n\n***** Incompatibilidade: %s printf ("\n\n***** Incompatibilidade: %s

*****\n\n", s);*****\n\n", s);}} Rodar com o


Exemplo: Exemplo: Teste de compatibilidade do operador Teste de compatibilidade do operador MULTOPMULTOP

Calcular o valor de Calcular o valor de $$$$ em todas as produções em todas as produções do não-terminal do não-terminal TermTerm e fazer teste de e fazer teste de compatibilidade nas produções cabíveiscompatibilidade nas produções cabíveis

Term Term : Factor : Factor /* Default: $$ = $1; *//* Default: $$ = $1; */| Term MULTOP {- - - - -} Factor | Term MULTOP {- - - - -} Factor {switch ($2) {{switch ($2) { case MULT: case DIV:case MULT: case DIV: if ($1 != INTEIRO && $1 != REAL && $1 != if ($1 != INTEIRO && $1 != REAL && $1 != CARACTERECARACTERE || $4 != INTEIRO && $4!=REAL && $4!|| $4 != INTEIRO && $4!=REAL && $4!=CARACTERE)=CARACTERE) IncompatibilidadeIncompatibilidade ("Operando improprio para ("Operando improprio para operador aritmetico");operador aritmetico"); if ($1 == REAL || $4 == REAL) $$ = REAL;if ($1 == REAL || $4 == REAL) $$ = REAL; else $$ = INTEIRO; else $$ = INTEIRO; break;break; case RESTO:case RESTO: if ($1 != INTEIRO && $1 != CARACTERE if ($1 != INTEIRO && $1 != CARACTERE || $4 != INTEIRO && $4 != CARACTERE)|| $4 != INTEIRO && $4 != CARACTERE) IncompatibilidadeIncompatibilidade ("Operando improprio para operador resto");("Operando improprio para operador resto"); $$ = INTEIRO; $$ = INTEIRO; break;break; } } } } ;;

Exercício: fazer testes para os operadores ADOP, RELOP, NOT, AND e OR


Programa 3.2: Gramática sem Programa 3.2: Gramática sem subprogramas, com variáveis escalares e subprogramas, com variáveis escalares e indexadas, comandos de atribuição, if, indexadas, comandos de atribuição, if, while, read e writewhile, read e write

Para os exercícios 3.3, 3.4 e 3.5, considerar os Para os exercícios 3.3, 3.4 e 3.5, considerar os arquivos arquivos tsimb022014.l tsimb022014.l ee tsimb022014.y tsimb022014.y da da aba de aba de ‘Códigos’‘Códigos’ da página do professor da página do professor

Rodar esses programas com o arquivo de Rodar esses programas com o arquivo de dados dados tsimb012014.dattsimb012014.dat

Esses programas já fazem teste de Esses programas já fazem teste de compatibilidade de compatibilidade de expressõesexpressões

Exercício 3.3: Inserir, no programa 3.2Exercício 3.3: Inserir, no programa 3.2, teste , teste para verificar a para verificar a compatibilidadecompatibilidade entre os dois entre os dois lados dos lados dos comandos de atribuiçãocomandos de atribuição, de acordo , de acordo com a tabela:com a tabela:

AssignStat :AssignStat : Variable {Variable { if ($1 != NULL) $1->inic = $1->ref = VERDADE;}if ($1 != NULL) $1->inic = $1->ref = VERDADE;}

ASSIGN {printf ("= ");} Expression ASSIGN {printf ("= ");} Expression SCOLON {SCOLON {

printf (";\n");printf (";\n"); if ($1 != NULL)if ($1 != NULL)

if ((($1->tvar == INTEIRO || $1->tvar == CARACTERE) if ((($1->tvar == INTEIRO || $1->tvar == CARACTERE) && && ($5 == REAL || $5 == LOGICO)) ||($5 == REAL || $5 == LOGICO)) ||

($1->tvar == REAL && $5 == LOGICO) || ($1->tvar == REAL && $5 == LOGICO) || ($1->tvar == LOGICO && $5 != LOGICO))($1->tvar == LOGICO && $5 != LOGICO))

Incompatibilidade ("Lado direito de comando de Incompatibilidade ("Lado direito de comando de atribuicao improprio");atribuicao improprio");

}} ;;

Testar com o arquivo de dados Testar com o arquivo de dados tsimb012014.dattsimb012014.dat

Exercício 3.4: Exercício 3.4: Inserir na gramática do Inserir na gramática do programa programa 3.23.2 testes semânticos para as produções dos testes semânticos para as produções dos comandos comandos ifif, , whilewhile, , readread, , writewrite que aparecem na que aparecem na linguagem COMP-ITA 2014linguagem COMP-ITA 2014

Produções:Produções:

Statement Statement : CompStat | IfStat | WhileStat | : CompStat | IfStat | WhileStat | ReadStatReadStat

| WriteStat | AssignStat| WriteStat | AssignStatIfStatIfStat : : ifif Expression Expression then then Statement ElseStatStatement ElseStatElseStatElseStat : : | | elseelse Statement StatementWhileStat WhileStat : : whilewhile Expression Expression dodo Statement StatementReadStat ReadStat : : readread ( ( ReadList ReadList )) ;;ReadListReadList : ReadElem | ReadList : ReadElem | ReadList ,, ReadElem ReadElemReadElemReadElem : Variable | : Variable | strstr Variable VariableWriteStat WriteStat : : writewrite ( ( WriteList WriteList )) ;; WriteListWriteList : WriteElem | WriteList : WriteElem | WriteList ,, WriteElem WriteElemWriteElemWriteElem : : STRINGSTRING | Expression | | Expression | strstr Variable Variable

Statement Statement : CompStat | IfStat | WhileStat | ReadStat: CompStat | IfStat | WhileStat | ReadStat | WriteStat | AssignStat| WriteStat | AssignStatIfStatIfStat : : ifif Expression Expression then then Statement ElseStatStatement ElseStatElseStatElseStat : : | | elseelse Statement StatementWhileStat WhileStat : : whilewhile Expression Expression dodo Statement StatementReadStat ReadStat : : readread ( ( ReadList ReadList )) ;;ReadListReadList : ReadElem | ReadList : ReadElem | ReadList ,, ReadElem ReadElemReadElemReadElem : Variable | : Variable | strstr Variable VariableWriteStat WriteStat : : writewrite ( ( WriteList WriteList )) ;; WriteListWriteList : WriteElem | WriteList : WriteElem | WriteList ,, WriteElem WriteElemWriteElemWriteElem : : STRINGSTRING | Expression | | Expression | strstr Variable Variable

Marcar as Marcar as variáveis lidasvariáveis lidas como como inicializadasinicializadas e e referenciadas referenciadas (tal como no lado esquerdo de (tal como no lado esquerdo de atribuição)atribuição)Não alterar as produções:

ReadElem: str Variable e WriteElem: str VariableElas serão tratadas com as variáveis indexadas

Statement Statement : CompStat | IfStat | WhileStat | ReadStat: CompStat | IfStat | WhileStat | ReadStat | WriteStat | AssignStat| WriteStat | AssignStatIfStatIfStat : : ifif Expression Expression then then Statement ElseStatStatement ElseStatElseStatElseStat : : | | elseelse Statement StatementWhileStat WhileStat : : whilewhile Expression Expression dodo Statement StatementReadStat ReadStat : : readread ( ( ReadList ReadList )) ;;ReadListReadList : ReadElem | ReadList : ReadElem | ReadList ,, ReadElem ReadElemReadElemReadElem : Variable | : Variable | strstr Variable VariableWriteStat WriteStat : : writewrite ( ( WriteList WriteList )) ;; WriteListWriteList : WriteElem | WriteList : WriteElem | WriteList ,, WriteElem WriteElemWriteElemWriteElem : : STRINGSTRING | Expression | | Expression | strstr Variable Variable

Verificar se as Verificar se as expressõesexpressões dos comandos dos comandos ifif e e whilewhile são são lógicaslógicas

Testar o programa com o arquivo de dados Testar o programa com o arquivo de dados tsimb022014.dattsimb022014.dat

Abrir o arquivo tsimb022014.dat

As variáveis n e num são lidas (inic e ref)

Expressões inteiras em comandos if e while

Exercício 3.5: Exercício 3.5: Inserir na gramática do Inserir na gramática do programa programa 3.23.2 alterações na alterações na tabela de símbolostabela de símbolos e e testes testes semânticossemânticos para as produções que aparecem na para as produções que aparecem na linguagem COMP-ITA 2014, envolvendo linguagem COMP-ITA 2014, envolvendo variáveis variáveis indexadasindexadas

Produções:Produções:

ElemElem :: IDID | | ID [ID [ DimList DimList ]] DimListDimList :: INTCT INTCT || DimList DimList , INTCT, INTCTReadElemReadElem : : Variable | Variable | strstr Variable VariableWriteElemWriteElem : : STRINGSTRING | Expression | | Expression | strstr Variable VariableVariableVariable : : IDID | | IDID [[ SubscrList SubscrList ]]SubscrListSubscrList : : AuxAuxExpr4Expr4 | SubscrList | SubscrList ,, AuxExpr4 AuxExpr4

Observar estas produções no arquivo Observar estas produções no arquivo tsimb022014.ytsimb022014.y

Na Na declaraçãodeclaração de variáveis indexadas, de variáveis indexadas, inseririnserir o nome na tabela de símbolos: o nome na tabela de símbolos:

Elem Elem :: ID {ID { printf ("%s ", $1);printf ("%s ", $1); if (ProcuraSimb ($1) != NULL)if (ProcuraSimb ($1) != NULL) DeclaracaoRepetida ($1);DeclaracaoRepetida ($1); elseelse InsereSimb ($1, IDVAR, InsereSimb ($1, IDVAR,

tipocorrente);tipocorrente); }}

| | ID OPBRAK {printf ("%s [ ", $1); } ID OPBRAK {printf ("%s [ ", $1); } DimListDimList

CLBRAK {printf ("] ");}CLBRAK {printf ("] ");} ;;

Copiar

No No usouso de variáveis indexadas, de variáveis indexadas, verificarverificar se o se o nome está na tabela de símbolos: nome está na tabela de símbolos:

Variable: Variable: ID {ID { printf ("%s ", $1);printf ("%s ", $1); simb = ProcuraSimb ($1);simb = ProcuraSimb ($1); if (simb == NULL) NaoDeclarado ($1);if (simb == NULL) NaoDeclarado ($1); else if (simb->tid != IDVAR) else if (simb->tid != IDVAR)

TipoInadequado ($1);TipoInadequado ($1); $$ = simb;$$ = simb; }} | | ID OPBRAK { printf ("%s [ ", $1); } SubscrListID OPBRAK { printf ("%s [ ", $1); } SubscrList CLBRAK {printf ("] ");}CLBRAK {printf ("] ");} ;;

Copiar

Na segunda produção de Variable, $$ = simb deverá ser corrigido mais adiante

Preparar a Preparar a tabela de símbolostabela de símbolos para guardar para guardar informações sobre: informações sobre:

Número de dimensõesNúmero de dimensões de uma variável de uma variável indexadaindexada

Número de elementosNúmero de elementos de cada dimensão de cada dimensão TipoTipo de cada elemento de cada elemento

Exemplo:Exemplo: para a declaração para a declaração

int A[10, 20, 5]int A[10, 20, 5]: :

Acadeia

IDVAR

tid

INTEIROtvar

0inic

0ref

1arra

y3

ndims

10

20

5 ..........

dims

0 1 2 3 10

/* Definicao de outras constantes *//* Definicao de outras constantes */

#define#define NCLASSHASHNCLASSHASH 2323#define#define VERDADEVERDADE 11#define#define FALSOFALSO 00#define #define MAXDIMSMAXDIMS 1010

/* Declaracoes para a tabela de simbolos *//* Declaracoes para a tabela de simbolos */

typedef struct celsimb celsimb; typedef celsimb typedef struct celsimb celsimb; typedef celsimb *simbolo;*simbolo;

struct celsimb {struct celsimb {char *cadeia; int tid, tvar char *cadeia; int tid, tvar , ndims, , ndims, dims[MAXDIMS+1]dims[MAXDIMS+1] ;;char inic, ref char inic, ref , array , array ; simbolo prox; ; simbolo prox;

};};A

cadeia

IDVAR

tid

INTEGER

tvar

0inic

0ref

1arra

y3

ndims

10

20

5 ..........

dims

0 1 2 3 10

/* ImprimeTabSimb: Imprime todo o conteudo da tabela de simbolos /* ImprimeTabSimb: Imprime todo o conteudo da tabela de simbolos */*/

void ImprimeTabSimb () {void ImprimeTabSimb () {int i; simbolo s;int i; simbolo s;printf ("\n\n TABELA DE SIMBOLOS:\n\n");printf ("\n\n TABELA DE SIMBOLOS:\n\n");for (i = 0; i < NCLASSHASH; i++)for (i = 0; i < NCLASSHASH; i++)if (tabsimb[i]) {if (tabsimb[i]) {printf ("Classe %d:\n", i);printf ("Classe %d:\n", i);for (s = tabsimb[i]; s!=NULL; s = s->prox){for (s = tabsimb[i]; s!=NULL; s = s->prox){printf (- - - - -);printf (- - - - -);if (s->tid == IDVAR) if (s->tid == IDVAR) {{printf (- - - - -);printf (- - - - -);if (s->array == VERDADE) { int j;if (s->array == VERDADE) { int j;printf (", EH ARRAY\n\tndims = %d, dimensoes:", s->ndims);printf (", EH ARRAY\n\tndims = %d, dimensoes:", s->ndims);for (j = 1; j <= s->ndims; j++)for (j = 1; j <= s->ndims; j++)

printf (" %d", s->dims[j]);printf (" %d", s->dims[j]);}}}}printf(")\n");printf(")\n");}}}}

}}

Alterar toda programação da montagem da Alterar toda programação da montagem da tabela de símbolostabela de símbolos e de e de testes semânticostestes semânticos realizados até agorarealizados até agora

Acadeia

IDVAR

tid

INTEGER

tvar

0inic

0ref

1arra

y3

ndims

10

20

5 ..........

dims

0 1 2 3 10

Nas declarações das variáveis:Nas declarações das variáveis:

Elem :Elem : ID { printf ("%s ", $1);ID { printf ("%s ", $1);if (ProcuraSimb ($1) != NULL) DeclaracaoRepetida ($1);if (ProcuraSimb ($1) != NULL) DeclaracaoRepetida ($1);

else else { simb ={ simb = InsereSimb ($1, IDVAR, InsereSimb ($1, IDVAR, tipocorrente);tipocorrente);

simb->array = FALSO; }simb->array = FALSO; }}}

| ID OPBRAK { printf ("%s [ ", $1);| ID OPBRAK { printf ("%s [ ", $1); if (ProcuraSimb ($1) != NULL) if (ProcuraSimb ($1) != NULL)

DeclaracaoRepetida ($1);DeclaracaoRepetida ($1); else else { simb ={ simb = InsereSimb ($1, IDVAR, InsereSimb ($1, IDVAR,

tipocorrente);tipocorrente); simb->array = VERDADE; simb->ndims simb->array = VERDADE; simb->ndims

= 0; }= 0; }} DimList CLBRAK {printf ("] ");}} DimList CLBRAK {printf ("] ");}

;;

Ainda falta achar as dimensões das variáveis indexadas

Acadeia

IDVAR

tid

INTEGER

tvar

0inic

0ref

1arra

y3

ndims

10

20

5 ..........

dims

0 1 2 3 10

No dimensionamento das variáveis indexadas, No dimensionamento das variáveis indexadas, inclusive verificando se a inclusive verificando se a constante inteiraconstante inteira usada usada no no dimensionamentodimensionamento de uma variável indexada é de uma variável indexada é positivapositiva: :

DimList : INTCT { printf ("%d ", $1);DimList : INTCT { printf ("%d ", $1); if ($1 <= 0) Esperado ("Valor inteiro positivo");if ($1 <= 0) Esperado ("Valor inteiro positivo"); simb->ndims++; simb->dims[simb->ndims] = simb->ndims++; simb->dims[simb->ndims] =

$1;$1;}}

| DimList COMMA INTCT { printf (", %d ", $3);| DimList COMMA INTCT { printf (", %d ", $3); if ($3 <= 0) Esperado ("Valor inteiro positivo");if ($3 <= 0) Esperado ("Valor inteiro positivo"); simb->ndims++; simb->dims[simb->ndims] = simb->ndims++; simb->dims[simb->ndims] =

$3;$3; }};;

Acadeia

IDVAR

tid

INTEGER

tvar

0inic

0ref

1arra

y3

ndims

10

20

5 ..........

dims

0 1 2 3 10

Criar o protótipo:Criar o protótipo:

void Esperado (char *);void Esperado (char *);

E a função:E a função:

void Esperado (char *s) {void Esperado (char *s) {printf ("\n\n***** Esperado: %s *****\n\printf ("\n\n***** Esperado: %s *****\n\

n", s);n", s);}}

Na segunda produção do não-terminal Na segunda produção do não-terminal VariableVariable, , para se determinar o para se determinar o atributoatributo do lado esquerdo, do lado esquerdo, deve ser feita a seguinte alteração:deve ser feita a seguinte alteração:

Variable: ID { - - - - - $$ = simb; }Variable: ID { - - - - - $$ = simb; }| ID OPBRAK {| ID OPBRAK { printf ("%s [ ", $1);printf ("%s [ ", $1); simb = ProcuraSimb ($1);simb = ProcuraSimb ($1); if (simb == NULL) NaoDeclarado ($1);if (simb == NULL) NaoDeclarado ($1); else if (simb->tid != IDVAR) TipoInadequado ($1);else if (simb->tid != IDVAR) TipoInadequado ($1); $<simb>$ = simb;$<simb>$ = simb;

} SubscrList CLBRAK {printf ("] "); } SubscrList CLBRAK {printf ("] "); $$ = $<simb>3; $$ = $<simb>3; }}

;;

É a especificação do É a especificação do atributoatributo de um de um não-não-terminal fictícioterminal fictício

Rodar o programa com o arquivo tsimb032014.dat, para verificar se as informações foram introduzidas na tabsimb

Porque não eliminar isso e não colocar $$ = simb aqui

Por default, o Por default, o atributoatributo de um de um não-terminal não-terminal fictício fictício também é do tipo também é do tipo inteirointeiro

Muitas vezes é Muitas vezes é desejáveldesejável especificar para ele um especificar para ele um dos campos da dos campos da %union%union

Isso não pode ser feito por uma declaração Isso não pode ser feito por uma declaração %type%type

%type %type só declara atributos de não-terminais só declara atributos de não-terminais não-fictíciosnão-fictícios

Para tanto, coloca-se o campo escolhido entre os Para tanto, coloca-se o campo escolhido entre os caracteres caracteres ‘<’‘<’ e e ‘>’‘>’, tudo isso logo após o , tudo isso logo após o primeiro caractere primeiro caractere ‘$’‘$’, por exemplo, , por exemplo, $<cadeia>$$<cadeia>$, , $<simb>1$<simb>1, , $<valint>2$<valint>2

Exemplo: Exemplo: Seja a seguinte produção:Seja a seguinte produção:

A A : : B {simb = InsereSimb (- - -);} C {$$ = simb->tvar;}B {simb = InsereSimb (- - -);} C {$$ = simb->tvar;}

Onde Onde simbsimb é uma variável global e é uma variável global e

%union {int tipoexpr; simbolo simb;}%union {int tipoexpr; simbolo simb;}%type <tipoexpr> A%type <tipoexpr> A

Por essa programação, deseja-se que o atributo de Por essa programação, deseja-se que o atributo de AA seja o seja o tipo da variável tipo da variável da célula apontada por da célula apontada por simbsimb

Mas, no processamento do não-terminal Mas, no processamento do não-terminal CC, pode ser , pode ser que o valor de que o valor de simbsimb seja alterado, não se realizando o seja alterado, não se realizando o desejado desejado

Então a programação na produção deve mudar paraEntão a programação na produção deve mudar paraA A : : B {$<simb>$ = InsereSimb (- - -);} C {$$ = B {$<simb>$ = InsereSimb (- - -);} C {$$ =

$<simb>2->tvar;}$<simb>2->tvar;}

Realizar ainda os seguintes testes e ações semânticas:Realizar ainda os seguintes testes e ações semânticas:

Verificar se as Verificar se as expressõesexpressões que aparecem nos que aparecem nos subscritossubscritos das variáveis indexadas são do tipo das variáveis indexadas são do tipo inteirointeiro ou ou caracterecaractere

Marcar as variáveis indexadas Marcar as variáveis indexadas lidaslidas, precedidas , precedidas pela palavra pela palavra strstr, como , como inicializadainicializadas e s e referenciadasreferenciadas

Marcar as variáveis indexadas Marcar as variáveis indexadas escritasescritas, precedidas , precedidas pela palavra pela palavra strstr, como , como referenciadasreferenciadas

Verificar se uma variável precedida pela palavra Verificar se uma variável precedida pela palavra strstr é indexada do tipo é indexada do tipo charchar

Realizar ainda os seguintes testes e ações semânticas:Realizar ainda os seguintes testes e ações semânticas:

Verificar se uma variável de Verificar se uma variável de tipo escalartipo escalar tem tem subscritossubscritos

Verificar se uma variável Verificar se uma variável indexadaindexada não precedida não precedida pela palavra reservada pela palavra reservada strstr não tem não tem subscritossubscritos

Verificar se o Verificar se o número de subscritosnúmero de subscritos de uma de uma variável indexada não precedida pela palavra variável indexada não precedida pela palavra strstr é é igual ao seu igual ao seu número de dimensõesnúmero de dimensões declarado declarado

Verificar se o Verificar se o número de subscritosnúmero de subscritos de uma de uma variável indexada precedida pela palavra variável indexada precedida pela palavra strstr é igual é igual ao seu ao seu número de dimensõesnúmero de dimensões declarado declarado menos 1menos 1

Verificar se as Verificar se as expressõesexpressões que aparecem nos que aparecem nos subscritossubscritos das variáveis indexadas são do tipo das variáveis indexadas são do tipo inteirointeiro ou ou caracterecaractere

Produções para este teste:Produções para este teste:

SubscrList: AuxExpr4 SubscrList: AuxExpr4 {{ if ($1 != INTEIRO && $1 != CARACTERE)if ($1 != INTEIRO && $1 != CARACTERE)

Incompatibilidade ("Tipo inadequado para Incompatibilidade ("Tipo inadequado para subscrito");subscrito");}}

| SubscrList COMMA {printf (", ");} AuxExpr4 | SubscrList COMMA {printf (", ");} AuxExpr4 {{

if ($4 != INTEIRO && $4 != CARACTERE)if ($4 != INTEIRO && $4 != CARACTERE) Incompatibilidade ("Tipo inadequado para Incompatibilidade ("Tipo inadequado para

subscrito");subscrito");}}

;;Rodar o programa com o arquivo tsimb032014.dat

Marcar as variáveis indexadas Marcar as variáveis indexadas lidaslidas, precedidas , precedidas pela palavra pela palavra strstr, como , como inicializadainicializadas e s e referenciadasreferenciadas

Na produção Na produção ReadElemReadElem que usa que usa strstr::

ReadElem: ReadElem: Variable {Variable {if ($1 != NULL) if ($1 != NULL) $1->inic = $1->ref = VERDADE; }$1->inic = $1->ref = VERDADE; }| | STR {printf ("str ");} Variable STR {printf ("str ");} Variable {{

if ($3 != NULL) {if ($3 != NULL) { $3->inic = $3->ref = VERDADE;}$3->inic = $3->ref = VERDADE;} }} ;; Rodar o programa com o arquivo

tsimb032014.dat

Marcar as variáveis indexadas Marcar as variáveis indexadas escritasescritas, , precedidas pela palavra precedidas pela palavra strstr, como , como referenciadasreferenciadas

Na produção Na produção WriteElemWriteElem que usa que usa strstr::

WriteElem: WriteElem: STRING {printf ("\"%s\" ", $1);}STRING {printf ("\"%s\" ", $1);}| | ExpressionExpression| | STR {printf ("str ");} Variable STR {printf ("str ");} Variable

{{ if ($3 != NULL) {if ($3 != NULL) { $3->ref = VERDADE; }$3->ref = VERDADE; }

}} ;; Rodar o programa com o arquivo

tsimb032014.dat

Verificar se uma variável precedida pela Verificar se uma variável precedida pela palavra palavra strstr é indexada do tipo é indexada do tipo charchar


ReadElem: ReadElem: Variable { - - - - - }Variable { - - - - - }| | STR { - - - - - } Variable {STR { - - - - - } Variable {

if ($3 != NULL) {if ($3 != NULL) { $3->inic = $3->ref = VERDADE;$3->inic = $3->ref = VERDADE; if ($3->array == FALSO if ($3->array == FALSO

|| $3->tvar != CARACTERE)|| $3->tvar != CARACTERE)Incompatibilidade ("Variavel incompativel com Incompatibilidade ("Variavel incompativel com str");str");

}} }} ;;

Verificar se uma variável precedida pela palavra Verificar se uma variável precedida pela palavra strstr é indexada do tipo é indexada do tipo charchar


WriteElem: WriteElem: STRING {printf ("\"%s\" ", $1);}STRING {printf ("\"%s\" ", $1);}| | ExpressionExpression| | STR {printf ("str ");} Variable {STR {printf ("str ");} Variable {

if ($3 != NULL) {if ($3 != NULL) { $3->ref = VERDADE;$3->ref = VERDADE; if ($3->array == FALSO if ($3->array == FALSO

|| $3->tvar != CARACTERE)|| $3->tvar != CARACTERE)Incompatibilidade ("Variavel incompativel com str");Incompatibilidade ("Variavel incompativel com str");

}} }} ;; Rodar o programa com o arquivo

tsimb032014.dat

Verificar se uma variável de Verificar se uma variável de tipo escalartipo escalar tem tem subscritossubscritos

Na segunda produção de Na segunda produção de VariableVariable::

Variable:Variable: ID { - - - - - }ID { - - - - - } | | ID OPBRAK { - - - - - } SubscrListID OPBRAK { - - - - - } SubscrList CLBRAK {CLBRAK { printf ("] "); $$ = $<simb>3;printf ("] "); $$ = $<simb>3; if ($$ != NULL)if ($$ != NULL) if ($$->array == FALSO)if ($$->array == FALSO) NaoEsperado NaoEsperado

("Subscrito\(s)");("Subscrito\(s)"); }} ;;

Criar o protótipo:Criar o protótipo:

void NaoEsperado (char *);void NaoEsperado (char *);

E a função:E a função:

void NaoEsperado (char *s) {void NaoEsperado (char *s) {printf ("\n\n***** Nao Esperado: %s *****\n\printf ("\n\n***** Nao Esperado: %s *****\n\n", s);n", s);}}

Rodar o programa com o arquivo tsimb032014.dat

Verificar se uma variável Verificar se uma variável indexadaindexada não não precedida pela palavra reservada precedida pela palavra reservada strstr não tem não tem subscritossubscritos

Criar o flag global Criar o flag global usastrusastr para sinalizar se uma para sinalizar se uma variável vem precedida da palavra variável vem precedida da palavra strstr

Na produção Na produção StatsStats::

StatsStats : : STATEMENTS {STATEMENTS {printf ("statements "); printf ("statements "); usastr = FALSO;usastr = FALSO;

} CompStat} CompStat ;;



ReadElem: ReadElem: Variable { - - - - - }Variable { - - - - - }| | STR {printf ("str "); STR {printf ("str "); usastr = usastr =

VERDADE; VERDADE; } } Variable {Variable {

if ($3 != NULL) { - - - - - }if ($3 != NULL) { - - - - - } usastr = FALSO;usastr = FALSO; }} ;;



WriteElem: WriteElem: STRING { - - - - - }STRING { - - - - - }| | ExpressionExpression| | STR {printf ("str "); STR {printf ("str "); usastr = usastr =

VERDADE;VERDADE; } } Variable {Variable {

if ($3 != NULL) { - - - - - }if ($3 != NULL) { - - - - - } usastr = FALSO;usastr = FALSO; }} ;;

Verificar se uma variável Verificar se uma variável indexadaindexada não precedida não precedida pela palavra reservada pela palavra reservada strstr não tem não tem subscritossubscritos

Na primeira produção Na primeira produção VariableVariable::

Variable: Variable: ID { - - - - -ID { - - - - - $$ = simb;$$ = simb; if ($$ != NULL)if ($$ != NULL) if ($$->array == VERDADE) if ($$->array == VERDADE)

if (usastr == FALSO)if (usastr == FALSO) Esperado Esperado

("Subscrito\(s)");("Subscrito\(s)"); }} | | ID OPBRAK { - - - - - } SubscrList ID OPBRAK { - - - - - } SubscrList

CLBRAK { - - - - - }CLBRAK { - - - - - } ;;

Rodar o programa com o arquivo tsimb032014.dat

Verificar se o Verificar se o número de subscritosnúmero de subscritos de uma de uma variável indexada não precedida pela palavra variável indexada não precedida pela palavra strstr é é igual ao seu igual ao seu número de dimensõesnúmero de dimensões declarado declarado

Verificar se o Verificar se o número de subscritosnúmero de subscritos de uma de uma variável indexada precedida pela palavra variável indexada precedida pela palavra strstr é igual é igual ao seu ao seu número de dimensõesnúmero de dimensões declarado declarado menos 1menos 1

Deve-se obter o Deve-se obter o número de subscritosnúmero de subscritos que que aparecem depois do nome de uma aparecem depois do nome de uma variávelvariável

Em seguida, deve-se Em seguida, deve-se compararcomparar esse número com o esse número com o número de dimensõesnúmero de dimensões desse nome na tabela de desse nome na tabela de símbolossímbolos

É necessário verificar se esse nome é precedido É necessário verificar se esse nome é precedido pela palavra pela palavra strstr

O não-terminal O não-terminal SubscrListSubscrList terá como atributo o terá como atributo o número de subscritos:número de subscritos:

%union {%union {char cadeia[50]; int atr, valint; float valreal; char char cadeia[50]; int atr, valint; float valreal; char carac;carac;simbolo simb; int tipoexpr;simbolo simb; int tipoexpr;int nsubscr;int nsubscr;

}}

%type%type <simb> <simb> VariableVariable%type%type <tipoexpr> Expression AuxExpr1 <tipoexpr> Expression AuxExpr1

AuxExpr2AuxExpr2 AuxExpr3 AuxExpr4 Term AuxExpr3 AuxExpr4 Term

FactorFactor%type <nsubscr> SubscrList%type <nsubscr> SubscrList

Nas produções de Nas produções de SubscrListSubscrList::

SubscrList: SubscrList: AuxExpr4 {AuxExpr4 { if ($1 != INTEIRO && $1 != CARACTERE)if ($1 != INTEIRO && $1 != CARACTERE) Incompatibilidade ("Tipo inadequado para Incompatibilidade ("Tipo inadequado para

subscrito");subscrito"); $$ = 1;$$ = 1;

}}| | SubscrList COMMA {printf (", ");} SubscrList COMMA {printf (", ");} AuxExpr4 {AuxExpr4 {

if ($4 != INTEIRO && $4 != CARACTERE)if ($4 != INTEIRO && $4 != CARACTERE) Incompatibilidade ("Tipo inadequado para Incompatibilidade ("Tipo inadequado para

subscrito");subscrito"); $$ = $1 + 1;$$ = $1 + 1;

}};;

Nas produções de Nas produções de VariableVariable::

Variable: Variable: ID { - - - - - $$ = simb;ID { - - - - - $$ = simb; if ($$ != NULL) if ($$->array == VERDADE)if ($$ != NULL) if ($$->array == VERDADE) if (usastr == FALSO) Esperado ("Subscrito\(s)");if (usastr == FALSO) Esperado ("Subscrito\(s)"); else if ($$->ndims != 1) Esperado ("Subscrito\else if ($$->ndims != 1) Esperado ("Subscrito\

(s)"); (s)"); }}

| ID OPBRAK { - - - - - } SubscrList CLBRAK { - - - - - $$ = $<simb>3;| ID OPBRAK { - - - - - } SubscrList CLBRAK { - - - - - $$ = $<simb>3; if ($$ != NULL)if ($$ != NULL) if ($$->array == FALSO) NaoEsperado ("Subscrito\(s)");if ($$->array == FALSO) NaoEsperado ("Subscrito\(s)"); else if (usastr == FALSO) {else if (usastr == FALSO) { if ($4 != $$->ndims)if ($4 != $$->ndims) Incompatibilidade ("Numero de subscritos incompativel com Incompatibilidade ("Numero de subscritos incompativel com

declaracao"); }declaracao"); } else if ($4 != $$->ndims - 1)else if ($4 != $$->ndims - 1) Incompatibilidade ("Numero de subscritos incompativel com Incompatibilidade ("Numero de subscritos incompativel com

declaracao");declaracao"); }};; Rodar o programa com o arquivo

tsimb032014.dat

CES-41 COMPILADORES Aulas Práticas - 2014 Capítulo III Análise Semântica no Yacc.

Documents

Transcript of CES-41 COMPILADORES Aulas Práticas - 2014 Capítulo III Análise Semântica no Yacc.