Implementação da programação modular II

Transcrição

1 Implementação da programação modular II - 1 Implementação da programação modular II Aula 11 Agenda Declaração e definição de dados Os conceitos relacionados com a ligação de programas Os elementos essenciais do pré-processador C/C++ Como implementar módulos de definição e módulos de implementação Objetivo Mostrar como implementar os conceitos de interface única, preservando o controle de tipos dos elementos declarados nas interfaces entre módulos. Referência Capítulo 6 Aula11-ProgramacaoModular-ii doc 26-mar-2006

2 Declaração e definição de elementos Implementação da programação modular II - 2 Ao declarar um nome em uma linguagem tipada é estabelecido que o nome existe que corresponde a valores de um determinado tipo Isto permite gerar código que interpreta corretamente os valores acessados a partir destes nomes Ao somente declarar um nome, não é definido o espaço de dados amarrado ao nome Para amarrar o nome a um espaço de dados é necessário definir o nome: alocar o espaço de dados a ser ocupado pelo valor amarrar o espaço ao nome. No conjunto de todos os módulos de um programa cada nome simbólico compartilhado por dois ou mais módulos deve ser associado a exatamente um espaço de dados Em C e C++ um único módulo do programa deve declarar e definir o nome compartilhado, os demais módulos devem somente declarar

3 Implementação da programação modular II - 3 Classes de memória Ao programar em podemos armazenar coisas em diversas classes de memória. Executável é onde se armazena o código que está sendo executado Automática é uma porção da memória principal que implementa a pilha de execução do programa contém os registros de ativação das função em execução Estática encapsulada é uma porção da memória principal que contém todos os espaços de dados globais encapsulados (declarados static ) constantes literais definidas no interior de um módulo Estática visível é uma porção da memória principal que contém todos os espaços de dados globais externos Dinâmica é uma porção da memória principal que contém espaços de dados explicitamente alocados pelo usuário (malloc, new). Persistente é onde se armazenam os dados que estarão disponíveis de uma instância de execução do programa para outra bases de dados arquivos específicos para o programa segmentos: cada arquivo utilizado corresponde a um segmento de memória virtual

4 Implementação da programação modular II - 4 Implementação em C e C++ Declarações e definições de nomes globais exportados pelo módulo servidor int A ; int F(int B) ; /* declara e define A, uma variável global de tipo inteiro e que é visível a todos os módulos que compõem o programa */ /* declara F, uma função tornada pública para todos os módulos que compõem o programa. Aqui está sendo declarado o protótipo da função. O corpo da função deverá ser fornecido no texto do módulo, devidamente precedido da declaração do cabeçalho. */ Declarações externas contidas no módulo cliente e que somente declaram o nome sem associá-lo a um espaço de dados extern int A ; /* declara A sendo uma variável de tipo inteiro e cujo espaço de memória será definido em um módulo servidor */ extern int F(int B) ; /* declara F sendo uma função cujo código será definido em um outro módulo. Aqui é declarado o protótipo da função */ Declarações e definições de nomes globais encapsulados no módulo: static int A ; /* declara e define A, uma variável global inteira e que é visível somente para os componentes do módulo em que é declarada. */ static int F(int B) ; /* declara F, uma função encapsulada no módulo sendo compilado. */ Em C e C++ o declarador static indica que o nome é conhecido no módulo mas não fora dele assegura que os dados e funções estejam encapsuladas no módulo

5 Implementação da programação modular II - 5 Ligação (Link) C e C++ particionam a memória principal em cinco domínios. código pilha estático interno estático externo dinâmico O resultado da compilação de um módulo é um módulo objeto. M1.OBJ Dados Código Tab Reloc Tab Simb Os declarados e os definidos relativos a 0 Relocável, relativo a 0 Tabela de relocação - informa os locais contendo endereços a serem relocados Tabela de símbolos - referências a nomes externos declarados e não definidos (importados) - referências a nomes externos declarados e definidos (exportados pelo módulo)

6 Implementação da programação modular II - 6 Ligação A ligação combina m >= 1 módulos objeto e módulos contidos em l >= 0 bibliotecas, produzindo o programa carregável (.EXE,.COM) No módulo objeto todos os endereços gerados são deslocamentos (offsets) relativos a zero dentro do respectivo segmento. O ligador (linker) justapõe os segmentos de cada um dos domínios definidos nos módulos objeto, formando um único grande segmento para cada domínio O conjunto destes grandes segmentos constitui o programa carregável

