CES-41 COMPILADORES Aulas Práticas - 2014

CES-41 CES-41 COMPILADORESCOMPILADORES

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

Capítulo IV Capítulo IV

Código Intermediário Código Intermediário no Yaccno Yacc

O sub-set da Linguagem O sub-set da Linguagem COMP-ITA-2014COMP-ITA-2014, , usado no final do capítulo anterior, contém:usado no final do capítulo anterior, contém:

Comandos de atribuição, compostos, Comandos de atribuição, compostos, entrada e saída, condicionais, while, entrada e saída, condicionais, while, variáveis escalares e indexadasvariáveis escalares e indexadas

Seja essa linguagem chamada de Seja essa linguagem chamada de Sub-Set2 Sub-Set2 20142014

Seja o programa a seguir, escrito em Seja o programa a seguir, escrito em Sub-Set2 Sub-Set2 20142014, para encontrar números primos, para encontrar números primos

program primosprogram primoslocal {logic achou; int n, div, resto, cont, num;}local {logic achou; int n, div, resto, cont, num;}statements {statements {

read (n);read (n); write (n, " primeiros numeros naturais primos:\n\n");write (n, " primeiros numeros naturais primos:\n\n");

if n > 0 then {if n > 0 then {num = 1; cont = 0;num = 1; cont = 0;while cont < n do {while cont < n do {

num = num + 1; div = 2; achou = false;num = num + 1; div = 2; achou = false;while achou == false && div * div <= num do {while achou == false && div * div <= num do {

resto = num % div;resto = num % div;if resto == 0 then achou = true;if resto == 0 then achou = true;else div = div + 1;else div = div + 1;

}}if achou == false then {if achou == false then {

write (num, "\n"); cont = cont + 1;write (num, "\n"); cont = cont + 1;}}

}}}}

}}

Um possível código intermediário não Um possível código intermediário não otimizado:otimizado:

program primosprogram primoslocal {logic achou; int n, div, resto, cont, num;}local {logic achou; int n, div, resto, cont, num;}

1) OPENMOD, (MODULO, primos), (IDLE), (IDLE)1) OPENMOD, (MODULO, primos), (IDLE), (IDLE)

read (n);read (n);

2) PARAM, (VAR, n), (IDLE), (IDLE)2) PARAM, (VAR, n), (IDLE), (IDLE)

3) 3) READ, (INT, 1), (IDLE), (IDLE)READ, (INT, 1), (IDLE), (IDLE)

if n > 0 then {if n > 0 then {

- - - - -- - - - -

}}

4) GT, (VAR, n), (INT, 0), (VAR, ##1)4) GT, (VAR, n), (INT, 0), (VAR, ##1)

5) JF, (VAR, ##1), (IDLE), (ROTULO, 42)5) JF, (VAR, ##1), (IDLE), (ROTULO, 42)

- - - - -- - - - -

42) NOP, (IDLE), (IDLE), (IDLE)42) NOP, (IDLE), (IDLE), (IDLE)

num = 0; cont = 0;num = 0; cont = 0;

6) ATRIB, (INT, 0), (IDLE), (VAR, num)6) ATRIB, (INT, 0), (IDLE), (VAR, num)

7) ATRIB, (INT, 0), (IDLE), (VAR, cont)7) ATRIB, (INT, 0), (IDLE), (VAR, cont)

NOP: no operation

Todos os desvios serão feitos para quádruplas com NOP’s

Facilitam a programação

Devem ser eliminadas na fase de otimização

while cont < n do {while cont < n do {

- - - - -- - - - -

}}


9) LT, (VAR, cont), (VAR, n), (VAR, ##2)9) LT, (VAR, cont), (VAR, n), (VAR, ##2)


- - - - -- - - - -

40) JUMP, (IDLE), (IDLE), (ROTULO, 8)40) JUMP, (IDLE), (IDLE), (ROTULO, 8)


num = num + 1; div = 2; achou = false;num = num + 1; div = 2; achou = false;

11) MAIS, (VAR, num), (INT, 1), (VAR, ##3)11) MAIS, (VAR, num), (INT, 1), (VAR, ##3)

12) ATRIB, (VAR, ##3), (IDLE), (VAR, num)12) ATRIB, (VAR, ##3), (IDLE), (VAR, num)

13) ATRIB, (INT, 2), (IDLE), (VAR, div)13) ATRIB, (INT, 2), (IDLE), (VAR, div)

14) ATRIB, (LOGIC, 0), (IDLE), (VAR, achou)14) ATRIB, (LOGIC, 0), (IDLE), (VAR, achou)

NOP: no operation

Todos os desvios serão feitos para quádruplas com NOP’s

Facilitam a programação

Devem ser eliminadas na fase de otimização

while achou == false && div * div <= num do {while achou == false && div * div <= num do {

- - - - -- - - - -

}}


16) EQ, (VAR, achou), (LOGIC, 0), (VAR, ##4)16) EQ, (VAR, achou), (LOGIC, 0), (VAR, ##4)

17) MULT, (VAR, div), (VAR, div), (VAR, ##5)17) MULT, (VAR, div), (VAR, div), (VAR, ##5)

18) LE, (VAR, ##5), (VAR, num), (VAR, ##6)18) LE, (VAR, ##5), (VAR, num), (VAR, ##6)

19) AND, (VAR, ##4), (VAR, ##6), (VAR, ##7)19) AND, (VAR, ##4), (VAR, ##6), (VAR, ##7)


- - - - -- - - - -



resto = num % div;resto = num % div;if resto == 0 then achou = true;if resto == 0 then achou = true;else div = div + 1;else div = div + 1;

21) RESTO, (VAR, num), (VAR, div), (VAR, ##8)21) RESTO, (VAR, num), (VAR, div), (VAR, ##8)

22) ATRIB, (VAR, ##8), (IDLE), (VAR, resto)22) ATRIB, (VAR, ##8), (IDLE), (VAR, resto)

23) EQ, (VAR, resto), (INT, 0), (VAR, ##9)23) EQ, (VAR, resto), (INT, 0), (VAR, ##9)


25) ATRIB, (LOGIC, 1), (IDLE), (VAR, achou)25) ATRIB, (LOGIC, 1), (IDLE), (VAR, achou)



28) MAIS, (VAR, div), (INT, 1), (VAR, ##10)28) MAIS, (VAR, div), (INT, 1), (VAR, ##10)

29) ATRIB, (VAR, ##10), (IDLE), (VAR, div)29) ATRIB, (VAR, ##10), (IDLE), (VAR, div)


if achou == false then {write (num); cont = cont + if achou == false then {write (num); cont = cont + 1;}1;}

33) EQ, (VAR, achou), (LOGIC, 0), (VAR, ##11)33) EQ, (VAR, achou), (LOGIC, 0), (VAR, ##11)


35) PARAM, (VAR, num), (IDLE), (IDLE)35) PARAM, (VAR, num), (IDLE), (IDLE)

36) WRITE, 1, (IDLE), (IDLE) 36) WRITE, 1, (IDLE), (IDLE)

