• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
JavaCC
 

JavaCC

on

  • 3,371 views

 

Statistics

Views

Total Views
3,371
Views on SlideShare
3,340
Embed Views
31

Actions

Likes
0
Downloads
65
Comments
0

1 Embed 31

http://www.slideshare.net 31

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    JavaCC JavaCC Presentation Transcript

    • JavaCC Java Compiler Compiler Paradigmas de Linguagens de Programação Adeline de Sousa Silva - adss@cin.ufpe.br
    • Definições preliminares: Parser
      • Um parser é um programa que recebe como entrada um arquivo fonte e diz se ele está correto sintaticamente, segundo uma gramática pré-definida.
      • Há parsers bottom-up e top-down
      • Definir um parser ‘na mão’ pode ser uma tarefa muito trabalhosa.
    • Definições Preliminares: Gerador de parser
      • Um gerador de parser é um programa que recebe como entrada um arquivo de especificação da gramática a ser aceita pelo parser (o formato deste arquivo depende do gerador) e retorna um parser que reconhece esta gramática.
      • O formato do arquivo de especificação da gramática depende muito do tipo de parser gerado (top-down ou bottom-up)
    • Geradores de Parsers em Java
      • Nesta aula, iremos abordar o JavaCC, mas existem outros geradores de parser
        • SableCC
        • JLex & Cup
      • O JavaCC é um dos mais populares na comunidade Java, sendo suportado hoje pela comunidade java.net
    • JavaCC
    • JavaCC
      • Gerador de parser 100% Java, o mais utilizado pela comunidade Java. Desenvolvido inicialmente pela Sun, já passou por vários outros desenvolvedores e hoje é mantido pela java.net
      • É um parser top-down
        • Mais fácil de depurar
      • Utiliza uma sintaxe muito próxima de Java
      • Não checa a corretude do código Java inserido. Pode gerar classes que não compilam.
    • JavaCC
      • Inclui um pré-processador para geração de árvores sintáticas (jjTree)
      • Possui um repositório de gramáticas bastante extenso disponível – inclui linguagens como Java, C, C++, Perl, etc
      • Possui uma interface gráfica fácil de usar
      • Definições léxicas e sintáticas em um único arquivo
      • Não aceita ambigüidades.
        • Ex: A gramática não pode possuir recursão à esquerda .(ex: expr:= expr ‘+’ expr)
    • Gramáticas em JavaCC
      • Uma gramática JavaCC possui a seguinte estrutura:
        • Opções do Parser (Não obrigatório)
        • Definição da classe do Parser
        • Definição dos Tokens (Componente Léxico)
          • Terminais
        • Definição das Produções (Componente Sintático)
          • Ações semânticas associadas
          • Não-Terminais
    • Opções do parser
      • STATIC – diz se os métodos do parser serão estáticos (default: true)
      • LOOKAHEAD – informa o nível de profundidade do lookahead (default: 1)
      • DEBUG_PARSER – instrui o parser a registrar todas as informações durante o parsing do arquivo (default: false)
      • DEBUG_LOOKAHEAD – instrui o parser a registrar também as tentativas de lookahead (default: false)
    • Mais opções
      • UNICODE_INPUT – informa se a entrada usa a codificaçõo UNICODE
      • OUTPUT_DIRECTORY – seta o diretório onde os arquivos java serão gerados (o default é o atual)
      • FORCE_LA_CHECK- força a checagem do lookahead em todos os “choice points”, independente da especificação explícita do lookahead (default: false)
    • Definição da classe do Parser
      • Este trecho define a classe do Parser. Nesta classe, podem ser definidos métodos e variáveis auxiliares. O formato é o seguinte:
      PARSER_BEGIN(parser_name) ... class parser_name ...{ ... } ... PARSER_END(parser_name)
    • Definição dos tokens
      • Serve para especificar os tipos de tokens e as expressões regulares associadas
      • Nes t a seção são descritas as palavras reservadas
      TOKEN: { < NUMBER: (<DIGIT>)+ ( &quot;.&quot; (<DIGIT>)+ )? > | < DIGIT: [&quot;0&quot;-&quot;9&quot;] > | < EOL: &quot; &quot; > }
    • Definição das produções
      • Obedecem o seguinte formato:
      tipoRetorno nomeProducao(listaParametros): { código Java } { subProducao1() { ação semântica correspondente } [lista de subProducoes] } Declaração de variáveis, invocação de métodos, etc Código Java. Em geral, corresponde a montagem da árvore
    • Exemplo: EBNF
      • Dada a gramática na forma EBNF
        • expr := number       | expr '+' expr       | expr '-' expr       | expr '*' expr       | expr '/' expr       | - expr number := digit+ ('.' digit+)? digit := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
      • A gramática do JavaCC que o representa é a seguinte (Lembre-se de que o JavaCC não permite recursão à esquerda, por isso, é necessário modificar a gramática antes de traduzí-la ):
    • Exemplo: JavaCC
        • options
        • {     LOOKAHEAD=2;
        • STATIC=false;
        • }
        • PARSER_BEGIN(Arithmetic) public class Arithmetic { }
        • PARSER_END(Arithmetic)
    • Exemplo:JavaCC
        • SKIP :
        • {   &quot; &quot; | &quot; &quot; | &quot; &quot;
        • }
        • TOKEN:
        • {  < NUMBER: (<DIGIT>)+ ( &quot;.&quot; (<DIGIT>)+ )? >
        • | < DIGIT: [&quot;0&quot;-&quot;9&quot;] >
        • }
    • Exemplo:JavaCC
        • double expr(): {}
        • {     term() ( &quot;+&quot; expr() | &quot;-&quot; expr() )*
        • }
        • double term(): {}
        • {     unary() ( &quot;*&quot; term() | &quot;/&quot; term() )*
        • }
    • Exemplo:JavaCC
      • double unary(): { }
      • {
      • &quot;-&quot; a=element() | a = element()
      • }
      • double element(): {}
      • {
      • <NUMBER>
      • }
    • Exercício
        • Altere o exemplos dados para que estes possam reconhecer as seguintes expressões:
          • parênteses “(“ , “)” -> expr ::= (expr)
          • exponenciação -> expr ::= expr ^ expr
        • Onde a ordem de precedência é: parênteses > exponenciação