PLP – Extensão da LI2 Procedimentos de Alta Ordem

1. PLP – Extensão da LI2Procedimentos de Alta Ordem 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

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

3. 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, procconcat (string i, string a, int m) { i := i ++ " de " ++ a; write(i) ; write(m) }, procpAltaOrdem( int num, [string, string, int] prod) { callprod(p, a, n) }; callpAltaOrdem(n, concat) }

4. Alterações na BNF Programa ::= Comando Comando ::= Atribuicao                       | ComandoDeclaracao                       | While                       | IfThenElse                       | IO                        | Comando ";" Comando                        | Skip                       | ChamadaProcedimento Skip ::= Atribuicao ::=  IdAbstrato “:=” Expressao IdAbstrato ::=  Id | Indexacao Expressao ::= Valor | ExpUnaria | ExpBinaria | IdAbstrato Valor ::= ValorConcreto| ValorAbstrato ValorAbstrato ::= ValorProcedimento ValorProcedimento ::= “pc” ListaDeclaracaoParametro “.” Comando ValorConcreto ::= ValorInteiro | ValorBooleano | ValorString | ValorArray

5. Alterações na BNF ValorArray ::= “{” ListaExpressao “}” ExpUnaria ::= "-" Expressao | "not" Expressao | "length" Expressao ExpBinaria ::= 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 "=" Expressao DeclaracaoComposta ::= Declaracao "," Declaracao

6. Alterações na BNF DeclaracaoProcedimento ::= "proc" Id "(" [ ListaDeclaracaoParametro ] ")" "{" Comando "}" ListaDeclaracaoParametro ::= DeclaracaoParametro | DeclaracaoParametro "," ListaDeclaracaoParametro DeclaracaoParametro::= Tipo Id Tipo ::= "string" | "int" | "boolean" | "TipoArray" | "TipoProcedimento“ TipoProcedimento:= Tipo | Tipo "," TipoProcedimento While ::= "while" Expressao "do" Comando IfThenElse ::= "if" Expressao "then" Comando "else" Comando

7. Alterações no Parser DeclaracaoPDeclaracao(): { Declaracao retorno; } { ( LOOKAHEAD(PDeclaracaoVariavel() <COMMA>) retorno = PDeclaracaoComposta() | LOOKAHEAD(PDeclaracaoProcedimento() <COMMA>) retorno = PDeclaracaoComposta() | retorno = PDeclaracaoVariavel() | retorno = PDeclaracaoProcedimento() ) {return retorno;} }

8. Alterações no Parser DeclaracaoComposta 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. Alterações no Parser Tipo 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. Alterações no Parser Tipo 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. Alterações no Parser Valor PValor() : { Valor retorno; } { ( retorno = PValorInteiro() | retorno = PValorBooleano() | retorno = PValorString() | retorno = PValorArray() | retorno = PValorProcedimento() ) { return retorno; } }

12. Alterações no Parser Valor PValorProcedimento() : { ListaDeclaracaoParametro parametrosFormais; Comando comando; } { <PC> parametrosFormais = PListaDeclaracaoParametro() <DOT> <LBRACE> comando = PComando() <RBRACE> { return new ValorProcedimento(parametrosFormais, comando); } }

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

14. Alterações no Parser DeclaracaoParametro PDeclaracaoParametro(): { Id id; Tipo tipo; } { tipo = PTipo() id = PId() { return new DeclaracaoParametro(id, tipo); } }

15. 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. Simplificações no Ambiente • AmbienteCompilacaoImperativa2 (plp.imperative2.memory)publicvoidmapParametrosProcedimento(IdAbstratoidArg, ListaDeclaracaoParametroparametrosId)publicListaDeclaracaoParametrogetParametrosProcedimento(IdAbstratoidArg) • ContextoCompilacaoImperativa2 (plp.imperative2.memory) • AmbienteExecucaoImperativa2(plp.imperative2.memory) publicvoidmapProcedimento(Id idArg, Procedimento procedimentoId) publicProcedimento getProcedimento(Id idArg) • ContextoExecucaoImperativa2 (plp.imperative2.memory)

17. Classes Criadas • ValorProcedimento(plp.imperative3)- extendsDefProcedimento - implementsValorAbstrato - publicValorProcedimento(ListaDeclaracaoParametroparametrosFormais, Comando comando) { super(parametrosFormais, comando); } - public Valor avaliar(AmbienteExecucaoamb) throws ...{returnthis; }

18. 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. Classes Criadas • TipoProcedimento(plp.imperative3) • - extends Tipo - privateList<Tipo> listTipo; // Compara os parâmetros formais com os parâmetros reais • publicbooleanchecaTipo(List<Tipo> tiposParametrosReais) { • returnthis.listTipo.equals(tiposParametrosReais); • }

20. Classes Alteradas • Tipo (plp.expressions1.util)- Novo tipo -> TIPO_PROC - public boolean eProc()

21. Classes Alteradas • DeclaracaoProcedimento(plp.imperative2.declaration)- Construtor: publicDeclaracaoProcedimento(Id nome, DefProcedimentodefProcedimento) publicDeclaracaoProcedimento(IdAbstrato nome, ValorProcedimentovalorProcedimento) - 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); returnresultado;

22. Classes Alteradas • DeclaracaoProcedimento(plp.imperative2.declaration)- Elabora: • ((AmbienteExecucaoImperativa2) ambiente).mapProcedimento(parametro1,new Procedimento(parametrosFormais, parametro2)); • ((AmbienteExecucaoImperativa) ambiente).map(parametro1,parametro2);

23. 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()){ returnfalse; }TipoProcedimentotipoProc = (TipoProcedimento) tipo;List<Tipo> tiposParametrosReais = parametrosReais.getTipos(ambiente); resposta = tipoProc.checaTipo(tiposParametrosReais);ambiente.restaura(); return resposta;

24. Dúvidas ?