37) MAIS, (VAR, cont), (INT, 1), (VAR, ##12)37) MAIS, (VAR, cont), (INT, 1), (VAR, ##12)

38) ATRIB, (VAR, ##12), (IDLE), (VAR, cont)38) ATRIB, (VAR, ##12), (IDLE), (VAR, cont)


Cada linha do código intermediário chama-se quádrupla

Estrutura de dados para o código intermediário de linguagens contendo subprogramas:

Cada lista de quádruplas fica acoplada a um mod-head

As quádruplas do módulo de tipo glob destinam-se a:

Alocar as variáveis globais

Acionar a execução do módulo principal (main)

E encerrar tudo no final

Cada lista de quádruplas tem um nó-lider

Estrutura de dados para código intermediário de linguagens sem subprogramas:

O primeiro mod-head seria dispensável

Ele é usado prevendo a implementação do módulo global

A primeira quádrupla é uma quádrupla-líder, sem conteúdo

Esta estrutura será usada nas próximas aulas

No projeto será usada a do slide anterior

Programa 4.1:Programa 4.1:

O arquivo O arquivo inter012014.y inter012014.y tem um analisador tem um analisador semântico quase acabado para a linguagem semântico quase acabado para a linguagem Sub-Sub-Set2 2014Set2 2014

O arquivo O arquivo inter012014.linter012014.l é seu analisador léxico é seu analisador léxico

O arquivo O arquivo inter012014.y inter012014.y contém ainda contém ainda declarações e funções para auxiliar a construção declarações e funções para auxiliar a construção do código intermediáriodo código intermediário

Rodar esses arquivos com Rodar esses arquivos com inter012014.datinter012014.dat

A seguir, uma descrição dessas A seguir, uma descrição dessas declaraçõesdeclarações e e funçõesfunções

Estrutura de uma quádrupla:Estrutura de uma quádrupla:

typedef struct celquad celquad; typedef struct celquad celquad;

typedef celquad *quadrupla; typedef celquad *quadrupla;

struct celquad {struct celquad {

int num, oper; operando opnd1, opnd2, int num, oper; operando opnd1, opnd2, result;result;

quadrupla prox;quadrupla prox;

};};

O campo O campo num num numera as quádruplasnumera as quádruplas

Não é necessário na compilaçãoNão é necessário na compilação Foi colocado por razões didáticas Foi colocado por razões didáticas

Um Um operandooperando tem dois campos: o tem dois campos: o tipotipo e o e o atributoatributo

oper opnd1

opnd2

result

prox

nu

m

celquad

Estrutura de um operando:Estrutura de um operando:

typedef struct operando operando; typedef struct operando operando;

struct operando {struct operando {

int tipo; atribopnd atr;int tipo; atribopnd atr;

};};

Os tipos dos operandos são:Os tipos dos operandos são:

Operando vazio (idle) Operando vazio (idle) Nome de variávelNome de variável Constantes inteira, real, lógica e caractereConstantes inteira, real, lógica e caractere Cadeia de caracteresCadeia de caracteres Rótulo de quádruplas (ponteiro para Rótulo de quádruplas (ponteiro para

quádruplas)quádruplas) Nome de móduloNome de módulo

tipo

atr

(simb, valint, valfloat, valchar, vallogic, valcad, rotulo, modulo)

operando

Estrutura do atributo de um operando:Estrutura do atributo de um operando:

typedef union atribopnd atribopnd; typedef union atribopnd atribopnd;

union atribopnd {union atribopnd {

simbolo simb; int valint; float valfloat;simbolo simb; int valint; float valfloat;

char valchar; char vallogic; char *valcad;char valchar; char vallogic; char *valcad;

quadrupla rotulo; modhead modulo;quadrupla rotulo; modhead modulo;

};};

Tabela dos atributos conforme o tipo de Tabela dos atributos conforme o tipo de operando:operando:Tipo Atributo Tipo Atributo

Idle - Constante caractere valchar

Nome de variável simb Cadeia de caracteres

valcad

Constante inteira valint Rótulo de quádrupla rotulo

Constante real valfloat Nome de módulo modulo

Constante lógica vallogic

tipo

atr

(simb, valint, valfloat, valchar, vallogic, valcad, rotulo, modulo)

operando

Estrutura de um cabeçalho de módulo:Estrutura de um cabeçalho de módulo:

typedef struct celmodhead celmodhead;typedef struct celmodhead celmodhead;

typedef celmodhead *modhead; typedef celmodhead *modhead;

struct celmodhead {struct celmodhead {

simbolo modname; modhead prox;simbolo modname; modhead prox;

int modtip;int modtip;

quadrupla listquad;quadrupla listquad;

};};

modname

modtip

celmodhead

prox

listquad

Variáveis globais:Variáveis globais:

quadrupla quadcorrente, quadaux;quadrupla quadcorrente, quadaux;modhead codintermed, modcorrente;modhead codintermed, modcorrente;int oper, numquadcorrente;int oper, numquadcorrente;operando opnd1, opnd2, result, opndaux;operando opnd1, opnd2, result, opndaux;int numtemp;int numtemp;const operando opndidle = {IDLEOPND, 0};const operando opndidle = {IDLEOPND, 0};

quadcorrente: quadcorrente: ponteiro para a ponteiro para a celquadcelquad recém-alocada recém-alocada

codintermed: codintermed: ponteiro que dá acesso a todo o código ponteiro que dá acesso a todo o código intermediáriointermediário

modcorrente: modcorrente: ponteiro para a última ponteiro para a última celmodheadcelmodhead alocadaalocada

numtemp:numtemp: usada para controlar a concessão de nomes a usada para controlar a concessão de nomes a variáveis temporáriasvariáveis temporárias

opndidle:opndidle: constante do tipo operando para preencher constante do tipo operando para preencher operandos vazios nas quádruplasoperandos vazios nas quádruplas

Novas definições para os tipos dos Novas definições para os tipos dos identificadores:identificadores:

Relembrando as definições para os tipos Relembrando as definições para os tipos de variáveis:de variáveis:

#define IDPROG 1#define IDVAR 2#define IDFUNC 3#define IDPROC 4#define IDGLOB 5

#define NAOVAR 0#define INTEIRO 1#define LOGICO 2#define REAL

3#define CARACTERE 4

Definições de constantes para operadores Definições de constantes para operadores de quádruplas:de quádruplas:

#define OPOR1

#define OPAND 2#define OPLT

3#define OPLE 4#define OPGT

5#define OPGE

6#define OPEQ

7#define OPNE

8#define OPMAIS 9#define OPMENOS10

#define OPMULTIP11

#define OPDIV 12#define OPRESTO 13#define OPMENUN

14#define OPNOT 15#define OPATRIB 16#define OPENMOD

17#define NOP 18#define OPJUMP 19#define OPJF 20

Definições de constantes para os tipos dos Definições de constantes para os tipos dos operandos:operandos:

#define IDLEOPND0

#define VAROPND 1#define INTOPND 2#define REALOPND

3#define CHAROPND

4#define LOGICOPND 5#define CADOPND 6#define ROTOPND 7#define MODOPND

8

Protótipos das funções para o código Protótipos das funções para o código intermediário:intermediário:

void InicCodIntermed (void);void InicCodIntermed (void);

void InicCodIntermMod (simbolo);void InicCodIntermMod (simbolo);

quadrupla GeraQuadrupla (int, operando, quadrupla GeraQuadrupla (int, operando, operando, operando, operando);operando);

simbolo NovaTemp (int);simbolo NovaTemp (int);

void ImprimeQuadruplas (void);void ImprimeQuadruplas (void);

void RenumQuadruplas (quadrupla, void RenumQuadruplas (quadrupla, quadrupla);quadrupla);

Função Função InicCodIntermedInicCodIntermed::

void InicCodIntermed () {void InicCodIntermed () {

codintermed = malloc (sizeof (celmodhead));codintermed = malloc (sizeof (celmodhead));

modcorrente = codintermed;modcorrente = codintermed;

modcorrente->listquad = NULL;modcorrente->listquad = NULL;

modcorrente->prox = NULL;modcorrente->prox = NULL;

}}

codintermed

modname

modtip

prox

listquad

modcorrente

●

●

Função Função InicCodIntermMod (simbolo simb)InicCodIntermMod (simbolo simb)::

void InicCodIntermMod (simbolo simb) {void InicCodIntermMod (simbolo simb) {modcorrente->prox = malloc (sizeof modcorrente->prox = malloc (sizeof (celmodhead));(celmodhead));modcorrente = modcorrente->prox;modcorrente = modcorrente->prox;modcorrente->prox = NULL;modcorrente->prox = NULL;modcorrente->modname = simb;modcorrente->modname = simb;modcorrente->modtip = simb->tid;modcorrente->modtip = simb->tid;modcorrente->listquad = malloc (sizeof modcorrente->listquad = malloc (sizeof (celquad));(celquad));quadcorrente = modcorrente->listquad;quadcorrente = modcorrente->listquad;quadcorrente->prox = NULL;quadcorrente->prox = NULL;numquadcorrente = 0;numquadcorrente = 0;quadcorrente->num = numquadcorrente;quadcorrente->num = numquadcorrente;

}}

codintermed

simb

num

oper ####

opnd1 ####

opnd2 ####

result ####

prox quadcorrente

●

0

modname

modtip

prox

listquad

modname

modtip

prox

listquad

modcorrente

●

● ●

cadeia tid

Função Função GeraQuadrupla (oper, opnd1, GeraQuadrupla (oper, opnd1, opnd2, result)opnd2, result)::

quadrupla GeraQuadrupla (int oper, operando quadrupla GeraQuadrupla (int oper, operando opnd1, operando opnd2, operando result) {opnd1, operando opnd2, operando result) {

quadcorrente->prox = malloc (sizeof (celquad));quadcorrente->prox = malloc (sizeof (celquad));

quadcorrente = quadcorrente->prox;quadcorrente = quadcorrente->prox;

quadcorrente->oper = oper;quadcorrente->oper = oper;

quadcorrente->opnd1 = opnd1;quadcorrente->opnd1 = opnd1;

quadcorrente->opnd2 = opnd2;quadcorrente->opnd2 = opnd2;

quadcorrente->result = result;quadcorrente->result = result;

quadcorrente->prox = NULL;quadcorrente->prox = NULL;

numquadcorrente ++;numquadcorrente ++;

quadcorrente->num = numquadcorrente;quadcorrente->num = numquadcorrente;

return quadcorrente;return quadcorrente;

}}

num 452

oper X

opnd1 YYYY

opnd2 ZZZZ

result WWWW

prox

quadcorrente

●

453

Roper SSSSopnd1

TTTTopnd2

VVVVresult

TTTT

SSSS

VVVV

R

●

num

oper

opnd1

opnd2

result

prox valor

retornado

Função Função Novatemp (tip)Novatemp (tip)::

simbolo NovaTemp (int tip) {simbolo NovaTemp (int tip) {

simbolo simb; int temp, i, j;simbolo simb; int temp, i, j;

char nometemp[10] = "##", s[10] = {0};char nometemp[10] = "##", s[10] = {0};

numtemp ++; temp = numtemp;numtemp ++; temp = numtemp;

for (i = 0; temp > 0; temp /= 10, i++)for (i = 0; temp > 0; temp /= 10, i++)

s[i] = temp % 10 + '0';s[i] = temp % 10 + '0';

i --;i --;

for (j = 0; j <= i; j++)for (j = 0; j <= i; j++)

nometemp[2+i-j] = s[j];nometemp[2+i-j] = s[j];

simb = InsereSimb (nometemp, IDVAR, tip);simb = InsereSimb (nometemp, IDVAR, tip);

simb->inic = simb->ref = VERDADE;simb->inic = simb->ref = VERDADE;

simb->array = FALSO;simb->array = FALSO; return simb;return simb;

}}

Gera um nome para uma nova variável temporária

O nome começa com ## e termina com um número

O número é a soma do último utilizado +1

O nome é inserido na TabSimb e marcado como inicializado e referenciado

Retorna um ponteiro para a célula inserida na TabSimbO tipo da nova variável vem como argumento

Os Os operandosoperandos para as para as quádruplasquádruplas que calculam que calculam o valor de o valor de expressõesexpressões devem estar nos devem estar nos atributosatributos dos não-terminais para a montagem de dos não-terminais para a montagem de expressõesexpressões

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

Term : Term MULTOP FactorTerm : Term MULTOP Factor

Deve ser gerada a quádrupla com:Deve ser gerada a quádrupla com:

operador operador correspondente ao atributo de correspondente ao atributo de MULTOPMULTOP

primeiro operando: primeiro operando: no atributo de no atributo de Term Term do do lado lado direitodireito

segundo operando:segundo operando: no atributo de no atributo de FactorFactor

operando resultado:operando resultado: no atributo de no atributo de Term Term do lado do lado esquerdoesquerdo

Não-terminais para a montagem de expressões:Não-terminais para a montagem de expressões:

Expression, AuxExpr1, AuxExpx2, Expression, AuxExpr1, AuxExpx2, AuxExpr3, AuxExpr4, Term, FactorAuxExpr3, AuxExpr4, Term, Factor

Esses não-terminais já guardam seus Esses não-terminais já guardam seus tipostipos em em seus atributos, para os testes de seus atributos, para os testes de compatibilidadecompatibilidade entre operadores e entre operadores e operandos:operandos:

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

Agora, o atributo desses não-terminais deverá Agora, o atributo desses não-terminais deverá ter dois campos:ter dois campos:

o o tipotipo e o e o operandooperando

Seja também a produção:Seja também a produção:

Factor : VariableFactor : Variable

É conveniente também que o não-terminal É conveniente também que o não-terminal Variable Variable carregue um carregue um operandooperando em seu atributo, em seu atributo, para que o operando de para que o operando de FactorFactor receba esse receba esse operandooperando

Esse não-terminal já guarda em seu atributo um Esse não-terminal já guarda em seu atributo um ponteiroponteiro para a para a TabSimbTabSimb, para os testes de , para os testes de compatibilidadecompatibilidade entre operadores e operandos: entre operadores e operandos:

%type <simb> Variable%type <simb> Variable

Agora, o atributo desse não-terminal deverá ter Agora, o atributo desse não-terminal deverá ter dois campos:dois campos:

o referido ponteiro e o o referido ponteiro e o operandooperando

Novas declarações para atributos de expressões e Novas declarações para atributos de expressões e variáveis:variáveis:

typedef struct infoexpressao infoexpressao;typedef struct infoexpressao infoexpressao;

struct infoexpressao { int tipo; operando opnd; };struct infoexpressao { int tipo; operando opnd; };

typedef struct infovariavel infovariavel;typedef struct infovariavel infovariavel;

struct infovariavel { simbolo simb; operando opnd; };struct infovariavel { simbolo simb; operando opnd; };

Novos campos para a declaração Novos campos para a declaração %union%union::

%union {%union {

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

infoexpressao infoexpr;infoexpressao infoexpr; infovariavel infovar; infovariavel infovar;

simbolo simb; int dim; int nsubscr;simbolo simb; int dim; int nsubscr;

}}

Novos campos para a declaração Novos campos para a declaração %union%union::

%union {%union {

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

infoexpressao infoexpr;infoexpressao infoexpr; infovariavel infovariavel infovar;infovar;

simbolo simb; int dim; int nsubscr;simbolo simb; int dim; int nsubscr;

}}

Novas especificações para os atributos dos Novas especificações para os atributos dos não-terminais envolvidos:não-terminais envolvidos:

%type <%type <infovarinfovar> > VariableVariable

%type <%type <infoexprinfoexpr> > Expression AuxExpr1 Expression AuxExpr1 AuxExpr2 AuxExpr2 AuxExpr3 AuxExpr3 AuxExpr4 Term FactorAuxExpr4 Term Factor

Antes era <simb>

Antes era <tipoexpr>

Nas produções onde aparecem não-terminais Nas produções onde aparecem não-terminais envolvidos no cálculo de expressões foi trocado envolvidos no cálculo de expressões foi trocado $$$$ por por $$.tipo$$.tipo e e $1$1, , $2$2, etc. por , etc. por $1.tipo$1.tipo, , $2.tipo$2.tipo, etc., etc.

Nas ocorrências de atributos do não terminal Nas ocorrências de atributos do não terminal VariableVariable, foi trocado , foi trocado $$$$ por por $$.simb$$.simb e e $1$1, , $2$2, etc. por , etc. por $1.simb$1.simb, , $2.simb$2.simb, etc., etc.

Exercício 4.1: Exercício 4.1: Inicializar o código intermediário e Inicializar o código intermediário e a lista de quádruplas do único módulo,a lista de quádruplas do único módulo, imprimindo-as (a lista é vazia)imprimindo-as (a lista é vazia)

Na produção do não-terminal Na produção do não-terminal ProgProg::

ProgProg :: {{

InicTabSimb (); InicTabSimb (); InicCodIntermed (); numtemp InicCodIntermed (); numtemp = 0;= 0;

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

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

InicCodIntermMod (simb);InicCodIntermMod (simb);

} LocDecls Stats {} LocDecls Stats {

VerificaInicRef (); ImprimeTabSimb (); VerificaInicRef (); ImprimeTabSimb ();

ImprimeQuadruplas ();ImprimeQuadruplas ();

}}

;;

Acrescentar ao arquivo inter012014.y o código em destaque Rodar com o arquivo inter012014.dat

Exercício 4.2: Exercício 4.2: Inserir a quádrupla Inserir a quádrupla OPENMODOPENMOD

Ainda na produção do não-terminal Ainda na produção do não-terminal ProgProg::

Prog:Prog: {- - - - -} PROGRAM ID {{- - - - -} PROGRAM ID {

- - - - -- - - - -

InicCodIntermMod (simb);InicCodIntermMod (simb);

opnd1.tipo = MODOPND;opnd1.tipo = MODOPND;

opnd1.atr.modulo = modcorrente;opnd1.atr.modulo = modcorrente;

GeraQuadrupla (OPENMOD, opnd1, GeraQuadrupla (OPENMOD, opnd1, opndidle, opndidle);opndidle, opndidle);

} LocDecls Stats {} LocDecls Stats {

- - - - -- - - - -

}}

;;

Acrescentar ao arquivo inter012014. y o código em destaqueRodar com o arquivo inter012014. dat

Exercício 4.3: Exercício 4.3: Inserir quádruplas para Inserir quádruplas para expressões sem variáveis indexadasexpressões sem variáveis indexadas

Exemplo:Exemplo: as quádruplas para a expressão: as quádruplas para a expressão:

(i+3 >= j-2) && b2(i+3 >= j-2) && b2

sendo: sendo: int i, j; logic b2;int i, j; logic b2;

podem ser: podem ser:

MAIS, (VAR, i), (INT, 3), (VAR, ##1)MAIS, (VAR, i), (INT, 3), (VAR, ##1)

MENOS, (VAR, j), (INT, 2), (VAR, ##2)MENOS, (VAR, j), (INT, 2), (VAR, ##2)

GE, (VAR, ##1), (VAR, ##2), (VAR, ##3)GE, (VAR, ##1), (VAR, ##2), (VAR, ##3)

AND, (VAR, ##3), (VAR, b2), (VAR, ##4)AND, (VAR, ##3), (VAR, b2), (VAR, ##4)

É necessária uma É necessária uma programaçãoprogramação em todos os em todos os não-terminais envolvendo não-terminais envolvendo expressõesexpressões

Em toda produção que contribui para a Em toda produção que contribui para a formação de expressõesformação de expressões, deve-se calcular o , deve-se calcular o atributo operandoatributo operando do não-terminal do do não-terminal do lado lado esquerdoesquerdo

Numa produção onde aparece Numa produção onde aparece operadoroperador de de expressões, além desse cálculo, deve-se expressões, além desse cálculo, deve-se gerar gerar quádruplaquádrupla com a com a operaçãooperação correspondente e correspondente e com os com os atributos operandosatributos operandos dos não- dos não-terminais de expressõesterminais de expressões

Na 1ª produção do não-terminal Na 1ª produção do não-terminal Variable Variable (sem (sem subscritos), calcula-se seu subscritos), calcula-se seu operandooperando::

Variable: ID { - - - - -Variable: ID { - - - - -

$$.simb = simb;$$.simb = simb;

if ($$.simb != NULL) if ($$.simb != NULL) {{

if ($$.simb->array == VERDADE)if ($$.simb->array == VERDADE)

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

Esperado ("Subscrito\(s)");Esperado ("Subscrito\(s)");

else if ($$.simb->ndims != 1)else if ($$.simb->ndims != 1)

Esperado ("Subscrito\(s)");Esperado ("Subscrito\(s)");

$$.opnd.tipo = VAROPND;$$.opnd.tipo = VAROPND;

$$.opnd.atr.simb = $$.simb;$$.opnd.atr.simb = $$.simb;

}}

}}

Nas produções sem operadores do não-Nas produções sem operadores do não-terminal terminal FactorFactor, calcula-se seu , calcula-se seu operandooperando::

FactorFactor : Variable {: Variable {

if ($1.simb != NULL) {if ($1.simb != NULL) {

- - - - - $$.tipo = $1.simb->tvar; - - - - - $$.tipo = $1.simb->tvar; $$.opnd $$.opnd = $1.opnd; = $1.opnd; }}

}}

| INTCT { - - - - - $$.tipo = INTEIRO;| INTCT { - - - - - $$.tipo = INTEIRO;

$$.opnd.tipo = INTOPND;$$.opnd.tipo = INTOPND;

$$.opnd.atr.valint = $1;$$.opnd.atr.valint = $1;

}}

| FLOATCT { - - - - - $$.tipo = REAL;| FLOATCT { - - - - - $$.tipo = REAL;

$$.opnd.tipo = REALOPND;$$.opnd.tipo = REALOPND;

$$.opnd.atr.valfloat = $1;$$.opnd.atr.valfloat = $1;

}}

Factor: CHARCT { - - - - - $$.tipo = CARACTERE;Factor: CHARCT { - - - - - $$.tipo = CARACTERE;

$$.opnd.tipo = CHAROPND;$$.opnd.tipo = CHAROPND;

$$.opnd.atr.valchar = $1;$$.opnd.atr.valchar = $1;

}}

| TRUE { - - - - - $$.tipo = LOGICO;| TRUE { - - - - - $$.tipo = LOGICO;

$$.opnd.tipo = LOGICOPND;$$.opnd.tipo = LOGICOPND;

$$.opnd.atr.vallogic = 1;$$.opnd.atr.vallogic = 1;

}}

| FALSE { - - - - - $$.tipo = LOGICO;| FALSE { - - - - - $$.tipo = LOGICO;

$$.opnd.tipo = LOGICOPND;$$.opnd.tipo = LOGICOPND;

$$.opnd.atr.vallogic = 0;$$.opnd.atr.vallogic = 0;

}}

| OPPAR {- - - - -} Expression CLPAR {| OPPAR {- - - - -} Expression CLPAR {

- - - - - $$.tipo = $3.tipo; - - - - - $$.tipo = $3.tipo; $$.opnd = $3.opnd;$$.opnd = $3.opnd;

}}

Na produção do não-terminal Na produção do não-terminal FactorFactor, com o , com o operador operador NEGNEG gera-se uma quádrupla, além de gera-se uma quádrupla, além de calcular o operando do lado esquerdo:calcular o operando do lado esquerdo:

FactorFactor : NEG {- - - - -} Factor {: NEG {- - - - -} Factor {

if ( - - - - - ) Incompatibilidade ( - - - - - );if ( - - - - - ) Incompatibilidade ( - - - - - );

if ($3.tipo == REAL) $$.tipo = REAL;if ($3.tipo == REAL) $$.tipo = REAL;

else $$.tipo = INTEIRO;else $$.tipo = INTEIRO;

$$.opnd.tipo = VAROPND;$$.opnd.tipo = VAROPND;

$$.opnd.atr.simb = NovaTemp ($$.tipo);$$.opnd.atr.simb = NovaTemp ($$.tipo);

GeraQuadrupla (OPMENUN, $3.opnd, GeraQuadrupla (OPMENUN, $3.opnd, opndidle, $$.opnd);opndidle, $$.opnd);

} }

;;Rodar com o arquivo inter012014. dat

Produções do não-terminal Produções do não-terminal TermTerm::

Term : Factor Term : Factor /* default: $$ = $1 *//* default: $$ = $1 */|| Term MULTOP {- - - - -} Factor {Term MULTOP {- - - - -} Factor {

switch ($2) {switch ($2) {case MULT: case DIV: - - - - -case MULT: case DIV: - - - - -

$$.opnd.tipo = VAROPND; $$.opnd.tipo = VAROPND; $$.opnd.atr.simb = NovaTemp ($$.tipo);$$.opnd.atr.simb = NovaTemp ($$.tipo);if ($2 == MULT) if ($2 == MULT) GeraQuadrupla (OPMULTIP, $1.opnd, $4.opnd, GeraQuadrupla (OPMULTIP, $1.opnd, $4.opnd,

$$.opnd);$$.opnd);else GeraQuadrupla (OPDIV, $1.opnd, $4.opnd, $else GeraQuadrupla (OPDIV, $1.opnd, $4.opnd, $

$.opnd);$.opnd); break;break;

case RESTO: - - - - -case RESTO: - - - - -$$.opnd.tipo = VAROPND; $$.opnd.tipo = VAROPND; $$.opnd.atr.simb = NovaTemp ($$.tipo);$$.opnd.atr.simb = NovaTemp ($$.tipo);GeraQuadrupla (OPRESTO, $1.opnd, $4.opnd, $GeraQuadrupla (OPRESTO, $1.opnd, $4.opnd, $

$.opnd);$.opnd);break;break;

}}}};;

Rodar com o arquivo inter012014. dat

Fazer programação análoga para as produções dos não terminais ExprAux4, ExprAux3, ExprAux2, ExprAux1 e Expressao

Exercício 4.4: Exercício 4.4: Inserir quádruplas para comandos Inserir quádruplas para comandos de atribuiçãode atribuição

Exemplo:Exemplo: as quádruplas para a atribuição: as quádruplas para a atribuição:

b1 = (i+3 >= j-2) && b2b1 = (i+3 >= j-2) && b2

sendo: sendo: int i, j; logic b1, b2;int i, j; logic b1, b2;

podem ser: podem ser:

MAIS, (VAR, i), (INT, 3), (VAR, ##1)MAIS, (VAR, i), (INT, 3), (VAR, ##1)

MENOS, (VAR, j), (INT, 2), (VAR, ##2)MENOS, (VAR, j), (INT, 2), (VAR, ##2)

GE, (VAR, ##1), (VAR, ##2), (VAR, ##3)GE, (VAR, ##1), (VAR, ##2), (VAR, ##3)

AND, (VAR, ##3), (VAR, b2), (VAR, ##4)AND, (VAR, ##3), (VAR, b2), (VAR, ##4)

ATRIB, (VAR, ##4), (IDLE), (VAR, b1)ATRIB, (VAR, ##4), (IDLE), (VAR, b1)

Exercício 4.5: Exercício 4.5: Inserir quádruplas para comandos Inserir quádruplas para comandos condicionaiscondicionais

Primeiramente, sejam os comandos Primeiramente, sejam os comandos if sem elseif sem else

Exemplo:Exemplo: as quádruplas para o comando as quádruplas para o comando

if i < j then { i = i+3; n = v/h; }if i < j then { i = i+3; n = v/h; }

podem ser:podem ser:

2) LT, (VAR, i), (VAR, j), (VAR, ##1)2) LT, (VAR, i), (VAR, j), (VAR, ##1)


4) MAIS, (VAR, i), (INT, 3), (VAR, ##2)4) MAIS, (VAR, i), (INT, 3), (VAR, ##2)

5) ATRIB, (VAR, ##2), (IDLE), (VAR, i)5) ATRIB, (VAR, ##2), (IDLE), (VAR, i)

6) DIV, (VAR, v), (VAR, h), (VAR, ##3)6) DIV, (VAR, v), (VAR, h), (VAR, ##3)

7) ATRIB, (VAR, ##3), (IDLE), (VAR, n)7) ATRIB, (VAR, ##3), (IDLE), (VAR, n)


Usar os arquivos inter022014.y, inter022014.l e inter022014.dat

Arquivo inter022014.y:Arquivo inter022014.y:

Gera quádruplas para abrir módulo, operadores de Gera quádruplas para abrir módulo, operadores de expressões e comandos de atribuiçãoexpressões e comandos de atribuição

Função RenumQuadruplas (q1, q2): Função RenumQuadruplas (q1, q2):

Algumas quádruplas serão geradas Algumas quádruplas serão geradas fora de fora de ordemordem

Sua Sua ordemordem deve ser deve ser corrigidacorrigida Para fins Para fins didáticosdidáticos, as quádruplas serão , as quádruplas serão

renumeradasrenumeradas

Abrir o arquivo Abrir o arquivo inter022014.datinter022014.dat Rodar Rodar flexflex, , yaccyacc, , gccgcc e executável gerado e executável gerado A cada implementação, alterar os comentários em A cada implementação, alterar os comentários em

inter022014.datinter022014.dat

A programação para A programação para if sem elseif sem else está na está na produção do não-terminal produção do não-terminal IfStatIfStat::

IfStatIfStat : IF {- - - - -} Expression { : IF {- - - - -} Expression {

- - - - -- - - - -

opndaux.tipo = ROTOPND;opndaux.tipo = ROTOPND;

$<quad>$ = $<quad>$ =

GeraQuadrupla (OPJF, $3.opnd, GeraQuadrupla (OPJF, $3.opnd, opndidle, opndaux);opndidle, opndaux);

} THEN {printf ("then\n");} Statement } THEN {printf ("then\n");} Statement {{

$<quad>4->result.atr.rotulo =$<quad>4->result.atr.rotulo =

GeraQuadrupla (NOP, opndidle, GeraQuadrupla (NOP, opndidle, opndidle, opndidle);opndidle, opndidle);

}} ElseStat ElseStat

;;É necessário acrescentar o campo quad na declaração %union: quadrupla quad;

A programação para A programação para if sem elseif sem else está na está na produção do não-terminal produção do não-terminal IfStatIfStat::


- - - - -- - - - -


$<quad>$ = $<quad>$ =

GeraQuadrupla (OPJF, $3.opnd, GeraQuadrupla (OPJF, $3.opnd, opndidle, opndaux);opndidle, opndaux);





;;No arquivo inter022014.dat, tirar o comentário do if sem else e rodar


- - - - -- - - - -


$<quad>$ = GeraQuadrupla (OPJF, $3.opnd, opndidle, $<quad>$ = GeraQuadrupla (OPJF, $3.opnd, opndidle, opndaux);opndaux);



GeraQuadrupla (NOP, opndidle, opndidle, opndidle);GeraQuadrupla (NOP, opndidle, opndidle, opndidle);


;;

Expression

----- ----- ----- ##n

JF ##n ----- ROT

$4

Statement

NOP ----- ----- -----

A quádrupla destino do desvio é gerada na produção de IfStat

NOP é eliminada na otimização do código intermediário

?

Sejam agora os comandos Sejam agora os comandos if com elseif com else

Exemplo:Exemplo: as quádruplas para os comandos as quádruplas para os comandos

if i < j then { i = i+3; n = v/h; }if i < j then { i = i+3; n = v/h; }

else { v = h; i = j; }else { v = h; i = j; }

n = v;n = v;


2) LT, (VAR, i), (VAR, j), (VAR, ##1)3) JF, (VAR, ##1), (IDLE), (ROTULO, 9)4) MAIS, (VAR, i), (INT, 3), (VAR, ##2)5) ATRIB, (VAR, ##2), (IDLE), (VAR, i)6) DIV, (VAR, v), (VAR, h), (VAR, ##3)7) ATRIB, (VAR, ##3), (IDLE), (VAR, n)8) JUMP, (IDLE), (IDLE), (ROTULO, 12)9) NOP, (IDLE), (IDLE), (IDLE)10) ATRIB, (VAR, h), (IDLE), (VAR, v)11) ATRIB, (VAR, j), (IDLE), (VAR, i)12) NOP, (IDLE), (IDLE), (IDLE)13) ATRIB, (VAR, v), (IDLE), (VAR, n)

A programação para A programação para if com elseif com else está nas está nas produções dos não-terminais produções dos não-terminais IfStatIfStat e e ElseStatElseStat::

IfStatIfStat : IF { - - - - - } Expression { - - - - -: IF { - - - - - } Expression { - - - - - opndaux.tipo = ROTOPND;opndaux.tipo = ROTOPND; $<quad>$ = GeraQuadrupla (OPJF, $3.opnd, opndidle, $<quad>$ = GeraQuadrupla (OPJF, $3.opnd, opndidle,

opndaux);opndaux);} THEN {printf ("then\n");} Statement {} THEN {printf ("then\n");} Statement {

$<quad>$ = quadcorrente;$<quad>$ = quadcorrente; $<quad>4->result.atr.rotulo =$<quad>4->result.atr.rotulo = GeraQuadrupla (NOP, opndidle, opndidle, opndidle);GeraQuadrupla (NOP, opndidle, opndidle, opndidle); } ElseStat } ElseStat {{ if ($<quad>8->prox != quadcorrente) {if ($<quad>8->prox != quadcorrente) { quadaux = $<quad>8->prox;quadaux = $<quad>8->prox; $<quad>8->prox = quadaux->prox;$<quad>8->prox = quadaux->prox; quadaux->prox = $<quad>8->prox->prox;quadaux->prox = $<quad>8->prox->prox; $<quad>8->prox->prox = quadaux;$<quad>8->prox->prox = quadaux; RenumQuadruplas ($<quad>8, quadcorrente);RenumQuadruplas ($<quad>8, quadcorrente); }} }};;

ElseStatElseStat ::

| ELSE {| ELSE {

- - - - -- - - - -


$<quad>$ = GeraQuadrupla (OPJUMP, $<quad>$ = GeraQuadrupla (OPJUMP, opndidle, opndidle, opndidle, opndidle, opndaux);opndaux);

} Statement } Statement {{



}}

;;

No arquivo inter022014.dat, tirar o comentário do if com else e rodar

IfStatIfStat : IF { - - - - - } Expression { - - - - -: IF { - - - - - } Expression { - - - - - opndaux.tipo = ROTOPND;opndaux.tipo = ROTOPND; $<quad>$ = GeraQuadrupla (OPJF, $3.opnd, opndidle, $<quad>$ = GeraQuadrupla (OPJF, $3.opnd, opndidle,

opndaux);opndaux);} THEN {printf ("then\n");} Statement {} THEN {printf ("then\n");} Statement {

$<quad>$ = quadcorrente;$<quad>$ = quadcorrente; $<quad>4->result.atr.rotulo =$<quad>4->result.atr.rotulo = GeraQuadrupla (NOP, opndidle, opndidle, GeraQuadrupla (NOP, opndidle, opndidle,

opndidle);opndidle); } ElseStat } ElseStat { - - - - - }{ - - - - - };; Expression

----- ----- ----- ##n

JF ##n ----- ROT

Statement

NOP ----- ----- -----

$4

$8

ElseStatElseStat :: | ELSE { - - - - -| ELSE { - - - - -


$<quad>$ = GeraQuadrupla (OPJUMP, opndidle, $<quad>$ = GeraQuadrupla (OPJUMP, opndidle, opndidle, opndaux);opndidle, opndaux);



GeraQuadrupla (NOP, opndidle, opndidle, GeraQuadrupla (NOP, opndidle, opndidle, opndidle);opndidle);

}}

;;

Expression

----- ----- ----- ##n

JF ##n ----- ROT

Statement

NOP ----- ----- -----

$4

$8

JUMP ----- ----- ROT

$2

As quádruplas NOP e JUMP foram geradas em ordem trocada

?

ElseStatElseStat :: | ELSE { - - - - -| ELSE { - - - - -


$<quad>$ = GeraQuadrupla (OPJUMP, opndidle, $<quad>$ = GeraQuadrupla (OPJUMP, opndidle, opndidle, opndaux);opndidle, opndaux);



GeraQuadrupla (NOP, opndidle, opndidle, GeraQuadrupla (NOP, opndidle, opndidle, opndidle);opndidle);

}}

;;

Expression

----- ----- ----- ##n

JF ##n ----- ROT

Statement

NOP ----- ----- -----

$4

$8

JUMP ----- ----- ROT

$2

Statement

NOP ----- ----- -----

É preciso inverter a ordem das quádruplas NOP e JUMP

?

IfStatIfStat : IF {- - - - -} Expression {- - - - -} THEN {- - - - -} : IF {- - - - -} Expression {- - - - -} THEN {- - - - -} Statement Statement

{ - - - - -} ElseStat { - - - - -} ElseStat {{if ($<quad>8->prox != quadcorrente) {if ($<quad>8->prox != quadcorrente) {

quadaux = $<quad>8->prox;quadaux = $<quad>8->prox;$<quad>8->prox = quadaux->prox;$<quad>8->prox = quadaux->prox;quadaux->prox = quadaux->prox =

$<quad>8->prox->prox;$<quad>8->prox->prox;$<quad>8->prox->prox = quadaux;$<quad>8->prox->prox = quadaux;RenumQuadruplas RenumQuadruplas

($<quad>8, quadcorrente);($<quad>8, quadcorrente);

}}}}

;;

Statement

NOP ----- ----- -----

$8

JUMP ----- ----- ROT

Statement

NOP ----- ----- -----

Se a quádrupla seguinte à $8 for a quádrupla corrente, o if não tem else – não é preciso fazer troca

quadaux

Exercício 4.6: Exercício 4.6: Inserir quádruplas para o Inserir quádruplas para o comando comando whilewhile

Exemplo:Exemplo: as quádruplas para o comando as quádruplas para o comando

while i < j do i = j + h;while i < j do i = j + h;

i = 0;i = 0;



3) LT, (VAR, i), (VAR, j), (VAR, ##1)3) LT, (VAR, i), (VAR, j), (VAR, ##1)


5) MAIS, (VAR, j), (VAR, h), (VAR, ##2)5) MAIS, (VAR, j), (VAR, h), (VAR, ##2)

6) ATRIB, (VAR, ##2), (IDLE), (VAR, i)6) ATRIB, (VAR, ##2), (IDLE), (VAR, i)



9) ATRIB, (INT, 0), (IDLE), (VAR, i)9) ATRIB, (INT, 0), (IDLE), (VAR, i)

WhileStatWhileStat : WHILE Expression DO Statement: WHILE Expression DO Statement

;;

Expression

----- ----- ----- ##n

JF ##n ----- ROT

Statement

NOP ----- ----- -----

NOP ----- ----- -----

JUMP -----

----- ROT

?

Exercício 4.7: Exercício 4.7: Inserir quádruplas para comandos Inserir quádruplas para comandos readread e e writewrite

Exemplo:Exemplo: as quádruplas para os comandos as quádruplas para os comandos

read (a, b, c);read (a, b, c);

write ("Valor de a+b:", a+b, "Valor de c:", c);write ("Valor de a+b:", a+b, "Valor de c:", c);


2) PARAM, (VAR, a), (IDLE), (IDLE)2) PARAM, (VAR, a), (IDLE), (IDLE)3) PARAM, (VAR, b), (IDLE), (IDLE)3) PARAM, (VAR, b), (IDLE), (IDLE)4) PARAM, (VAR, c), (IDLE), (IDLE)4) PARAM, (VAR, c), (IDLE), (IDLE)5) READ, (INT, 3), (IDLE), (IDLE)5) READ, (INT, 3), (IDLE), (IDLE)6) PARAM, (CADEIA, Valor de a+b:), (IDLE), (IDLE)6) PARAM, (CADEIA, Valor de a+b:), (IDLE), (IDLE)7) MAIS, (VAR, a), (VAR, b), (VAR, ##1)7) MAIS, (VAR, a), (VAR, b), (VAR, ##1)8) PARAM, (VAR, ##1), (IDLE), (IDLE)8) PARAM, (VAR, ##1), (IDLE), (IDLE)9) PARAM, (CADEIA, Valor de c:), (IDLE), (IDLE)9) PARAM, (CADEIA, Valor de c:), (IDLE), (IDLE)10) PARAM, (VAR, c), (IDLE), (IDLE)10) PARAM, (VAR, c), (IDLE), (IDLE)11) WRITE, (INT, 4), (IDLE), (IDLE)11) WRITE, (INT, 4), (IDLE), (IDLE)

Os operadores de quádruplas PARAM, OPREAD e OPWRITE já estão declarados no programa inter022014.y

As produções iniciadas pela palavra str serão tratadas junto às variáveis indexadas

2) PARAM, (VAR, a), (IDLE), (IDLE)2) PARAM, (VAR, a), (IDLE), (IDLE)

