Emanuella Aleixo ( emanuellaaleixo17@gmail.com)José Antônio (jamrr@cin.ufpe.br)

Juliana Mafra (j_mafra@hotmail.com)Marcela Balbino (marcelabalbinosm@gmail.com)

Prof.: Augusto Sampaio

PLP – Extensão da LI2Procedimentos de Alta Ordem

2/24

Apresentação

• Definição• Alterações na BNF• Alterações no Parser• Simplificações no Ambiente• Classes Criadas• Classes Alteradas• Testes

3/24

Procedimentos de Alta Ordem

São procedimentos que podem receber outros procedimentos como parâmetro, pois agora eles passam a possuir o status de valor.

Ex.:

{ var p = "Procedimento", var a = "Alta Ordem", var n = 10, proc concat (string i, string a, int m) { i := i ++ " de " ++ a; write(i) ; write(m) }, proc pAltaOrdem( int num, [string, string, int] prod) { call prod(p, a, n) }; call pAltaOrdem(n, concat) }

4/24

Alterações na BNFPrograma ::= Comando

Comando ::= Atribuicao                        | ComandoDeclaracao                        | While                        | IfThenElse                        | IO                        | Comando ";" Comando                        | Skip                        | ChamadaProcedimento

Skip ::= Atribuicao ::=  IdAbstrato “:=” ExpressaoIdAbstrato ::=  Id | IndexacaoExpressao ::= Valor | ExpUnaria | ExpBinaria | IdAbstratoValor ::= ValorConcreto | ValorAbstratoValorAbstrato ::= ValorProcedimento ValorProcedimento ::= “pc” ListaDeclaracaoParametro “.” ComandoValorConcreto ::= ValorInteiro | ValorBooleano | ValorString | ValorArray

5/24

Alterações na BNF

ValorArray ::= “{” ListaExpressao “}”ExpUnaria ::= "-" Expressao | "not" Expressao | "length" ExpressaoExpBinaria ::= Expressao "+" Expressao                         | Expressao "-" Expressao                         | Expressao "and" Expressao                         | Expressao "or" Expressao                         | Expressao "==" Expressao                         | Expressao "++" Expressao Indexacao ::= Id “[“ Expressao “]”ComandoDeclaracao :: = "{" Declaracao ";" Comando "}" Declaracao ::= DeclaracaoVariavel                         | DeclaracaoProcedimento                         | DeclaracaoComposta

DeclaracaoVariavel ::= "var" Id "=" Expressao  | "array" Id "=" ExpressaoDeclaracaoComposta ::= Declaracao "," Declaracao

6/24

Alterações na BNF

DeclaracaoProcedimento ::= "proc" Id "(" [ ListaDeclaracaoParametro ] ")" "{" Comando "}" ListaDeclaracaoParametro ::= DeclaracaoParametro | DeclaracaoParametro "," ListaDeclaracaoParametroDeclaracaoParametro::= Tipo IdTipo ::= "string" | "int" | "boolean" | "TipoArray" | "TipoProcedimento“TipoProcedimento:= Tipo | Tipo "," TipoProcedimentoWhile ::= "while" Expressao "do" ComandoIfThenElse ::= "if" Expressao "then" Comando "else" Comando

7/24

Alterações no ParserDeclaracao PDeclaracao():{

Declaracao retorno;}{

( LOOKAHEAD(PDeclaracaoVariavel() <COMMA>)

retorno = PDeclaracaoComposta() | LOOKAHEAD(PDeclaracaoProcedimento() <COMMA>)

retorno = PDeclaracaoComposta()

| retorno = PDeclaracaoVariavel()

| retorno = PDeclaracaoProcedimento()

){return retorno;}

}

8/24

Alterações no ParserDeclaracaoComposta PDeclaracaoComposta():{

Declaracao d1;Declaracao d2;

}{

d1 = PDeclaracaoVariavel() <COMMA> d2 = PDeclaracao() {return new DeclaracaoComposta(d1, d2);} |

d1 = PDeclaracaoProcedimento() <COMMA> d2 = PDeclaracao() {return new DeclaracaoComposta(d1, d2);}}

9/24

Alterações no ParserTipo PTipo():{

Tipo tipo;Tipo tipoInterno;

}{

( (<INT> {tipo = Tipo.TIPO_INTEIRO;} | <BOOLEAN> {tipo = Tipo.TIPO_BOOLEANO;}

| <STRING> {tipo = Tipo.TIPO_STRING;}

) [ LOOKAHEAD (<LBRACKET>) <LBRACKET> <RBRACKET> {tipoInterno = tipo; tipo = Tipo.TIPO_ARRAY; tipo.setTipoInterno(tipoInterno);} ] | tipo = PTipoProcedimento()

){

return tipo;}

}

10/24

Alterações no ParserTipo PTipoProcedimento():{

List listTipos = new ArrayList();Tipo tipo;

}

{LOOKAHEAD (<LBRACKET> <RBRACKET> ) <LBRACKET> <RBRACKET> {

return new TipoProcedimento(listTipos); }| <LBRACKET> tipo = PTipo() { listTipos.add(tipo); } ( (<COMMA> tipo = PTipo()) { listTipos.add(tipo); } )* <RBRACKET> {

return new TipoProcedimento(listTipos); }

}

11/24

