Compiladores 12/03/2012

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

type -> simple
     |  *id    // um apontador
     |  array [simple] of type

// Deve haver uma função simple() que é chamada quando se espera encontrar um simple.

simple -> array
       |  char
       |  num dotdot num

código do type:

if lookahead is {integer,char,num}
  then simple();
  else if lookahead = *
    then begin match(*) etc...

// se conseguir completar esse algoritimo complete, talvez tenha algo no site da materia.

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

  Vamos começar a fazer nosso compilador.

    Função principal: Reconhecer os símbolos terminais.

    Funções adicionais:
      - Remoção de branco
      - Remoção de comentários
      - Indicação de posição de erro // é necessário saber-se a linha e a coluna.
      - Listagem do fonte.


    Porque não juntar o analizador léxico com o sintatico?

    Porque o primeiro é mais simples. Se juntarmos os dois voce acaba gastando mais tempo com uma coisa simples.
      - Simplicidade.
      - Eficiencia, pode-se criar otimizações mais especificas para cada um.
      - A portabilidade do compilador é melhorada, cada parte pode ser criada de forma mais versátil.
    O que de fato acontece é que chama-se o analisador lexico para ver se o caractere é válido e então se chama o sintatico.
    E se repete isso a cada trecho de código.

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

  Revendo conceitos:
    - Lexema: Sequencia de caracteres reconhecia pelo analisador léxico.
    - Token: Dupla contendo o tipo do lexema e um ponteiro para as informações do mesmo.
    - Padrão: Uma determinada formação de tokens reconhecida pelo analisador sintático.

  Ex: <operador, +> ou <operador, ÷> ou <id, Aux>

  // Na prática o compilador só utiliza o primeiro item da dupla, o segundo só é útil durante a execução.

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

  // Usa-se uma expressão regular para definir os lexemas aceitos na linguagem, assim temos algumas operações que podem ser usadaso:

  Operações possíveis

  União A,L = {x | x € A ou x € L}
  Concatenação A.B = AB
  Fecho A* = qualquer sequencia gerada por 0 ou mais concatenações de A
  Fecho positivo A+ = qualquer sequencia gerada por 1 ou mais concatenações de A
  A⁵ = Palavras formadas por 5 concatenações de A

  Uma definição regular é da forma:
    {nome} => {exp regular}
  // Onde o nome é o nome do identificador
  ex: id = letra . { letra , numero }

  A ordem de precedencia é: * . ,
  // A professora usa | ao inves de , para indicar união.
  // Concatenação (.) pode ser ocultado (basta colocar duas coisas lado a lado para denotar uma concatenação).

  Ou seja para cada token de nome por exemplo "id" temos uma definição regular para dizer como ele é escrito.

  Tranquilo isso né?

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

  Notações para abreviação
  a-z denota todo o alfabeto minusculo de a até z.

  .digito? denota que se ocorrer a palavra . concatenado com um digito ele deve aparecer uma unica vez.
  (isso pode ser útil para denotar a parte fracionaria de um numero por exemplo)

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

  Notação para grafos que usaremos:

    Estado inicial:   "-> ()"
    Estado normal:    "()"
    Estado final:     "(())"
    Transição:        "->"

  Ex: ->(0)----letra------>(1)---outro_caractere--->((2)) Se chegou aqui faça: retract(); return(id)
                            \
                              ---letra ou digito----->(1)  //Isso aqui denota um loop, ou seja um estado que pode sair de sí mesmo e voltar para sí mesmo.

  Ao se chegar em um estado final, voce executa alguma ação e retorna.
  Normalmente voce da um retract() que seria um retorno no cabeçote de leitura em uma letra, e então retorna o tipo que voce recebeu.

  E é imitando essa idéia que se faz um analisador léxico.

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

  Na prox aula a professora vai encinar a usar as ferramentas para analise lexica.

  // Fim da aula.