3) PARAM, (VAR, b), (IDLE), (IDLE)3) PARAM, (VAR, b), (IDLE), (IDLE)

4) PARAM, (VAR, c), (IDLE), (IDLE)4) PARAM, (VAR, c), (IDLE), (IDLE)

5) READ, (INT, 3), (IDLE), (IDLE)5) READ, (INT, 3), (IDLE), (IDLE)

6) PARAM, (CADEIA, Valor de a+b:), (IDLE), (IDLE)6) PARAM, (CADEIA, Valor de a+b:), (IDLE), (IDLE)

7) MAIS, (VAR, a), (VAR, b), (VAR, ##1)7) MAIS, (VAR, a), (VAR, b), (VAR, ##1)

8) PARAM, (VAR, ##1), (IDLE), (IDLE)8) PARAM, (VAR, ##1), (IDLE), (IDLE)

9) PARAM, (CADEIA, Valor de c:), (IDLE), (IDLE)9) PARAM, (CADEIA, Valor de c:), (IDLE), (IDLE)

10) PARAM, (VAR, c), (IDLE), (IDLE)10) PARAM, (VAR, c), (IDLE), (IDLE)

11) WRITE, (INT, 4), (IDLE), (IDLE)11) WRITE, (INT, 4), (IDLE), (IDLE)

