Outro tópico que vem aí é a criação de relatórios com iReport e com JSF, duas abordagens diferentes.

Foi aí que esbarrei com o JFlex, é uma implementação em Java, baseada o JLex, sendo este último mais queixo duro. O JFlex tem uma interface gráfica bem simpática, mas que no final das contas você nem precisa usar

Uma das vantagens é que ele permite usar um modo de compatibilidade para ser usado junto com o CUP que vai analisar sintaticamente o seu programa. Assim você mata duas etapas do processo de compilação e depois pode escrever seu interpretador ou seu gerador de código!

Para facilitar a tarefa eu juntei as duas ferramentas em um “toolkit” já com 2 exemplos mastigados de como usar só o JFlex e dois de como usar a integração com o CUP. Como o pacote original do JFlex tem alguns exemplos interessantes eu deixei ele incluído no toolkit, mas já preparei os Makefiles dos projetos para referenciar a pasta lib que está no arquivo zip (baixe e descompacte no seu micro que esse parágrafo vai fazer mais sentido).

Então, para usar o JFlex é necessário entender para que ele serve antes de tudo. O objetivo dessa ferramenta gerar um programa que seja capaz de analisar uma entrada (normalmente de arquivo texto) que contém um “programa” escrito na linguagem definida e identificar se não contém algum caracter estranho ao que possa ser reconhecido. É só isso mesmo, mas escrever o analisador na mão é bem mais complicado, então por isso usamos esse tipo de ferramenta (pelo menos nos cursos de compiladores).

Para ajudar vou colocar uma figura aqui.

Temos duas areas nessa figura, uma acima do pontilhado, que é o processo de construção do analisador léxico, e a outra embaixo do pontilhado que é o uso do analisador já pronto. Neste exemplo estou trabalhando com uma linguagem fictícia chamada T1.

Uma saída comum do programa gerado pelo JFlex é uma tabela de símbolos com os valores que foram reconhecidos do programa analisado.

Para funcionar o JFlex recebe um arquivo em formato txt normalmente com a extensão .lex ou .flex, esse arquivo deve seguir um formato definido, com 3 seções separadas por %%:

1. Código do usuário – esta seção contém códigos que você precise para o seu analisador final, ela é copiada para o arquivo final
2. Definições e macros – nesta seção você define macros e seleciona as opções de configuração do JFlex
3. Regras – nesta última seção você vai definir as regras que indicam o que fazer, por exemplo retornar um símbolo, com os textos que vão sendo reconhecidos da entrada. Essas regras vão ser analisadas para gerar o autômato da linguagem que depois será codificado pelo JFlex.

É melhor colocar um exemplo bem simples aqui:

//secao do usuario, nao coloquei nada
%%
//nome da classe CalcLexer
%class CalcLexer
//ativa contagem de linhas
%line
//ativa contaagem de colunas
%column
//coloca em modo de debug que permite usar de forma isolada para testes
%debug
//macros sao escritas em expresoes regulares
LineTerminator = \r|\n|\r\n
WhiteSpace     = {LineTerminator} | [ \t\f]
dec_int_lit = 0 | [1-9][0-9]*
dec_int_id = [A-Za-z_][A-Za-z_0-9]*

