Compiladores 05/03/2012

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

  Materia:
    - Compiladores

  Professora responsável:
    - Mariza Andrade da Silva Bigonha

  Avaliações:
    - 6 testes valendo 10 pontos.
    - 1 prova obrigatória.
    - 4 TPs valendo 23 pontos no total (grupos de até 2)
    - Prova final 10 pontos.

// Calendário não será seguido ao pé da letra.

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

CONCEITO:
  Compilador recebe um programa e dá como resultado um código para uma determinada arquitetura ou para uma máquina virtual,
  ou ainda para uma outra linguagem (o que não é o caso usual).

  Pode ser descrito na forma:
                                    .____________.
                          fonte --->| Compilador | ---> objeto
                                    |____________|
                                           ||
                                           \/
                                          erros

CONCEITO:
  Interpretador recebe um programa e linha a linha compila e executa as ações equivalentes em uma arquitetura.
  Ele também recebe as entradas do próprio do programa em tempo de compilação.

CONCEITO:
  Arquitetura Vonn Noiman que é a arquitetura utilizada nas máquinas de hoje
  armazena os programas e os dados em um mesmo espaço de memória.

CONCEITO:
  Linguagem funcional é uma linguagem onde não existe sobreescrita de posições de memória.
  No geral elas são feitas com aplicação de funções sobre funções
  e são baseadas no "Cálculo Lambda" que é um modelo equipotente e concorrente da "Maquina de Turing" por assim dizer.

NOTA: Compiladores para linguagens funcionais e para linguagens do tipo Von Noimann são um tanto diferentes.

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

  Fases de um compilador:

  Primeira fase "Frontend" ou "Análise":
  // Só depende da linguagem fonte

    1 - Analise Léxica ou Linear (AL)
          -> Erro léxico quando aparece um caractere que não faz parte da linguagem.

    2 - Analise Sintática Hierarquica // Verificação se as frases fazem sentido.
          -> Erros sintáticos são aqueles de coesão do texto, ou seja quando uma frase não bate com os modelos reconhecidos.

    3 - Análise Semântica
          -> Básicamente compatibilidade de tipos entre as variáveis definidas.

    4 - Geração de Código Intermediario
          -> Código recebido como entrada na segunda fase.

  Segunda fase "Backend" ou "Síntese":
  // Depende só da linguagem objeto.
  // É a geração do código executável.

     1 - Otimização (fase opicional)
           -> Substitui A=A+1 por INC A por exemplo.

     2 - Geração de código Objeto
           -> Gera o executável.

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

  Código Fonte -> |Preprocessador| -> Código Fonte Modificado -> |Compilador| -> Código Assembly -> |Assembler| -> Programa objeto -> |Linkador| -> Programa Final.

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

CONCEITO:
  Tabela de Simbolos é uma tabela que armazena as variáveis de um programa e as informações associadas à ela.
  É utilizada pelo compilador em várias etapas.

  Informações guardadas:
    Tipo
    Nome
    Valor
    Escopo
    Se possuí parametros ou não (caso a variável seja uma função)
    // Falaremos disso em detalhes em outras aulas.

CONCEITO:
  Um Lexema é uma string de caracteres reconhecido pelo analisador léxico.
  Um caractere em branco normalmente é entendido como o separador (práticamente)universal entre dois lexemas.

  Para cada lexema o analisador léxico produz como saída um Token no formato:

  <nome-token, valor-atributo>
    - O nome é o simbolo usado durante a análise sintática, ex: "id" se for um identificador, ou "var" se for uma variável.
    - O valor aponta para a posição na tabela de simbolos referente a este token.
      onde o valor pode ser entendido como o simbolo digitado pelo usuário.

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

  TP1: Analisador Lexico: reconhecer comentários, variáveis, valores e etc.

  Exemplo do TP1:

  Entrada:
    X := A + B / 5
  Saida:
    (id   , X)
    (:=   ,  )
    (id   , A)
    (addop, +)
    (id   , B)
    (mulop, /)
    (num  , 5)

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

  TP2: Analise sintatica. // Usaremos uma ferramenta para nos ajudar a fazer o TP.

  Nessa análise deve-se usar uma arvore de derivação que indica os formatos aceitáveis para as frases.

  A saída desse tp é a arvore de sintaxe abstrata.

  // Bem fim da aula, devemos discutir melhor sobre esses detalhes dos TPs nas próximas aulas.