Elementos de leitura e escrita também podem ser operandos de quádruplas

São úteis contadores de argumentos para os comandos read e write

Isso será feito nas produções dos não-terminais ReadList e WriteList

O atributo dos não-terminais O atributo dos não-terminais ReadListReadList e e WriteListWriteList deve ser o número de argumentos de suas listasdeve ser o número de argumentos de suas listas

Deve-se acrescentar mais um campo na declaração Deve-se acrescentar mais um campo na declaração %union%union::

%union {%union {

- - - - -- - - - -

int nsubscr, int nsubscr, nargsnargs;;

- - - - -- - - - -

}}

Declaração do atributo dos não terminais Declaração do atributo dos não terminais ReadListReadList e e WriteListWriteList::

%type <nargs>%type <nargs> ReadList WriteListReadList WriteList

Tal como uma expressão, o não terminal Tal como uma expressão, o não terminal WriteElemWriteElem terá um operando de quádrupla terá um operando de quádrupla

Então deve haver uma declaração Então deve haver uma declaração %type%type para para ele:ele:

%type%type <infoexpr> <infoexpr> Expression AuxExpr1 Expression AuxExpr1 AuxExpr2 AuxExpr2

AuxExpr3 AuxExpr4 AuxExpr3 AuxExpr4 Term Term Factor Factor WriteElemWriteElem

