Conversor de Houaiss para Babylon - parte 2

Após algumas semanas de suspense, chegamos finalmente à nossa segunda e última parte da saga do dicionário Houaiss.

Como devem estar lembrados, a primeira parte se dispôs a desmontar a ofuscação usada nos arquivos do dicionário para permitir nossa posterior análise, com o simples e justo objetivo de importá-lo para o Babylon, cujas funcionalidades de busca são bem superiores.

Feito isso, agora nos resta entender a estrutura interna do Houaiss para montar um conversor que irá ajudar o Babylon Builder a construir nosso Houaiss-Babylon. Simples, não?

A primeira parte de toda análise é a busca por padrões com um pouco de bom senso. O Houaiss armazena suas definições em um conjunto de arquivos de nome deahNNN.dhx (provavelmente deah de Dicionario Eletrônico Antônio Houaiss). Os NNN variam de 001 -- o maior arquivo -- até 065, com algumas poucas lacunas, em um total de 53 arquivos originais.

O nosso rústico importador fez o trabalho de desofuscar todos os 53 arquivos usando a mesma lógica encontrada pelo WinDbg: somar o valor 0x0B para cada byte do arquivo. Dessa forma foram gerados 53 arquivos novos no mesmo diretório, porém com a extensão TXT.

Partindo do bom senso, abriremos o arquivo maior, deah001.txt, e abriremos o próprio dicionário Houaiss, em busca de um padrão que faça sentido. Como poderemos ver na figura abaixo, o padrão inicial não é nem um pouco complicado.

As duas primeiras observações do formato do arquivo nos dizem que (1) o primeiro caractere de cada linha indica o conteúdo dessa linha, e que (2) a formatação dos caracteres é feita dentro de um par de chaves {}.

Dessa forma, podemos começar a construir nosso interpretador de arquivos do Houaiss em seu formato básico.

#include <iostream>
#include <string>

int main()
{
  char cmd; // comando da linha atualmente lida
  string line; // linha atualmente lida
  int count = 0; // contador de palavras

  while( getline(cin, line) )
  {
    cmd = line[0]; // guardamos o comando
    line.erase(0, 1); // tiramos o comando da linha
    format(line); // formatação da linha (explicações adiante)

    switch( cmd ) // que comando é esse?
    {
    case '*': // verbete
      ++count;
      cout << '\n' << line << '\n';
      break;

    case ':': // definição
      cout << line << "<br>\n";
      break;
    }
  }

  return 0;
}

Simples e funcional. Com esse código já é possível extrair o básico que precisamos de um dicionário: os vocábulos e suas definições.

Para conseguir mais, é necessário mais trabalho.

A formatação segue o estilo já identificado, de forma que podemos aos poucos montar um interpretador de formatação para HTML, que é o formato reconhecido pelo Babylon Builder. Podemos seguir o seguinte molde, chamado no exemplo de código anterior:

void format(string& str)
{
  string::size_type pos1 = 0;
  string::size_type pos2 = 0;

  while( (pos1 = str.find('<')) != string::npos )
    str.replace(pos1, 1, "<");

  while( (pos1 = str.find('>')) != string::npos )
    str.replace(pos1, 1, ">");

  while( (pos1 = str.find('{')) != string::npos )
  {
    if( pos1 && str[pos1 - 1] == '\\' ) // caractere de escape
      str.replace(pos1 - 1, 2, "{");
    else
    {
      string subStr;

      pos2 = str.find('}', pos1);

      if( pos2 != string::npos )
        subStr = str.substr(pos1 + 1, pos2 - pos1 - 1);
      else
        subStr = str.substr(pos1 + 1);

      istringstream is(subStr);

      string fmt;
      string word;
      is >> fmt;
      getline(is, word);
      if( word[0] == ' ' )
      word.erase(0, 1);

      if( fmt.find("\\i") != string::npos )
        word = "<i>" + word + "</i>";

      if( fmt.find("\\b") != string::npos )
        word = "<b>" + word + "</b>";

      if( fmt.find("\\f20") != string::npos )
        word = "" + word + "";

      if( fmt.find("\\super") != string::npos )
        word = "" + word + "";

      if( pos2 != string::npos )
        str.replace(pos1, pos2 - pos1 + 1, word);
      else
        str.replace(pos1, pos2, word);
    }
  }
}

Algumas partes ainda estão feias, eu sei. Mas, ei, isso é um código de ráquer, não é mesmo? Além do mais, se isso não é desculpa suficiente, estamos trabalhando em uma versão beta.

A partir dessas duas funções é possível dissecar o primeiro arquivo do dicionário, e assim, construirmos a primeira versão interessante do Houaiss no Babylon.

Como é normal a qualquer dicionário do Babylon, podemos instalá-lo simplesmente clicando duas vezes no arquivo (em uma máquina com Babylon previamente instalado).

O projeto atual está um tanto capenga, mas já desencripta os arquivos do Houaiss e gera o projeto do Babylon Builder sozinho. Em anexo já está um projeto do Babylon Builder. Basta copiar o arquivo Houaiss.txt para a pasta do projeto e gerar o projeto do Babylon.