7 Implementação da programação modular II - 7 Relocação O ligador ajusta os endereços dos elementos contidos em cada segmento de modo que passem a ser deslocamentos relativos à origem dos correspondentes segmentos do programa A relocação ocorre com relação aos segmentos de código, estático local e estático externo A tabela de relocação contida no módulo objeto informa os pontos no código e nos dados do módulo que deverão ser ajustados

8 Implementação da programação modular II - 8 Resolução de nomes externos Cada módulo objeto contém uma tabela de símbolos agregando os nomes globais externos, particionada em símbolos somente declarados símbolos declarados e definidos Um nome externo de uma variável somente declarado em um determinado módulo necessariamente deverá estar declarado e definido em exatamente um outro módulo No caso de funções não existe a obrigatoriedade de definir todos os protótipos, entretanto todas a funções chamadas precisam estar definidas. Resolução de nomes externos ao encontrar um nome externo, caso não esteja definido, cria ou adiciona um elemento à lista de referências ao nome externo ainda não definido cada lista identifica os endereços em que o correspondente nome é usado, considerando o conjunto de todos os módulos cada a lista contém um elemento para cada referência ao nome externo contida em algum dos módulos ligados ao encontrar a definição do nome, atribui o correspondente endereço a todos os lugares referenciados pela lista e destrói a lista ao encontrar um nome externo, caso já esteja definido, atribui logo o correspondente endereço Resulta em erro se: um mesmo nome é definido mais de uma vez um determinado nome não é definido sequer um vez

9 Esquema de processamento do ligador Implementação da programação modular II - 9 Para cada módulo do programa: Calcula o endereço inicial dos segmentos de código e de dados estático interno e estático externo Copia o código do módulo e os valores iniciais dos dados Reloca todos os endereços marcados Copia para a tabela de símbolos do ligador os nomes externos do módulo e que ainda não figuravam na tabela Associa o endereço de cada nome externo definido no módulo à lista de referências a este nome Caso o nome já tenha sido definido anteriormente é emitida uma mensagem de erro São resolvidos todos os nomes externos de todos os módulos já incluídos Após incorporar todos os módulos fornecidos ao ligador, inicia-se a incorporação dos módulos de biblioteca. As bibliotecas são pesquisadas em busca de nomes ainda não resolvidos O primeiro módulo encontrado que contenha um nome a resolver é incorporado ao programa A incorporação segue exatamente o que foi descrito para módulos do programa A incorporação de módulos de biblioteca termina caso todos os nomes externos tenham sido resolvidos ou todos os nomes remanescente não possam ser resolvidos com as bibliotecas fornecidas, neste caso é emitida uma mensagem de erro para todos estes nomes

10 Implementação da programação modular II - 10 Ligação dinâmica Ligador dinâmico. carrega as bibliotecas dinâmicas à medida que forem sendo necessitadas durante a execução do programa DLL Dynamic Link Library do dynamic object todos os programas que necessitem de uma mesma biblioteca compartilham o seu espaço de código cada programa somente estabelece espaços próprios para os dados Vantagens uma biblioteca dinâmica poder ser carregada uma única vez considerando todos os programas em execução simultânea pode-se trocar um módulo sem precisar recompilar ou religar todo o programa Problemas poucas são as ocasiões nas quais uma mesma biblioteca é efetivamente referenciada por mais de um programa ativo deve-se projetar com muito cuidado as bibliotecas dinâmicas, visando explicitamente a possibilidade do seu reúso em diversos programas as bibliotecas são conhecidas pelo nome, portanto pode ocorrer colisão de nomes bibliotecas diferentes com o mesmo nome é necessário assegurar que a versão correta da biblioteca seja utilizada com cada um dos programas todos os programas utilizam a mesma versão da biblioteca a menos que se possa armazenar as bibliotecas em locais distintos todos evoluem à medida que as bibliotecas forem evoluindo

11 Implementação da programação modular II - 11 Pré-processamento Um pré-processador é um processador de linguagem recebe um arquivo contendo texto fonte e diretivas de pré-processamento produz um outro arquivo de texto fonte na mesma linguagem Instruções de pré-processamento de C e C++ #define NomeElem ValorElem #include <nome-arquivo> inclui a partir do domínio do compilador #include "nome-arquivo" inclui a partir do domínio do usuário #if Expressão TextoTrue #else TextoFalse #endif #ifdef NomeElem ou #ifndef NomeElem TextoTrue #else TextoFalse #endif #undef NomeElem

12 Regras para programar módulos em C/C++ Implementação da programação modular II - 12 Ao desenvolver programas em C ou C++ siga o recomendado no apêndice 1 Padrão de Composição de Módulos C e C++. Todos os módulos que podem ser incluídos devem conter um controle de compilação única módulo de definição tabelas de definição tabelas de dados #if!defined( Nome-arquivo_MOD ) #define Nome-arquivo_MOD // Comentário cabeçalho do arquivo Corpo do arquivo #endif // Comentário fim de arquivo