O não terminal O não terminal ReadElemReadElem terá o mesmo terá o mesmo atributo que o não-terminal atributo que o não-terminal VariableVariable

Então deve haver uma declaração Então deve haver uma declaração %type%type para para ele:ele:

%type%type <infovar> <infovar> Variable Variable ReadElemReadElem

Na produção Na produção ReadElem : Variable ReadElem : Variable por por default, default, $$ = $1$$ = $1

Programação para o não-terminal Programação para o não-terminal ReadListReadList que é usado que é usado na produção do não-terminal na produção do não-terminal ReadStatReadStat::

ReadListReadList : ReadElem : ReadElem

{ {

$$ = 1;$$ = 1;

GeraQuadrupla (PARAM, $1.opnd, opndidle, opndidle);GeraQuadrupla (PARAM, $1.opnd, opndidle, opndidle);

}}

| ReadList COMMA { - - - - - } ReadElem | ReadList COMMA { - - - - - } ReadElem

{{

$$ = $1 + 1;$$ = $1 + 1;

GeraQuadrupla (PARAM, $4.opnd, opndidle, opndidle);GeraQuadrupla (PARAM, $4.opnd, opndidle, opndidle);

}}

;;

$$ é o contador de argumentos de um comando read

Programação para o não-terminal Programação para o não-terminal ReadStatReadStat::

