Compiladores 07/03/2012

   # # # # # # # # # # # # #
  # Compiladores            #
  # Professora Mariza       #
  # notasdogarcia.blog.com  #
   # # # # # # # # # # # # #

// A aula começou com uma revisão da ultima aula.

  Lembram-se que um compilador tem o frontend e o backend?

  O assunto do curso é focado no frontend.

  A primeira etapa a Análise Léxica é feita de forma semelhante a um automato, a cada caractere lido muda-se de estado até reconhecer um elemento da linguagem.

  A cada reconhecimento uma tupla de dados chamados token é adicionada a lista de elementos encontrados.

  Como já falamos na aula passada o primeiro elemento do token é um identificador de que tipo de token ele é, e o segundo guarda os dados relacionados.
  Ex: o caractere 5 seria o token: <num, 5>, é um número mais especificamente no valor 5.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Análise Sintática

  Ela é feita utilizando-se uma Árvore de Derivação que verifica se a estrutura dos tokens é uma estrutura reconhecida pela gramática ou não.

  A árvore efetivamente usada é a arvore de sintaxe abstrada, que é igual a uma arvore de derivação porém os termos não terminais
  são substituidos pelos simbolos terminais que eles geram.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Análise Semântica:

  Converções de tipo é responsabilidade do analisador semântico.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Geração de Código Intermediário.

    - Pode-se gerar, uma arvore, um assembly, uma versão pós fixada da linguagem, ou seja um código intermediario pode ser entendido de muitas formas.

    - O código intermediario deve ser fácil de ser produzido e fácil de ser traduzido para a máquina alvo.

    - Normalmente os compiladores criam várias estruturas de 3° operandos do tipo: id0 = id1 op id2

    // Em operações longas do tipo: a = b + c / d * x, são divididas em várias instruções com váriaveis temporárias do tipo:
    // t0 = c / d, t1 = t0 * x, a = b + t1

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Otimização de código:

    Normalmente um código otimizado significa um código mais rápido.
    Porém outros objetivos também podem ser visados: Um código menor, um código com menor custo energético etc.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  No geral durante a geração do código as tuplas são enumeradas, e as expressões do tipo id0 = id1 op id2 são construidos com os nomes das tuplas enumeradas.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Otimizações tem como ponto crítico a atribuição de variáveis à registradores. Já que seu número é limitado e alguns registradores já tem funções pre-definidas.

  O problema dessa parte da otimização é que é um problema NP-Completo e apesar de existerem soluções boas e muito boas, não existem soluções ótimas.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

CONCEITO:
  Fase de um compilador diz respeito a sua organização lógica (o que nós acabamos de falar).

CONCEITO:
  Um Passo de um compilador diz respeito a recepção de uma entrada pelo compilador e escrita de uma saída.
  Em uma compilação completa pode-se dizer que temos dois Passos, um no frontend, e um backend.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Ferramentas que usaremos:

    - Geradores de Analisadores Léxicos, produzem análizadores léxicos a partir de uma descrição dos tokens de uma linguagem em forma de expressão regular. (IAC)
    - Gerados de Reconhecedores Sintáticos produzem automaticamente reconhecedores sintáticos a partir de uma descrição gramatical da linguagem de programação. (CUP)
    - Mecanismos de tradução dirigida por sintaxe produzem coleções de rotinas para percorrer uma arvore de derivação e gerar código intermediário.
    - A ótimização e a geração do código devem ser feitos à mão.

  Existem links para as ferramentas citadas acima no site da materia.

  // Fim da aula, agora teremos um pequeno teste para avaliar nosso conhecimento inicial da materia, ele valerá 2 pontos eerrando ou acertando.