13 Controle da consistência de interfaces Implementação da programação modular II - 13 Para garantir a consistência entre módulos cliente e módulos servidores, é fundamental que se utilize exatamente a mesma definição de interface tanto ao compilar o módulo servidor, como ao compilar os diversos módulos cliente deste módulo servidor. O código da interface é redigido no módulo de definição. será incorporado através de #include ao compilar o correspondente módulo de implementação ao compilar módulos cliente deste módulo. Problemas devido a propriedades sintáticas das linguagens C/C++ variáveis externas devem aparecer exatamente uma vez sem o declarador extern todas as outras vezes devem vir precedidas deste declarador

14 Implementação da programação modular II - 14 Controle de forma de compilação Inicie o código do corpo do módulo de definição com o seguinte esquema de código: // Controle de escopo do arquivo de definição #ifdef Nome-arquivo_OWN #define Nome-arquivo_EXT #else #define Nome-arquivo_EXT extern #endif Declare cada variável global externa da seguinte forma: Nome-arquivo_EXT declaração de variável global externa Declare a inicialização de variáveis globais externas: Nome-arquivo_EXT declaração-variavel-inicializada #ifdef Nome-arquivo_EXT = Inicialização ; #else ; #endif Ao final do código do módulo de definição coloque o código: #undef Nome-arquivo_EXT

15 Implementação da programação modular II - 15 Exemplo de módulo de definição #if!defined( EXEMP_MOD ) #define EXEMP_MOD /***************************************************************** /* /* Módulo de definição: Módulo exemplo /* /* Nome do arquivo: EXEMP.H /* /****************************************************************/ // Controle de escopo do arquivo de definição #if defined( EXEMP_OWN ) #define EXEMP_EXT #else #define EXEMP_EXT extern #endif /***** Tipo de dados exportado pelo módulo *****/ typedef struct { int UmInt ; int OutroInt ; } EX_tpMeuTipo ; /* note que a declaração de tipos não é afetada pelas regras estabelecidas */ /***** Estruturas de dados exportada pelo módulo *****/ /* Estrutura de dados : Vetor de números */ EXEMP_EXT int EX_vtNum[ 5 ] #if defined( EXEMP_OWN ) = { 1, 2, 3, 4, 5 } ; #else ; #endif #undef EXEMP_EXT #endif /********** Fim da definição: modulo **********/

16 Implementação da programação modular II - 16 Inclusão do módulo de definição no de implementação No módulo de implementação redija o código de inclusão do respectivo módulo de definição na forma a seguir: #define Nome-Arquivo_OWN #include "Nome-Arquivo.H" #undef Nome-Arquivo_OWN Exemplo /***************************************************************** /* /* Módulo de implementação: Módulo exemplo /* /* Nome do arquivo: EXEMP.C /* /****************************************************************/ /* Inclusões do compilador / #include <stdio.h> /* Inclusão do respectivo módulo de definição / #define EXEMP_OWN #include "EXEMP.H" #undef EXEMP_OWN /* Inclusão de módulos de definição de servidores e de tabelas de definição */ #include "Modulo1.H" #include "Modulo2.H" #include "Tabela.INC" /* Código do módulo de implementação */... /********** Fim da implementação: modulo **********/

17 Implementação da programação modular II - 17 Alternativa Embora fora do nosso padrão, a seguinte organização funciona: Módulo de definição (.h ou.hpp) extern int XX_VarInt ; Módulo de implementação (.c ou.cpp) int XX_VarInt = 1000 ; // sem extern Esta organização tem a vantagem de não necessitar os elementos xxx_ext, nem a forma convoluta de declarar dados públicos inicializados. Tem a desvantagem de exigir a alteração de vários módulos caso seja feita alguma mudança em uma estrutura de dados interfaceada.

18 Implementação da programação modular II - 18 Implementação em Java A linguagem Java não possui explicitamente módulos de definição O módulo objeto (.CLASS) exerce os dois papéis o de módulo de definição o de código executável Vantagens não é possível ocorrerem inconsistências entre o módulo de definição e o módulo objeto Java controla e trata adequadamente as inserções duplas de nomes Em Java módulos correspondem a packages ou a arquivos de código fonte (.JAVA). Java não possui pré processador, mas permite a compilação condicional por intermédio de: if ( Expressão-Constante ) { Código expandido se True } else { Código expandido se False }