ReadStatReadStat : READ OPPAR { - - - - -} : READ OPPAR { - - - - -}

ReadListReadList

{{

opnd1.tipo = INTOPND;opnd1.tipo = INTOPND;

opnd1.atr.valint = $4;opnd1.atr.valint = $4;

GeraQuadrupla (OPREAD, opnd1, opndidle, GeraQuadrupla (OPREAD, opnd1, opndidle, opndidle);opndidle);

}}

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

;;

Programação para o não-terminal Programação para o não-terminal WriteElemWriteElem::

WriteElemWriteElem : STRING {: STRING {

printf ("%s ", $1);printf ("%s ", $1);

$$.opnd.tipo = CADOPND;$$.opnd.tipo = CADOPND;

$$.opnd.atr.valcad = malloc (strlen($1) + 1);$$.opnd.atr.valcad = malloc (strlen($1) + 1);

strcpy ($$.opnd.atr.valcad, $1);strcpy ($$.opnd.atr.valcad, $1);

}}

| Expression| Expression /* default: $$ = $1 *//* default: $$ = $1 */

;;

Obs.: $$.tipo da 1ª produção do não-terminal WriteElem não é usado

Portanto não é calculado

Programação para o não-terminal Programação para o não-terminal WriteListWriteList::

WriteListWriteList : WriteElem: WriteElem