Alterações no ParserValor PValor() :{

Valor retorno;}{

( retorno = PValorInteiro()

| retorno = PValorBooleano() | retorno = PValorString() | retorno = PValorArray() | retorno = PValorProcedimento()

)

{return retorno;

}}

12/24

Alterações no ParserValor PValorProcedimento() :

{

ListaDeclaracaoParametro parametrosFormais;Comando comando;

}

{<PC> parametrosFormais = PListaDeclaracaoParametro() <DOT>

<LBRACE> comando = PComando() <RBRACE>

{return new ValorProcedimento(parametrosFormais, comando);

}

}

13/24

Alterações no ParserListaDeclaracaoParametro PListaDeclaracaoParametro():{ DeclaracaoParametro parametro; List retorno = new ArrayList();}{ ( ( parametro = PDeclaracaoParametro() ) { retorno.add(parametro); } ( ( <COMMA> parametro = PDeclaracaoParametro() ) { retorno.add(parametro); } )*)?

{ return new ListaDeclaracaoParametro(retorno);}

}

14/24

Alterações no ParserDeclaracaoParametro PDeclaracaoParametro():{

Id id;Tipo tipo;

}{

tipo = PTipo() id = PId()

{ return new DeclaracaoParametro(id, tipo);}

}

15/24

Simplificações no Ambiente

• Como procedimento agora é um Valor, não se faz necessário fazer um mapeamento diferenciado para associar identificadores de procedimentos às respectivas definições.

• Necessidade de apenas um único mapeamento.

16/24

Simplificações no Ambiente• AmbienteCompilacaoImperativa2 (plp.imperative2.memory)

public void mapParametrosProcedimento(IdAbstrato idArg, ListaDeclaracaoParametro parametrosId)

public ListaDeclaracaoParametro getParametrosProcedimento(IdAbstrato idArg)

• ContextoCompilacaoImperativa2 (plp.imperative2.memory)

• AmbienteExecucaoImperativa2 (plp.imperative2.memory)public void mapProcedimento(Id idArg, Procedimento procedimentoId)

public Procedimento getProcedimento(Id idArg)

• ContextoExecucaoImperativa2 (plp.imperative2.memory)

17/24

Classes Criadas• ValorProcedimento (plp.imperative3)

- extends DefProcedimento

- implements ValorAbstrato

- public ValorProcedimento(ListaDeclaracaoParametro parametrosFormais, Comando comando) {

super(parametrosFormais, comando); }

- public Valor avaliar(AmbienteExecucao amb) throws ...{ return this;

}

18/24

Classes Criadas• ValorProcedimento (plp.imperative3) (cont.)

- public boolean checaTipo(AmbienteCompilacao amb) throws ... {

return this.getTipo(amb) != null;

}

- public Tipo getTipo(AmbienteCompilacao amb) throws ...{

List<Tipo> list = new ArrayList<Tipo>();

ListaDeclaracaoParametro parametrosFormais2 = getParametrosFormais();

for (DeclaracaoParametro declaracaoParametro : parametrosFormais2) {

list.add(declaracaoParametro.getTipo());}

return new TipoProcedimento(list);

19/24

Classes Criadas• TipoProcedimento (plp.imperative3)

- extends Tipo - private List<Tipo> listTipo;

// Compara os parâmetros formais com os parâmetros reais

public boolean checaTipo(List<Tipo> tiposParametrosReais) {

return this.listTipo.equals(tiposParametrosReais); }

20/24

Classes Alteradas

• Tipo (plp.expressions1.util)

- Novo tipo -> TIPO_PROC - public boolean eProc()

21/24

Classes Alteradas• DeclaracaoProcedimento (plp.imperative2.declaration)

- Construtor: public DeclaracaoProcedimento(Id nome, DefProcedimento defProcedimento) public DeclaracaoProcedimento(IdAbstrato nome, ValorProcedimento

valorProcedimento) - ChecaTipo:

ambiente2.mapParametrosProcedimento(parametro1, parametrosFormais);

ambiente.incrementa();

ambiente.map(parametro1, parametro2.getTipo(ambiente));

resultado = parametrosFormais.checaTipo(ambiente);

ambiente =parametrosFormais.declaraParametro(ambiente);

resultado = resultado && comando.checaTipo(ambiente);

return resultado;

22/24

Classes Alteradas• DeclaracaoProcedimento (plp.imperative2.declaration)

- Elabora:

• ((AmbienteExecucaoImperativa2) ambiente).mapProcedimento(parametro1,new Procedimento(parametrosFormais, parametro2));

• ((AmbienteExecucaoImperativa) ambiente).map(parametro1,parametro2);

23/24

Classes Alteradas• ChamadaProcedimento (plp.imperative2.command)- executar:

Procedimento procedimento = ambiente.getProcedimento(nomeProcedimento); ValorProcedimento procedimento = (ValorProcedimento)

ambiente.get(nomeProcedimento);- checaTipo:

ambiente.incrementa();Tipo tipo = ambiente.get(this.nomeProcedimento);

if(!tipo.eProc()){

return false; }TipoProcedimento tipoProc = (TipoProcedimento) tipo;List<Tipo> tiposParametrosReais = parametrosReais.getTipos(ambiente);resposta = tipoProc.checaTipo(tiposParametrosReais);ambiente.restaura();

return resposta;

24/24

Dúvidas

?