%%
//regras
<YYINITIAL> {

 ";"   { return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "+"   { System.out.print(" + ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "-"   { System.out.print(" - ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "*"   { System.out.print(" * ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "/"   { System.out.print(" / ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "("   { System.out.print(" ( ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 ")"   { System.out.print(" ) ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }

 {dec_int_lit}      { System.out.print(yytext());
 return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }

 {dec_int_id}       { System.out.print(yytext());
 return (new Yytoken(0,yytext(),yyline,yychar,yychar+1));}

 {WhiteSpace}       { /* pula, não faz nada */ }   
}
[^]      { throw new Error("Caracter inválido <"+yytext()+">"); }

Então com esse arquivo podemos gerar um analisador léxico capaz de reconhecer os caracteres necessários para escrever expressões aritméticas, mas ele não vai reconhecer se estão corretamente formadas, isso é papel do analisador sintático (que será o CUP).

Outra coisa importante desse exemplo, como estamos operando em modo debug, as regras estão retornando um objeto da classe Yytoken que deve ser fornecida (no toolkit esse exemplo está todo pronto). Quando integrarmos com o CUP o retorno será uma entrada na tabela de símbolos e por isso será do tipo inteiro.

Para encerrar, um breve comentário sobre uns métodos que aparecem na área de regras, temos:

• yytext() – retorna o texto atual reconhecido pelo lexer
• yyline – retorna o número da linha atual
• yychar – retorna o número do caracter atual

Para integrar com o CUP o uso do yytext() será muito importante, então no próximo texto veremos isso com mais detalhes.

Esse problema é muito comum, ter que enviar uma senha, ou até mesmo uma mensagem de boas vindas ao sistema. Para isso podemos usar uma classe do Java que já trata isso com uma série de facilidades. Eu vou colocar aqui o exemplo mais básico de todos, mas a documentação da MessageFormat pode ser encontrada aqui.

Primeiro de tudo você precisa saber qual será o texto modelo, digamos que seja algo assim:

Olá [nome do usuário],

Bem vindo ao sistema! Seu login e senha seguem abaixo:

login=[login do usuário]

senha=[senha gerado pelo sistema]

Como podemos ver nesse exemplo, existem 3 valores que precisam ser preenchidos, é claro que COMO conseguir esses valores vai depender do seu sistema, mas provavelmente isso virá do banco de dados então o que precisamos fazer é criar a String modelo que deverá ficar assim:

String modelo = “Olá {0}, Bem vindo ao sistema! Seu login e senha seguem abaixo: login={1} senha={2}”;

A diferença entre os dois textos está nas marcações com parênteses que determinam onde o texto será trocado.

Agora só precisamos de um array do tipo Object com os valores que precisam ser trocados, curiosamente os números entre parênteses representam o índice da String no array que será trocada. Embora não seja muito natural, você poderia usar no texto modelo os números fora de ordem que na hora de substituir o Java vai buscar a String correspondente ao número que você colocou, só para ficar mais claro o texto poderia ser:

Olá {1}, bem vindo novamente, seu login é {0}

Mas eu acho que isso não é muito natural, prefiro manter a ordem igual entre modelo e array.

Bom agora precisamos de um array de Object, isto porque não são apenas Strings que podem ser substituídas, também podemos usar números e datas (veja maiores detalhes na documentação da classe). Vamos criar um array de Strings para o nosso caso com os textos:

String vetor[] = {“Juca”, “jucabala”, “senha1234″};

Agora que temos o modelo e o array (que tem os dados que vieram do banco) podemos usar a classe MessageFormat para fazer a troca:

String s = MessageFormat.format (modelo, vetor);

Assim a String s conterá o novo texto:

Olá Juca, Bem vindo ao sistema! Seu login e senha seguem abaixo: login=jucabala senha=senha1234

É claro que dá para fazer muito mais coisas com essa classe, mas para essa tarefa de modelos é uma mão na roda!

O primeiro exemplo que temos que tratar são arquivos CSV, ou Comma Separeted Value – Valores Separados por Vírgula, um tipo de arquivo tradicional para ser aberto em aplicações de planilha como Calc ou Excel. Não existe mistério em gerar esse tipo de arquivo, basta criar as Strings com os valores e as vírgulas nos lugares corretos e aí mandar para o arquivo de saída. Para processar um arquivo desses também não há mistério, basta ler linha a linha e para cada linha podemos usar o método split da classe String para separar os valores.

Mas como ler e escrever em um arquivo? Esse é o nosso tópico, então vamos a ele. Em Java, existem várias classes para se lidar com arquivos considerando que os arquivos são fluxos de bytes. A palavra em inglês é stream que pessoalmente eu acho que não é bem traduzida como fluxo no contexto de informática e programação. A vantagem dessa abstração do Java é que o programa que serve para trabalhar com arquivos pode ser facilmente modificado para trabalhar com conexões de rede.

Então sem mais delongas vamos ver um exemplo de código para abrir um arquivo e ler as linhas:

try {
   BufferedReader leitor = new BufferedReader(
      new FileReader("entrada.txt"));
   String linha = leitor.readLine();

   while (linha != null) {
      //processar a linha lida
      System.out.println("linha="+linha);
      linha = leitor.readLine();
   }
   leitor.close();
} catch (FileNotFoundException ex) {
   System.out.println("Erro " + ex);
} catch (IOException ex) {
   System.out.println("Erro " + ex);
}

E para gravar um arquivo usamos o seguinte trecho:

try {
   PrintWriter escritor = new PrintWriter(
      new FileWriter("saida.txt"));

   //aqui podemos escrever tudo que for preciso
   escritor.println("gravar minha string no arquivo");
   escritor.flush();
   escritor.close();

} catch (FileNotFoundException ex) {
   System.out.println("Erro " + ex);
}

Os pontos principais desses dois trechos de código são as partes do meio, mas antes vamos entender a estrutura de objetos. Para abrir um arquivo temos que diferenciar entre leitura e escrita assim temos Input para entrada e Output para saída. A classe FileReader é uma classe que cria uma referência para um arquivo capaz de trabalhar sobre bytes, ou seja, lendo bytes. Isso não é muito prático e por isso usamos um BufferedReader que permite ler uma linha inteira. Do outro lado a classe FileWriter permite escrever bytes e por isso vamos usar o PrintWriter para ter acesso a um método que permita escrever uma linha inteira, mas além disso precisamos chamar o método flush para descarregar as informações no arquivo e por fim o método close em ambas as situações permite fechar o arquivo.

Só mais um detalhe, a String que passamos representa o nome do arquivo, se for somente o nome, o arquivo será procurado na pasta onde o programa está executando, mas pode-se passar também um caminho completo. Uma alternativa bem legal é usar um JFileChooser, um diálogo para escolha de arquivos. Não chega a ser complicado, costumo criar um método separado que abre a janela, processa a escolha e retorna um objeto do tipo File. Tanto o FileReader quanto o FileWriter são capazes de receber um File, então se optar por usar um JFileChooser pode continuar usar os trechos de código aí de cima.

Um exemplo de uso do JFileChooser:

public static File chooser() {
   JFileChooser chooser = new JFileChooser();
   int returnVal = chooser.showOpenDialog(null);
   File f = null;
   if (returnVal == JFileChooser.APPROVE_OPTION) {
      f = chooser.getSelectedFile();
   }
   return f;
}

E assim bata fazer a chamada desse método diretamente como entrada do FileReader ou FileWriter.