{{

$$ = 1;$$ = 1;

GeraQuadrupla (PARAM, $1.opnd, opndidle, GeraQuadrupla (PARAM, $1.opnd, opndidle, opndidle);opndidle);

}}

| WriteList COMMA {printf (", ");} WriteElem| WriteList COMMA {printf (", ");} WriteElem

{{

$$ = $1 + 1;$$ = $1 + 1;

GeraQuadrupla (PARAM, $4.opnd, opndidle, GeraQuadrupla (PARAM, $4.opnd, opndidle, opndidle);opndidle);

}}

;;$$ é o contador de argumentos de um comando write

Programação para o não-terminal Programação para o não-terminal WriteStatWriteStat::

WriteStatWriteStat : WRITE OPPAR {- - - - -} WriteList: WRITE OPPAR {- - - - -} WriteList

{{

opnd1.tipo = INTOPND;opnd1.tipo = INTOPND;

opnd1.atr.valint = $4;opnd1.atr.valint = $4;

GeraQuadrupla (OPWRITE, opnd1, opndidle, GeraQuadrupla (OPWRITE, opnd1, opndidle, opndidle);opndidle);

}}

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

;;

No arquivo inter022014.dat, tirar o comentário dos comandos ler e escrever e rodar

Exercício 4.8: Exercício 4.8: Inserir quádruplas para Inserir quádruplas para indexação indexação sem sem “str”“str”

Sejam as seguintes declarações e comandos:Sejam as seguintes declarações e comandos:

int i, j, k, A[6,5]; int i, j, k, A[6,5];

i = 4; j = 3;i = 4; j = 3;

k = A[i,j-2] + 7;k = A[i,j-2] + 7;

A[10-i,2*j+3] = i + j * k;A[10-i,2*j+3] = i + j * k;

read (i, j, A[i+j,2*i-j]);read (i, j, A[i+j,2*i-j]);

Acesso a um elemento genérico Acesso a um elemento genérico A[i,j]:A[i,j]:

Uma vez conhecido o Uma vez conhecido o endereço inicialendereço inicial da matriz da matriz AA, é necessário , é necessário localizarlocalizar o elemento o elemento A[i,j]A[i,j]

Seja a seguir o mapa de Seja a seguir o mapa de A[6,5] A[6,5] na memória:na memória:

Seja Seja mm o número de linhas o número de linhas e e nn o número de colunas da o número de colunas da matriz matriz AA

O endereço do elemento O endereço do elemento A[i,j] A[i,j] é dado pela fórmula:é dado pela fórmula:

Ender (A) + i * n + jEnder (A) + i * n + j

Para Para m = 6m = 6, , n = 5n = 5, o , o endereço de endereço de A[4,3]A[4,3] é é

Ender (A) + 23Ender (A) + 23

No programa, cada No programa, cada índiceíndice pode ser uma pode ser uma expressão expressão inteirainteira

