1.3 Variantes des r´esultats d’homog´en´eisation
1.3.4 Particules tri-dimensionnelles r´eparties sur une surface
laridade;
• N˜ao existem recursos na linguagem para tratar micro-estruturas, em n´ıvel de co- mandos e express˜oes. Na verdade, esta ´e uma limita¸c˜ao da implementa¸c˜ao, pois os conceitos inerentes `a linguagem abrangem este tipo de constru¸c˜ao;
• A linguagem n˜ao possui expressividade suficiente para representar trechos de c´odigo em padr˜oes. Al´em da representa¸c˜ao de estruturas isoladas da linguagem Java, ´e fundamental a existˆenca de vari´aveis para representa¸c˜ao de conjuntos de estruturas, ou, mais adequadamente, listas, j´a que a ordem das estruturas ´e importante no interior de m´etodos.
Seguindo um dos princ´ıpios b´asicos de JaTS, consideramos que agregar o m´aximo de expressividade `a linguagem de declara¸c˜ao de templates ´e fundamental para preservar a natureza declarativa das transforma¸c˜oes, o que ´e um dos principais diferenciais de JaTS em rela¸c˜ao a outros sistemas de transforma¸c˜ao. Portanto, visando o dom´ınio das refatora¸c˜oes de programas, buscamos introduzir na linguagem de templates a capacidade de tratar estruturas de fina granularidade, tanto em termos de casamento quanto de gera¸c˜ao. Al´em disto, embutimos na linguagem o conceito de micro-transforma¸c˜oes e defini¸c˜ao de estrat´egias, o que permite a defini¸c˜ao de transforma¸c˜oes elaboradas e auto- contidas.
As sub-se¸c˜oes a seguir apresentam as extens˜oes realizadas sobre a linguagem JaTS-TL e a aplicabilidade pr´atica de cada uma delas.
4.2.1 Declara¸c˜ao de Templates ´
E fundamental em uma ferramenta de transforma¸c˜ao com suporte a refatora¸c˜oes a ca- pacidade de tratar sub-estruturas da AST do programa objeto de forma isolada. Em se tratando de um sistema que utiliza padr˜oes para especifica¸c˜ao de transforma¸c˜oes, como ´e o caso de templates em JaTS, ´e importante que tais padr˜oes sejam capazes de representar n˜ao-terminais da gram´atica. No entanto, como j´a dissemos anteriormente, n˜ao ´e poss´ıvel a declara¸c˜ao de templates para representa¸c˜ao de sub-estruturas isoladas.
Para superar tal limita¸c˜ao, decidimos estender a sintaxe de declara¸c˜ao de templates de JaTS de forma a permitir a defini¸c˜ao de seus tipos, numa abordagem similar `a adotada em [Oli04]. Isto possibilita a declara¸c˜ao de padr˜oes compat´ıveis com v´arios n˜ao-terminais da gram´atica e, conseq¨uentemente, a defini¸c˜ao de transforma¸c˜oes para micro-estruturas.
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 31
Al´em do tipo, decidimos associar um identificador ao template, que antes era uma enti- dade anˆonima. Isto possibilita a manipula¸c˜ao da estrutura de forma mais natural, como veremos na Se¸c˜ao 4.3.2.
A sintaxe de declara¸c˜ao de um template em JaTS-TL ´e a seguinte:
<tipo > <nome > { <padrao > }
Onde <tipo> indica o tipo da estrutura representada pelo template, <nome> ´e uma vari´avel JaTS que deve atender o padr˜ao sint´atico #<id>, e <padrao> o padr˜ao de pro- grama em si, que representa a estrutura de acordo com o tipo informado.
A Listagem 4.1 apresenta um exemplo de declara¸c˜ao de template em JaTS-TL.
Listagem 4.1 Template representando uma unidade de compila¸c˜ao. CompilationUnit # dec {
PackageDeclaration :# pd ; ImportDeclarationSet :# ids ;
public class #C {
private Type :# t # field ; FieldDeclarationSet :# fds ; MethodDeclarationSet :# mds ; }
}
A especifica¸c˜ao do tipo da estrutura representada permite ao usu´ario a defini¸c˜ao de templates para diversas sub-estruturas, como declara¸c˜oes de classes, m´etodos, atributos, seq¨uˆencia de comandos, nomes, etc. O exemplo da Listagem 4.2, por exemplo, mostra a declara¸c˜ao de um template utilizado para gera¸c˜ao de um m´etodo get de acesso ao atributo mapeado `a vari´avel #field.
Este tipo de declara¸c˜ao ´e utilizada com freq¨uˆencia na especifica¸c˜ao de transforma¸c˜oes que comp˜oem refatora¸c˜oes, tanto na decomposi¸c˜ao estrutural de fragmentos do c´odigo quanto na gera¸c˜ao de estruturas que posteriormente passam a compor o c´odigo final.
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 32
Listagem 4.2 Template representando uma declara¸c˜ao de m´etodo get. MethodDeclaration # md {
public Type :# t get ::# field () { return this .# field ;
} }
Desta forma ´e poss´ıvel decompor transforma¸c˜oes complexas em transforma¸c˜oes menores, o que melhora a modularidade e legibilidade do c´odigo.
Templates podem ser declarados em arquivos individuais, como ocorre na vers˜ao ori- ginal de JaTS, o que permite a reutiliza¸c˜ao destes em v´arias transforma¸c˜oes, ou direta- mente no meta-programa onde s˜ao utilizados. No meta-programa os templates passam a ser representados por vari´aveis que, atrav´es de uma sintaxe espec´ıfica, s˜ao utilizadas na defini¸c˜ao de transforma¸c˜oes. Maiores detalhes sobre esta sintaxe, a linguagem de meta- programa¸c˜ao e a sintaxe para imers˜ao de declara¸c˜oes de templates em meta-programas JaTS ser˜ao apresentados na Se¸c˜ao 4.3.
4.2.2 Listas de Comandos
O principal elemento constituinte da sub-´arvore que comp˜oe o corpo de m´etodos ´e a es- trutura statement, que chamaremos de comando neste trabalho. Listas de comandos, aninhados ou n˜ao, comp˜oem o corpo de m´etodos e s˜ao usados para descrever o com- portamento de programas Java, o que coloca este tipo de estrutura em uma posi¸c˜ao de destaque no contexto de transforma¸c˜oes que envolvem melhoria de qualidade de c´odigo. A grande maioria das refatora¸c˜oes age, direta ou indiretamente, sobre comandos, o que exige da ferramenta de transforma¸c˜ao a capacidade de prover ao usu´ario um meio para tratar este tipo de estrutura.
Analisando refatora¸c˜oes cl´assicas e transforma¸c˜oes relacionadas a reestrutura¸c˜ao de c´odigo, conclu´ımos que uma constru¸c˜ao espec´ıfica para representa¸c˜ao de listas de coman- dos agregaria grande expressividade `a linguagem com rela¸c˜ao ao tratamento de c´odigo em corpo de m´etodos, devido ao ganho em versatilitade na defini¸c˜ao de padr˜oes envolvendo tais estruturas.
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 33
Em JaTS-TL definimos um novo tipo de meta-vari´avel para representa¸c˜ao de listas de comandos, chamado StatementList. Seu escopo de ocorrˆencia ´e o mesmo de qualquer comando, o que permite, inclusive, a intercala¸c˜ao entre declara¸c˜oes de vari´aveis do tipo listas de comandos e trechos de c´odigo concreto.
Suponha, por exemplo, uma aplica¸c˜ao que utiliza logs para execu¸c˜ao de testes, que apresentam mensagens de sucesso no in´ıcio da execu¸c˜ao de cada m´etodo e s˜ao habilita- dos e desabilitados conforme a necessidade. Conclu´ıda a fase de desenvolvimento, seria uma boa pr´atica remover o c´odigo referente ao mecanismo de log, tanto para melhoria de performance quanto de tamanho de bytecode. Assumindo que tais instru¸c˜oes de log seguem um determinado padr˜ao, o template da Listagem 4.3 poderia ser utilizado para o casamento e o template da Listagem 4.4 para a gera¸c˜ao em uma transforma¸c˜ao que exclui o c´odigo referente ao log.
Listagem 4.3 Template de casamento com utiliza¸c˜ao de StatementLists. Type :# t # metodo () {
StatementList :# sl1 ; if ( LOG == true ) {
System . out . println ( Literal :# str ); }
StatementList :# sl2 ; }
Listagem 4.4 Template de gera¸c˜ao que exclui o log. Type :# t # metodo () {
StatementList :# sl1 ; StatementList :# sl2 ; }
A forma como os templates s˜ao declarados permite, inclusive, que o comando de log n˜ao seja o primeiro comando do m´etodo, para os casos que ocorram declara¸c˜oes de vari´aveis locais ou qualquer outro tipo de inicializa¸c˜ao. A ´unica restri¸c˜ao ´e que o comando if onde encontra-se o comando de impress˜ao esteja na raiz do corpo do m´etodo, ou seja, no n´ıvel de aninhamento zero.
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 34
´
E importante observar que n˜ao h´a restri¸c˜oes quanto a posi¸c˜ao de ocorrˆencia de vari´aveis do tipo StatementList na lista de comandos de um bloco. Isto permite a defini¸c˜ao de templates de casamento bastante elaborados em rela¸c˜ao aos existentes at´e ent˜ao. Vari´aveis do tipo lista tamb´em est˜ao presentes em MetaJ [Oli04], por´em, existem restri¸c˜oes quanto a posi¸c˜ao e quantidade de ocorrˆencias quando a gram´atica da constru¸c˜ao ´
e recursiva `a direita.
O mecanismo de casamento de padr˜oes para listas de comandos em JaTS foi elabo- rado de forma a garantir que, se houver pelo menos uma possibilidade de casamento entre o padr˜ao descrito e o c´odigo fonte, o casamento ser´a realizado sem interferˆencia do usu´ario. Para que isto fosse poss´ıvel, definimos um processo de casamento seq¨uencial que leva em considera¸c˜ao a ordem de ocorrˆencia dos padr˜oes. Ou seja, havendo m´ultiplas possibilidades de casamento entre o template descrito e o c´odigo concreto, o casamento se dar´a de acordo com o padr˜ao que primeiro se adequar conforme a ordem de ocorrˆencia dos comandos no c´odigo. Por exemplo, caso o c´odigo da Listagem 4.5 fosse transformado segundo os templates das Listagens 4.3 e 4.4, o c´odigo resultante seria o apresentado na Listagem 4.6. Note que o primeiro if da seq¨uˆencia de comandos foi removido, pois foi o primeiro a se adequar ao padr˜ao determinado.
Listagem 4.5 Exemplo de c´odigo de uma opera¸c˜ao banc´aria. double getSaldoDisponivel () {
double resultado = 0; if ( LOG == true ) {
System . out . println (" Metodo getSaldoDisponivel invocado ."); }
resultado = this . getSaldo (); if ( LOG == true ) {
System . out . println (" Retorno de getSaldo ok ."); }
resultado += this . getLimiteCredito (); return resultado ;
}
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 35
Listagem 4.6 C´odigo resultante ap´os a transforma¸c˜ao. double getSaldoDisponivel () {
double resultado = 0;
resultado = this . getSaldo (); if ( LOG == true ) {
System . out . println (" Retorno de getSaldo ok ."); }
resultado += this . getLimiteCredito (); return resultado ;
}
Considere que T ´e um template de casamento e C um trecho de c´odigo concreto. Para o casamento entre ambos segue-se os seguintes passos:
1. Faz-se i = ´ındice do primeiro comando de C ;
2. Casa-se o primeiro trecho de c´odigo concreto c do template T com a primeira ocorrˆencia dele a partir do comando de ´ındice i no c´odigo fonte C. Para tal, c ∈ C ∧ c ∈ T.
3. Casa-se o trecho de c´odigo anterior a c do template T com o trecho anterior a c do c´odigo fonte C. Ou seja, sendo T = x;c;s e C = y;c;t, realiza-se o casamento x → y;
• Se o casamento x → y falhar
– Faz-se i = ´ındice do ´ultimo comando de c adicionado de 1; – Volta-se ao passo 2;
4. Se t estiver vazio e s estiver vazio ou composto por vari´aveis compat´ıveis com vazio, o processo ´e encerrado com sucesso;
5. Volta-se ao passo 1 considerando s e t como C e T respectivamente. • Se o casamento falhar
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 36
– Volta-se ao passo 2; ´
E importante notar que cada um destes passos engloba algoritmos de casamento bas- tante elaborados. Por exemplo, a identifica¸c˜ao de blocos de c´odigo concretos compat´ıveis entre si no template e no c´odigo objeto exige uma heur´ıstica de busca n˜ao trivial. Por´em, o detalhamento de tal mecanismo n˜ao ´e o foco deste trabalho e n˜ao ser´a abordado aqui. No transcorrer desta se¸c˜ao descrevemos outros detalhes sint´aticos e semˆanticos da cons- tru¸c˜ao, mantendo o foco na linguagem de transforma¸c˜ao.
Vimos at´e aqui templates de casamento que contˆem trechos de c´odigo concreto, que contribuem para a determina¸c˜ao dos valores das vari´aveis que ocorrem no c´odigo. No entanto, em alguns casos, ´e interessante para o usu´ario definir templates mais gen´ericos, que n˜ao se restrinjam a trechos sint´aticos espec´ıficos. Um caso particular de declara¸c˜ao de vari´aveis do tipo StatementList que contribui para ente tipo de tarefa ´e a ocorrˆencia de m´ultiplas declara¸c˜oes seq¨uenciais em um template de casamento.Considere, por exemplo, o c´odigo da Listagem 4.7.
Listagem 4.7 Vari´aveis de tipo StatementList seq¨uenciais. Type :# t # metodo () {
StatementList :# sl1 ; StatementList :# sl2 ; StatementList :# sl3 ; }
A princ´ıpio, declara¸c˜oes como estas levariam o casamento a um caso indecid´ıvel, pois n˜ao seria poss´ıvel para o sistema detectar que trechos de c´odigo corresponderiam `as vari´aveis #sl1, #sl2 e #sl3. No entanto, a semˆantica de casamento seq¨uencial definida para vari´aveis StatementList determina que as restri¸c˜oes de escopo s˜ao determinadas pelos trechos de c´odigo concreto presentes no template e por vari´aveis com valores pr´e- mapeados antes do in´ınio do processo de casamento. Portanto, sendo #sl1, #sl2 e #sl3 vari´aveis n˜ao instanciadas, a primeira vari´avel casaria com a lista completa de comandos que compusesse o corpo do m´etodo. As vari´aveis #sl2 e #sl3 se manteriam como listas vazias, n˜ao impedindo a conclus˜ao do processo de casamento com sucesso.
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 37
StatementList, como mostra o exemplo citado anteriormente, n˜ao pode ser tratada
como um erro semˆantico. De fato, esta ´e uma alternativa que oferece grande flexibilidade na declara¸c˜ao de templates. Por exemplo, podemos dizer que o template da Listagem 4.7 ´
e uma generaliza¸c˜ao do template da Listagem 4.3, j´a que a declara¸c˜ao
StatementList:#sl2 ´
e uma generaliza¸c˜ao do c´odigo if (LOG == true) {
System.out.println(Literal:#str); }
Portanto, para que tiv´essemos equivalˆencia entre os templates das Listagens 4.7 e 4.3, bastaria associar-mos a vari´avel #sl2 a um template que representasse o padr˜ao do if em quest˜ao:
StatementList # sl2 { if ( LOG == true ) {
System . out . println ( Literal :# str ); }
};
Este tipo de especializa¸c˜ao pode ser realizado de forma simples e direta em meta- programas descritos em JaTS-ML, que veremos adiante.
4.2.3 Tratamento de Contextos
De forma geral, chamamos de contexto o c´odigo em torno de um determinado trecho de interesse, ou seja, o ambiente no qual um fragmento de c´odigo encontra-se inserido. Par- ticularmente, neste trabalho estamos considerando o espa¸co restrito a corpo de m´etodos. Portanto, na abordagem aqui apresentada contextos s˜ao entidades locais ao escopo de m´etodos.
A extra¸c˜ao de trechos de c´odigo e a manipula¸c˜ao de contextos ´e uma t´ecnica comum em refatora¸c˜oes como Extract Method, Replace Temp With Query e Introduce Explaining
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 38
Variable [FBB+99]. Transforma¸c˜oes como estas exigem n˜ao apenas a transferˆencia de
fragmentos de c´odigo como tamb´em a an´alise e extra¸c˜ao de informa¸c˜oes do contexto em que tais fragmentos encontram-se inseridos. ´E importante, portanto, que, em uma ferra- menta de transforma¸c˜ao baseada em templates, haja algum tipo de recurso que permita a representa¸c˜ao de padr˜oes para contextos.
A priori, poder´ıamos supor que vari´aveis do tipo StatementList poderiam ser sufici- entes para representa¸c˜ao de contextos, afinal, atrav´es delas podemos facilmente descrever padr˜oes do tipo
void metodo () {
StatementList :# st1 ; < codigo >
StatementList :# st2 ; }
onde < codigo > representa o trecho de c´odigo imerso no contexto e os trechos re- presentados por #st1 e #st2 as por¸c˜oes de c´odigo anterior e posterior ao trecho interno, que compostas, formam o contexto completo.
No entanto, o c´odigo imerso no contexto pode estar aninhado em qualquer n´ıvel de profundidade no bloco de c´odigo que comp˜oe o corpo do m´etodo. Por isso, nem sempre vari´aveis do tipo StatementList s˜ao suficientemente expressivas para representar tais padr˜oes. Considere, por exemplo, o trecho de c´odigo Java da Listagem 4.8.
Listagem 4.8 C´odigo com aninhamento de comandos. 1 double getSaldoDisponivel () {
2 double resultado = 0;
3 if ( LOG == true ) {
4 System . out . println (" Metodo invocado .");
5 }
6 resultado = this . getSaldo ();
7 resultado += this . getLimiteCredito ();
8 return resultado ;
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 39
Suponha que pretendˆessemos definir uma transforma¸c˜ao para extra¸c˜ao do comando da linha 4 da Listagem 4.8. A princ´ıpio, poder´ıamos supor que o template da Listagem 4.7 seria suficiente para realizar o casamento de padr˜ao, bastando para tal realizar a seguinte instancia¸c˜ao:
#sl2 → System.out.println("metodo invocado.");
No entanto, os trechos de c´odigo anterior e posterior a tal comando n˜ao s˜ao listas de comandos sintaticamente v´alidos, pois o c´odigo a ser extra´ıdo encontra-se aninhado em uma estrutura if. Isto exigiria que o seguinte mapeamento fosse realizado:
#sl1 → double resultado = 0; if (LOG == true) {
o que violaria a corre¸c˜ao sint´atica da vari´avel #sl1. Este ´e um caso t´ıpico onde o contexto necessita de uma representa¸c˜ao individual, que permita sua manipula¸c˜ao como uma estrutura ´unica, sem viola¸c˜oes sint´aticas.
De forma geral, a conjuntura da situa¸c˜ao de que estamos tratando pode ser ilustrada segundo a Figura 4.2. Onde B ´e uma sub-estrutura da ´arvore do programa que representa um trecho de c´odigo sintaticamente v´alido. Sendo X o trecho de c´odigo de interesse, C representa o contexto de X. Sendo que B = C + X.
Figura 4.2 Esbo¸co de um Contexto na ´Arvore
O tratamento do contexto como uma estrutura ´unica e isoladamente v´alida per- mite a consider¸c˜ao de transforma¸c˜oes que envolvem a manipula¸c˜ao direta do contexto. Al´em de aplica¸c˜oes relacionadas a refatora¸c˜oes cl´assicas, existe um grande potencial de aplica¸c˜ao em refatora¸c˜oes customizadas, envolvendo novas tecnologias como, por exem-
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 40 class C { ... pub T m () { Context[ body ] } } → class C { ... pub T m () { body } } privileged aspect A { void around (C cthis ):
exec (T C.m ()) && this ( cthis ) {
Context[ proceed ()] [ cthis / this ] }
}
Figura 4.3 Extra¸c˜ao de Contexto para Aspecto
plo, AOP [Kic96]. J´a existem propostas de refatora¸c˜oes para AspectJ [MF05], como a refatora¸c˜ao Extract Context [Col05], que possibilita a extra¸c˜ao de um contexto para um aspecto, como mostra o modelo da Figura 4.3. Transforma¸c˜oes como esta s´o vˆem a corroborar a id´eia de que ´e pujante a necessidade de um recurso nas linguagens de transforma¸c˜ao que permita a representa¸c˜ao declarativa de contextos.
Ap´os a an´alise de uma s´erie de transforma¸c˜oes envolvendo contextos, conclu´ımos que, para representar tais padr˜oes em templates, ´e necess´aria a existˆencia de um tipo de meta- estrutura com a forma C [X ], onde X representa um trecho de c´odigo e C o contexto que o envolve. Em nossa abordagem, X pode ser qualquer seq¨uˆencia de comandos v´alida presente na AST do programa. J´a o contexto C ´e, tamb´em, uma seq¨uˆencia de comandos imersa em um corpo de m´etodo M, tal que C [X ] ∈ M.
Tomando mais uma vez como exemplo o c´odigo da Listagem 4.8, sendo M o m´etodo getSaldoDisponivel() e X o c´odigo da linha 4, em um padr˜ao do tipo M C [X ] ter´ıamos a seguinte correspondˆencia:
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 41
M <todo o c´odigo do m´etodo> double resultado = 0; if (LOG == true) { } C resultado = this.getSaldo(); resultado += this.getLimiteCredito(); return resultado; X System.out.println("Metodo invocado.");
Sem d´uvida, esta defini¸c˜ao de contexto em JaTS pode ser estendida para que n˜ao ape- nas comandos sejam representados, mas tamb´em outras estruturas de granularidade mais fina, como express˜oes e nomes. Por´em, por quest˜ao de coerˆencia com a implementa¸c˜ao atual, manteremos a restri¸c˜ao conceitual aqui apresentada, o que facilita a compreens˜ao do leitor e n˜ao prejudica em absoluto a explana¸c˜ao da contribui¸c˜ao do trabalho.
Formalmente, dizemos que um contexto em JaTS ´e uma fun¸c˜ao para constru¸c˜ao de fragmentos de templates, que recebe como parˆametro um trecho de c´odigo objeto X (c´odigo concreto ou meta-vari´avel valorada) e d´a como retorno uma lista de comandos L, tal que X ∈ L. Podemos dizer ent˜ao que declara¸c˜oes de contexto s˜ao constru¸c˜oes de meta-meta-programa¸c˜ao.
Para a concretiza¸c˜ao dos conceitos expostos at´e aqui, definimos um novo tipo de constru¸c˜ao capaz de representar estruturas do tipo C [X ], chamado ContextDeclaration. Atrav´es dela ´e poss´ıvel realizar declara¸c˜oes como a do template da Listagem 4.9, onde o trecho de interesse ´e representado por #codigo e o contexto por #contexto.
Listagem 4.9 Declara¸c˜ao de contexto. Type :# t # metodo () {
ContextDeclaration :# contexto { # codigo }; }
A sintaxe para declara¸c˜oes de contexto ´e a seguinte:
ContextDeclaration :< var_contexto >{ < var_parametro > };
Onde <var_contexto> e <var_parametro> s˜ao vari´aveis JaTS que representam o contexto e o fragmento de c´odigo envolvido, respectivamente.
4.2 EXTENS ˜OES DA LINGUAGEM DE TEMPLATES 42
O escopo de ocorrˆencia de declara¸c˜oes deste tipo ´e idˆentico ao de vari´aveis do tipo StatementList, j´a que este ´e, digamos, o tipo de retorno da fun¸c˜ao de contexto.
No exemplo da Listagem 4.9, o contexto representa todo o bloco que comp˜oe o corpo do m´etodo, menos o trecho interno representao por #codigo. No entanto, ´e poss´ıvel definir contextos com escopo bem mais restrito, ou mesmo m´ultiplos contextos em um m´etodo, como mostra a Listagem 4.10.
Listagem 4.10 M´ultiplos contextos em um bloco. Type :# t # metodo () {
ContextDeclaration :# contexto1 { # codigo1 }; StatementList :# sl ;
ContextDeclaration :# contexto2 { # codigo2 };