Calcula-se o valor de cada Calcula-se o valor de cada índiceíndice, empilhando-o numa , empilhando-o numa pilha de índicespilha de índices

Isso pode ser feito pela Isso pode ser feito pela execução de uma execução de uma quádruplaquádrupla de operador de operador INDIND::

IND, i , ---- , ----IND, i , ---- , ----

IND, j , ---- , ----IND, j , ---- , ----

Calcula-se o endereço de Calcula-se o endereço de A[i,j]A[i,j], , usando uma quádrupla de usando uma quádrupla de operador operador INDEXINDEX::

INDEX , A , 2 , temp1INDEX , A , 2 , temp1

Sua Sua execuçãoexecução consiste em: consiste em: Pegar as Pegar as dimensõesdimensões e o e o

endereçoendereço de de AA na tabela de na tabela de símbolossímbolos

Desempilhar Desempilhar dois índicesdois índices Calcular o Calcular o endereçoendereço, ,

colocando-o na variável colocando-o na variável temp1temp1

A variável A variável temp1 temp1 é portanto um é portanto um ponteiroponteiro

Quando o elemento Quando o elemento A[i,j]A[i,j] está numa está numa expressãoexpressão, necessita-se do , necessita-se do conteúdoconteúdo do local do local apontado por apontado por temp1temp1

Para isso, pode-se usar uma quádrupla de Para isso, pode-se usar uma quádrupla de operador operador CONTAPONTCONTAPONT::

CONTAPONT , temp1 , ---- , temp2CONTAPONT , temp1 , ---- , temp2

int i, j, k, A[6,5];

i = 4; j = 3;

k = A[i,j-2] + 7;

A[10-i,2*j+3] = i + j * k;

read (i, j, A[i+j,2*i-j]);

temp2 recebe o conteúdo do local apontado por temp1

Quando o elemento Quando o elemento A[i,j]A[i,j] vai receber uma vai receber uma atribuição, o local apontado por atribuição, o local apontado por temp1temp1 é que é que vai receber issovai receber isso

Então, pode-se usar uma quádrupla de Então, pode-se usar uma quádrupla de operador operador ATRIBPONTATRIBPONT::

ATRIBPONT , tempexpr , ---- , temp1ATRIBPONT , tempexpr , ---- , temp1

int i, j, k, A[6,5];

i = 4; j = 3;

k = A[i,j-2] + 7;

A[10-i,2*j+3] = i + j * k;


O local apontado por temp1 recebe o conteúdo de tempexpr

Quando o elemento Quando o elemento A[i,j]A[i,j] vai receber um valor vai receber um valor lido:lido:

O valor lido é guardado numa O valor lido é guardado numa temporáriatemporária O local apontado por O local apontado por temp1temp1 recebe o recebe o

valor dessa temporáriavalor dessa temporária

É conveniente colocar a leitura do elemento de uma variável indexada numa quádrupla separada:

Duas quádruplas OPREAD

int i, j, k, A[6,5];

i = 4; j = 3;

k = A[i,j-2] + 7;

A[10-i,2*j+3] = i + j * k;


PARAM , tempread , ---- , ----OPREAD , 1 , ---- , ----ATRIBPONT , tempread , ---- , temp1

Exemplo: Exemplo: seja o seguinte programa:seja o seguinte programa:

program teste program teste

local {local {

int i, j, k, A[10,10];} int i, j, k, A[10,10];}

statements {statements {

i = 7; j = 5;i = 7; j = 5;

k = A[i-3,j+2] + 5;k = A[i-3,j+2] + 5;

A[10-i,9-j] = i + j * k;A[10-i,9-j] = i + j * k;

read (i, j, A[2,3], k);read (i, j, A[2,3], k);

read (A[1,2]);read (A[1,2]);

}}

A seguir suas possíveis quádruplas

program testeprogram teste

Local {Local {

int i, j, k, A[10,10];}int i, j, k, A[10,10];}

1) OPENMOD, (MODULO, teste), (IDLE), (IDLE)1) OPENMOD, (MODULO, teste), (IDLE), (IDLE)

statements {statements {

i = 7; j = 5;i = 7; j = 5;

2) ATRIB, (INT, 7), (IDLE), (VAR, i)2) ATRIB, (INT, 7), (IDLE), (VAR, i)

3) ATRIB, (INT, 5), (IDLE), (VAR, j)3) ATRIB, (INT, 5), (IDLE), (VAR, j)

k = A[i-3,j+2] + 5;k = A[i-3,j+2] + 5;

4) MENOS, (VAR, i), (INT, 3), (VAR, ##1)4) MENOS, (VAR, i), (INT, 3), (VAR, ##1)

5) IND, (VAR, ##1), (IDLE), (IDLE)5) IND, (VAR, ##1), (IDLE), (IDLE)

6) MAIS, (VAR, j), (INT, 2), (VAR, ##2)6) MAIS, (VAR, j), (INT, 2), (VAR, ##2)


8) INDEX, (VAR, A), (INT, 2), (VAR, ##3)8) INDEX, (VAR, A), (INT, 2), (VAR, ##3)

9) CONTAPONT, (VAR, ##3), (IDLE), (VAR, ##4)9) CONTAPONT, (VAR, ##3), (IDLE), (VAR, ##4)

10) MAIS, (VAR, ##4), (INT, 5), (VAR, ##5)10) MAIS, (VAR, ##4), (INT, 5), (VAR, ##5)

11) ATRIB, (VAR, ##5), (IDLE), (VAR, k)11) ATRIB, (VAR, ##5), (IDLE), (VAR, k)

A[10-i,9-j] = i + j * k;A[10-i,9-j] = i + j * k;

12) MENOS, (INT, 10), (VAR, i), (VAR, ##6)12) MENOS, (INT, 10), (VAR, i), (VAR, ##6)


14) MENOS, (INT, 9), (VAR, j), (VAR, ##7)14) MENOS, (INT, 9), (VAR, j), (VAR, ##7)



17) MULT, (VAR, j), (VAR, k), (VAR, ##9)17) MULT, (VAR, j), (VAR, k), (VAR, ##9)

18) MAIS, (VAR, i), (VAR, ##9), (VAR, ##10)18) MAIS, (VAR, i), (VAR, ##9), (VAR, ##10)

19) ATRIBPONT, (VAR, ##10), (IDLE), (VAR, ##8)19) ATRIBPONT, (VAR, ##10), (IDLE), (VAR, ##8)

read (i, j, A[2,3], k);read (i, j, A[2,3], k);

20) PARAM, (VAR, i), (IDLE), (IDLE)20) PARAM, (VAR, i), (IDLE), (IDLE)

21) PARAM, (VAR, j), (IDLE), (IDLE)21) PARAM, (VAR, j), (IDLE), (IDLE)


23) IND, (INT, 2), (IDLE), (IDLE)23) IND, (INT, 2), (IDLE), (IDLE)






29) PARAM, (VAR, k), (IDLE), (IDLE)29) PARAM, (VAR, k), (IDLE), (IDLE)


read (A[1,2]);read (A[1,2]);

}}







Exercício 4.9: Exercício 4.9: Inserir quádruplas para Inserir quádruplas para indexação indexação com com “str”“str”

Sejam as seguintes declarações e comandos:Sejam as seguintes declarações e comandos:

int i, j, k; int i, j, k;

char A[20], B[10,15], C[10,5,15]; char A[20], B[10,15], C[10,5,15];

read (i, str A, str B[5], j, str C[4,2], k);read (i, str A, str B[5], j, str C[4,2], k);

write (i, str A, str B[5], j, str C[4,2], k);write (i, str A, str B[5], j, str C[4,2], k);

Sugestão: adotar novos operadores de Sugestão: adotar novos operadores de quádruplas:quádruplas:

OPREADSTROPREADSTR e e OPWRITESTROPWRITESTR

Tratar separadamente os casos dos nomes das Tratar separadamente os casos dos nomes das variáveis virem sem e com subscritosvariáveis virem sem e com subscritos

CES-41 COMPILADORES Aulas Práticas - 2014

Documents

Transcript of CES-41 COMPILADORES Aulas Práticas - 2014