Kodumaro

Mais sobre reiteração

2009-12-06T12:42:00.007-03:00

A reiteração ou iteração é um dos mais efetivos algoritmos para para processamento de sequências, mas sua eficiência não se limita a processamento de conjuntos prontos, essa técnica de algoritmo também pode ser usada para processamento de amostragens em plena coleta.

Vamos a um algoritmo bem simples, a média aritmética:

O algoritmo reiterativo pode ser expresso da seguinte forma:

(defun mean ((a-list list))
  (/
    (apply #'+ a-list)
    (length a-list)))

Agora imagine que você tem o registro contínuo do comportamento de um dado específico ao longo do tempo e gostaria de manter sua média sem preocupação como os valores em si (acho um caso pouco provável, mas…).

Se reparando bem, há dois dados importantes para o cálculo da média aritmética: a própria média e a quantidade de elementos. Basta que a função receba esses valores além dos novos valores que serão usados para atualizar a média anterior.

Assim é possível armazenar apenas a média atual e a quantidade de elementos avaliados:

(defun update-mean ((the-mean hash-table) (a-list list))
  (let ((*count* (+ (gethash 'count the-mean) (length a-list))))
    (setf (gethash 'mean the-mean)
      (/
        (+
          (apply #'+ a-list)
          (* (gethash 'mean the-mean) (gethash 'count the-mean)))
        *count*))
    (setf (gethash 'count the-mean) *count*)
    the-mean))

Então, além de receber a lista com os dados mais recentes (segundo parâmetro), a função recebe como primeiro parâmetro um hash com os dados de média anteriores.

O formato inicial do hash deve ser:

#S(hash-table :test fasthash-eql (count . 0) (mean . 0))

Ou seja, 'mean zero (0) e 'count zero (0). O hash será atualizado e retornado:

(setq *mean*
  (make-hash-table
    :initial-contents (list
      (cons 'count 0)
      (cons 'mean 0))))

Na próxima falarei em variância on-line.

[]'s
Cacilhas, La Batalema

Ideias poderosas por trás de uma piada

2009-11-04T19:41:00.004-03:00

Ricardo Bánffy fez uma piada de 1º de abril no ano passado lançando um suposto framework em Lisp chamado Kanamit.

No entanto a parte da piada é somente o terceiro tópico do texto e o Bánffy aproveitou o ar de piada para rasgar o verbo e dizer umas verdades sem medo.

Como concordo quase 100% com o texto, decidi reproduzi-lo aqui de forma séria:

Eu sempre gostei de escrever aqui sobre linguagens «exóticas». Já houve um tempo em que Python era exótico. Hoje Python é mainstream. Ruby, idem. Há até suporte a Rails no NetBeans 6 e para Python no Visual Studio. Não dá pra ser muito mais mainstream do que isso.

Nem todas as linguagens exóticas que eu conheci deram certo. Smalltalk, por exemplo, continua sendo aquela linguagem muito sofisticada, anos-luz à frente do Java, mas que quase ninguém usa. Smalltalk tem ideias poderosas demais. A ideia de rodar dentro de uma máquina virtual, de todo o código poder ser examinado e modificado «ao vivo», do compilador incremental, do class browser, do late-binding, das mensagens... Tudo isso era demais pras cabecinhas da maioria dos programadores que só conseguem entender Visual Basic ou PHP e olha lá.

Mas «Visual Basic e PHP resolvem todos os meus problemas», dizem eles. Claro. Se tudo o que eles conhecem se resume a isso, eles não imaginam sequer que existam outros tipos de problema. É uma limitação de capacidade expressiva: eles não têm as ferramentas intelectuais necessárias para expressar as classes de problemas que outras ferramentas expressam e resolvem.

Não se pode pensar em uma lâmpada fluorescente se tudo o que você conhece são pedras lascadas e peles de urso.

Uma outra linguagem muito além do seu tempo é o Lisp. Além do seu tempo porque, se ela é uma coisa poderosa hoje comparada ao que temos hoje, imaginem em 1960 quando ela foi inventada…

Por muito tempo, havia implementações de Lisp para computadores desktop, mas, com processadores de 16 bits e menos de um megabyte de RAM, essas máquinas serviam apenas como brinquedos. Você podia fazer um loop e imprimir 10 vezes «fulano é bobo», mas não muito mais do que isso.

Naquele tempo, para se rodar programas em Lisp, você precisaria de uma Lisp machine, um computador dedicado, com um processador único capaz de coisas que nenhum outro processador da época – ou de hoje – era capaz de fazer. Eram incrivelmente caras.

Mas as implementações de brincquedo eram o bastante para abrir as cabeças dos jovens computólogos (antes deles se chamarem assim). Lisp e Scheme (um dialeto de Lisp) são usados como ferramenta didática em todos os bons cursos de ciência da computação. Se no seu curso não tem, pare de perder tempo e paça seu dinheiro de volta. Não sei quanto é a mensalidade, mas é certo que o curso vale menos.

E, claro, hoje em dia, temos computadores amplamente capazes de rodar boas implementações de Lisp. Meu notebook consegue emular uma Lisp machine da Texas Instruments (uma Micro-Explorer) mais depressa do que ela era originalmente.

Artigo original: O Kanamit Web Framework.

[]'s
Cacilhas, La Batalema

Mais sobre programação funcional

2009-10-21T22:01:00.007-03:00

Aproveitando o ensejo do artigo anterior sobre programação funcional, gostaria de puxar mais este artigo sobre três algoritmos tradicionais: sequência de Fibonacci, fatorial e quick sort.

Fatorial

Fatorial é um dos algoritmos recursivos mais tradicionais da Matemática. É também um dos algoritmos mais simples:

Sua implementação tanto em Haskell quanto em Common Lisp descreve exatamente esse algoritmo.

Em Haskell:

factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * (factorial (n - 1))

Em Common Lisp:

(defun factorial ((n integer))
  (if (= n 0)
    n
    (* n (factorial (- n 1)))))

Já em Scheme a coisa pode complicar… se o interpretador (uso guile) tiver sido compilado com suporte a bignum, tudo bem, se não, é preciso fazer uma pequena mágica, multiplicando os resultados do maior para o menor:

(define (factorial n)
  (define (loop k l)
    (if (zero? k)
      l
      (loop (- k 1) (* k l))))
  (loop n 1))

Sequência de Fibonacci

A Sequência de Fibonacci é uma progressão natural iniciando por 1, 1 e progredindo ao passo de que cada elemento é a soma dos dois anteriores:

É uma sequência recursiva em árvore binária, o pesadelo dos programadores. =D

Mas como já foi muito estudada, há diversas formas de implementá-la sem usar código recursivo, como algoritmo reiterativo, potência de matrizes e função fechada.

A seguinte implementação em Haskell utiliza recursão e lista infinita:

fib :: [Integer]
fib = 1 : 1 : zipWith (+) fib (tail fib)

Já em Common Lisp foi uma boa ideia usar reiteração, muito mais elegante do que seria possível em qualquer linguagem imperativa:

(defun fib (index)
  (check-type index (integer 0 *))
  (loop
    for a = 1 then b
    and b = 1 then (+ a b)
    repeat index
    finally (return a)))

Quick sort

O algoritmo de ordenação quick sort é a exceção das exceções: um algoritmo de ordenação recursivo em árvore binária, o que deveria ser o pior dos casos, no entanto é um dos métodos de ordenação mais rápidos e eficientes que conhecemos.

O princípio é o seguinte: toma-se um elemento qualquer da lista, tradicionalmente o primeiro, então separa-se a lista em duas, uma de elementos menores que o tomado e outra de elementos maiores. Aplica-se a mesma ordenação quick sort a cada uma das novas listas e concatena-as com o elemento tomado no meio.

Em Haskell isso pode ser descrito assim:

qsort :: Ord a => [a] -> [a]
qsort [] = []
qsort (x:xs) = qsort lesser ++ [x] ++ qsort greater
    where
        lesser =  [e | e <- xs, e < x]
        greater = [e | e <- xs, e >= x]

Em Common Lisp o princípio é o mesmo, mas com aquele monte de parêntesis característicos de Lisp:

(defun qsort ((a-list list))
  (if (< (length a-list) 2)
    a-list
    (let ((x (pop a-list)))
      (concatenate 'list
        (qsort
          (loop for e in a-list
            if (< e x)
              collect e))
        (list x)
        (qsort
          (loop for e in a-list
            if (>= e x)
              collect e))))))

**

Espero que este artigo tenha sido interessante e cause curiosidade aos leitores sobre programação funcional.

[]'s
Cacilhas, La Batalema

Oddwording de novo

2009-10-16T21:46:00.012-03:00

Em maio de 2007 publiquei um artigo sobre a implementação do algoritmo oddwording em diversas linguagens de programação.

Para relembrar, segue o código em Haskell:

module Main where

import IO


main = mainloop


mainloop :: IO ()
mainloop = do
    ph <- readString
    if ph == ""
        then
            return ()
        else do
            let nph = oddword ph
            putStrLn nph
            mainloop


readString :: IO String
readString = do
    putStrLn "Digite uma frase: "
    putStr "> "
    hFlush stdout
    s <- getLine
    return s


oddword :: String -> String
oddword s = listToStr $ invodd $ strToList s


strToList :: String -> [String]
strToList "" = []
strToList s = (take spi s) : (strToList (drop (incr spi) s))
    where spi = nextspace s


incr :: Int -> Int
incr = (+ 1)


nextspace :: String -> Int
nextspace "" = 0
nextspace (x:xs) =
    if x == ' '
        then
            0
        else
            1 + (nextspace xs)


listToStr :: [String] -> String
listToStr [] = ""
listToStr (x:xs) = x ++ " " ++ (listToStr xs)


invodd :: Ord a => [[a]] -> [[a]]
invodd [] = []
invodd (x:xs) = x : (inveven xs)


inveven :: Ord a => [[a]] -> [[a]]
inveven [] = []
inveven (x:xs) = (inv x) : (invodd xs)


inv :: Ord a => [a] -> [a]
inv [] = []
inv (x:xs) = (inv xs) ++ [x]

<update ressaca>
Havia esquecido de forçar o flush de STOUT na função readString. Corrigido!
</update>

No entanto ficou faltando uma linguagem excepcionalmente importante, Lisp.

Lisp (LISt Processing) é uma família de linguagens funcionais concebida por John McCarthy em 1958, baseada no cálculo lambda. As principais linguagens da família Lisp são Common Lisp, Scheme e Emacs Lisp.

O código acima será reimplementado abaixo em Common Lisp.

Observação: os blocos de código deverão ser escritos em arquivo na ordem inversa em que aparecem aqui, ou seja, digite cada bloco no arquivo em linhas acima do bloco digitado anteriormente.

Ciclo principal

O ciclo principal será a função mainloop. Sua lógica de funcionamento é a seguinte:

Pegar uma string digitada na entrada padrão;
Se a string for vazia, sair do programa;
Aplicar o algoritmo oddwording;
Exibir na tela o resultado;
Recomeçar o ciclo.

A função fica assim:

(defun mainloop ()
  (loop do
    (format t "~&~a~%"
      (oddword (*exit-if-empty* (*read-string*))))))

Lendo uma linha da entrada padrão

Para ler uma linha da entrada padrão, devemos exibir um prompt, ler a entrada digitada pelo usuário e remover os espaços em branco do começo e do fim:

(defun *read-string* ()
  (format t "~&Digite uma frase:~%> ")
  (string-trim " " (read-line)))

Saindo caso a string esteja vazia

Caso nada tenha sido digitado, o programa encerra. Para isso é preciso avaliar a string, encerrando o processo se apropriado, caso contrário retornar a string:

(defun *exit-if-empty* ((a-string string))
  (if (string= a-string "")
    (exit)
    a-string))

Descrição do algoritmo em alto nível

Podemos agora definir em alto nível o algoritmo oddwording:

Transformar a string em uma lista de palavras;
Inverter somente o conteúdo dos elementos de índice ímpar da lista;
Transformar novamente a lista de palavras em uma string.

(defun oddword ((a-string string))
  (list-to-str (invodd (str-to-list a-string))))

String para lista

Para transformar uma string em uma lista, basta quebrada em cada ocorrência de espaço (#\Space):

(defun str-to-list ((a-string string))
  (loop
    for i = 0 then (1+ j)
    as j = (position #\Space a-string :start i)
    collect (subseq a-string i j)
    while j))

Lista para string

Para transformar uma lista de palavras em uma string única, é preciso concatenar todos os elementos da lista, sem esquecer de acrescentar espaços entre eles:

(defun list-to-str ((a-list list))
  (string-trim " "
    (apply #'concatenate 'string
      (loop for e in a-list
        collect (concatenate 'string e " ")))))

Inversão dos elementos ímpares

Só faltou inverter os elementos de índice ímpar da lista. Nada mais simples: pegar cada elemento, se o índice for ímpar, inverter:

(defun invodd ((a-list list))
  (loop
    for x in a-list
    and i from 0
    collect (if (oddp i)
      (reverse x)
      x)))

Fazendo funcionar

Para que tudo aconteça, no final do arquivo acrescente uma chamada à função principal:

(mainloop)

E execute o arquivo com o comando clisp (aconselho o uso dos parâmetros -K full e -q).

**

Lisp tem uma abordagem extremamente elegante e clara, aproveita o paradigma funcional perfeitamente e seus programas podem ser retroalimentados recursivamente para obter-se um comportamento de aprendizado, apreciado no desenvolvimento de IA.

[]'s
Cacilhas, La Batalema

<update 2009-10-20>
Adicionada tipagem aos argumentos das funções e removido código redundante.
</update>

IDEs em ambiente GNU/Linux

2009-10-06T21:20:00.005-03:00

Semana passada escrevi um artigo sobre alguns ambientes de desenvolvimento integrado e editores de texto, alguns deles RAD. No entanto o artigo ficou muito longo, daí tive a ideia de quebrá-lo em três partes.

Publiquei em meu blog Reflexões de Monte Gasppa e Giulia C., mas agora, pensando bem, acho que cabe pelo menos uma referência aqui no Kodumaro.

As três partes do artigo são:

A quem se interessar, boa leitura!

[]'s
Cacilhas, La Batalema

Dev in Rio 2009

2009-08-21T11:00:00.001-03:00

Gente,

Notícia fresquinha no blog do Henrique Bastos:

Dev in Rio 2009: EU VOU!

Finalmente o Rio de Janeiro ganhou um grande evento de tecnologia focado no que é mais importante: Pessoas!

É com muito orgulho que apresentamos o Dev in Rio 2009, uma conferência bombástica sobre desenvolvimento de software que acontecerá no próximo dia 14 de setembro no Centro de Convenções SulAmérica, no Rio de Janeiro!

O Dev in Rio 2009, contará com palestrantes nacionais e internacionais que falarão sobre Java, Ruby e Ruby on Rails, Python, Django, Open Source, Joomla!, Métodos Ágeis, e muito mais. Nomes como Fábio Akita, Vinícius Manhães Teles, Jacob Kaplan-Moss, Guilherme Silveira, Nico Steppat, Ryan Ozimek e Jeff Patton agitarão um dia inteiro de muita tecnologia e diversão. Veja a programação detalhada no site da Dev in Rio 2009.

Mas não é só isso. Como eu disse no início, este é um evento focado em pessoas. Toda a organização do evento está voltada para promover ao máximo a interação e integração entre os presentes.

Por isso, o Dev in Rio 2009 contará com uma Arena DojoRio onde participantes e palestrantes poderão programar lado à lado, experimentando diversas linguagens e técnicas, buscando juntos as melhores formas de desenvolver software.

O evento está sendo organizado por mim (Henrique Bastos) em parceria com o meu amigo Guilherme Chapiewski, contando com todo o apoio dos membros da PythOnRio, DojoRio e #Horaextra.

A realização está sendo coordenada pelas nossas experientes amigas da Arteccom. E tê-las ao nosso lado já garante que este será um evento para marcar o circuito carioca.

Você não pode perder esta incrível oportunidade de participar desse mega evento, interagir com grandes nomes do cenário mundial de tecnologia, conhecer pessoas interessantes que compartilham a paixão pelo desenvolvimento de software, e ainda por cima começar sua semana só na terça-feira. Inscreva-se já!

Nos vemos por lá!

[]’s!

[]'s
Cacilhas, La Batalema

Ponteiro opaco

2009-07-01T19:01:00.004-03:00

Muitas vezes programadores de C++ e Java confundem encapsulamento com ocultação, o que não é a intenção da orientação a objetos.

No entanto, o contrário da ocultação, a exposição, também não é desejável para o encapsulamento, pois causa uma confusão entre interface e implementação.

Em C++, a declaração de uma classe força a exposição de sua estrutura privada. Um exemplo bem simples:

class X {
    public:
        X(int);
        ~X();

        int get(void) const;

    private:
        int value;
}

Neste exemplo insanamente simples, é possível ver a estrutura privada da classe X, o que no caso não é um problema muito sério, mas em casos ligeiramente mais complexos, é possível corromper o encapsulamento.

Uma forma de resolver o problema é usando um design pattern¹ chamado ponteiro opaco ou Pimpl.

A ideia é que a classe de interface seja apenas uma moldura (wrapper) para a classe de implementação. A classe de implementação é declarada no corpo da classe de interface, mas nada é exposto ali.

A classe de implementação vai ser finalmente implementada no arquivo onde os métodos da classe de interface são implementados. Os métodos da classe de interface então simplemente chamam os métodos da classe de implementação.

Voltemos ao exemplo… o arquivo de cabeçalho de nossa classe (x.h por exemplo) passa a ser:

class X {
    class Ximpl;

    public:
        X(int);
        ~X();

        int get(void) const;

    private:
        Ximpl *pimpl;
}

Como é possível ver, nada da implementação está exposto.

Então a classe de implementação é finalmente definida no arquivo de implementação (x.cc):

class X::Ximpl {
    public:
        Ximpl(int);
        ~Ximpl();

        int get(void) const;

    private:
        int value;

}

O resto do código fica:

X::X(int value): pimpl(new X::Ximpl(value)) {
    // Nada mais a fazer
}

X::Ximpl::Ximpl(int value): value(value) {
    // Nada mais a fazer
}

X::~X() {
    delete this->pimpl;
}

X::Ximpl::~Ximpl() {
    // Nada mais a fazer
}

X::get(void) const {
    return this->pimpl->get();
}

X::Ximpl::get(void) const {
    return this->value;
}

É claro que é um pattern extremamente desconfortável, pois é preciso implementar cada método duas vezes, uma para a classe de interface, outra para a classe de implementação… e há sim formas melhores de fazer isso.

Mas Pimpl funciona, é uma saída viável e pode salvar sua vida. =D

[update 2009-08-01]Sugestão de leitura de 0xc0de: Compilation Firewalls.[/update]

[]'s
Cacilhas, La Batalema

¹ Design patterns: antes que me crucifiquem por usar esta expressão fora do mundinho pequeno de Java, a definição de design pattern é «um jeito formal de documentar a solução para um problema de desenvolvimento», o que define corretamente ponteiro opaco.

Variaridade

2009-06-28T19:10:00.010-03:00

Uma função ~~variádica~~ variária – em inglês variadic, variable arity, aridade¹ variável – é aquela que suporta uma quantidade variável de parâmetros.

Muitas linguagens suportam funções variárias, aliás de forma bem simples. Python usa o operador * para indicar quantidade variável de parâmetros, Lua usa o operador ... e Common Lisp o operador &rest.

Outras linguagens podem ser ainda mais simples, como por exemplo Perl, onde toda função é variária e os parâmetros são recebidos na lista @_, tradicionalmente capturados por shift.

Já Java não suporta funções verdadeiramente variárias devido a sua limitação forçada de tipagem, no entanto é possível simular com o uso de Object e casting («vazamento» na falta de uma tradução melhor):

void myFunction(Object... args) {
    // Código do método
    …
}

Funções variárias em C/C++

C/C++ usa o cabeçalho stdarg.h para suporte a funções variárias.

O exemplo apresentado na Wikipédia é bastante simples: uma função printargs que recebe uma quantidade arbitrária de números inteiros, encerrando com -1 (ou qualquer número negativo em nosso exemplo), e os exibe na saída padrão.

Precisamos incluir dois cabeçalhos em C++, cstdarg para suporte a funções variária e cstdio para exibir o resultado:

#include <cstdio>
#include <cstdarg>

Ou, em C:

#include <stdio.h>
#include <stdarg.h>

A assinatura da função fica assim:

void printargs(int arg1, ...) {

Para acesso aos parâmetros múltiplos é usado um objeto va_list:

    va_list args;

A função va_start() inicializa o objeto. Ela recebe dois parâmetros: o objeto va_list e o nome do último argumento antes da lista:

    va_start(args, arg1);

Portanto é preciso haver pelo menos um argumento antes da lista variável. Podemos então exibir o primeiro parâmetro, recebido no argumento arg1:

    printf("%d", arg1);

A função va_arg() retorna o argumento seguinte. Ela recebe como parâmetros o objeto va_list e o tipo do parâmetro da lista a ser recuperado.

O tipo precisar ser plenamente promovido, ou seja, ponteiro, inteiro, ponto flutuante ou precisão dupla. Outros tipos, como char precisam sofrer casting, como por exemplo (não faz parte do código de printargs):

char c = static_cast<char>(va_arg(va, int));

Continuando o código, podemos agora reiterar sobre os resultados de va_arg() até encontrarmos o valor de parada negativo:

    int arg;
    while((arg = va_arg(args, int)) >= 0)
        printf(" %d", arg);

Após o fim da reiteração dos parâmetros obtidos do objeto va_list através de va_arg(), é preciso encerrar o objeto:

    va_end(arg);
    printf("\n");
}

Caso você queira restringir o formato de entrada da função, isso é possível usando __attribute__ em sua declaração. Por exemplo, se a função log() recebe o nível de log como primeiro parâmetro, uma string de formatação como segundo parâmetro (2) e os parâmetros variáveis a partir do terceiro (3), com formato similar ao da função printf(), isso é feito com a seguinte assinatura:

extern void
log(int level, cons char *fmt, ...)
__attribute__((format(printf, 2, 3)));

As opções para format() são printf, scanf, strftime e strfmon. Veja Declaring Attributes of Functions da documentação do GCC.

[]'s
Cacilhas, La Batalema

¹Aridade: em Matemática é o número de operandos de uma função.

Um «Olá Mundo!» pequenininho

2009-05-14T19:03:00.001-03:00

Como este blog estava muito parado, resolvi postar um «Olá Mundo!» com janela de duas linhas em Tcl/Tk:

wm title . Hello
grid [ button .bt -text { Olá Mundo! } -command exit ]

Se preferir, pode ser criado um script autoexecutável acrescentando o hash-bang:

#!/bin/sh
#\
exec wish "$0" "$@"

wm title . Hello
grid [ button .bt -text { Olá Mundo! } -command exit ]

[]'s
Cacilhas, La Batalema

Sobre APIs

2009-03-19T00:01:00.012-03:00

Umas das coisas mais importantes em programação, sem a qual ninguém consegue desevolver, é API.

API – Interface de Programação de Aplicativos – é o conjunto de recursos de que o programador dispõe para desenvolver suas aplicações.

Este artigo faz uma comparação – na verdade, mais uma demonstração – de cinco APIs muito usadas: IEEE 1003, STL, OpenStep, GLib e Java.

Para a demonstração será usado um trecho de código para ler a primeira linha de um arquivo.

Por que não a API do Windows?

Antes de começar, é preciso esclarecer por que não a API do Windows.

O objetivo de uma API é oferecer um ambiente homogêneo de programação, para que o programador não seja obrigado a reaprender a mesma coisa diversas vezes. Para facilitar isso, muitas APIs ainda podem ser usadas em diversas linguagens diferentes, outras em apenas uma.

No entanto uma API que funciona apenas em um único sistema operacional – ou ainda no grupo de sistemas operacionais de uma única empresa – não está fazendo seu trabalho, por mais usado que esse(s) sistema(s) possa ser.

Assim a API do Windows não faz mais do que se espera da interface de um sistema operacional.

É claro que é necessário que o Windows possua uma API, mesmo que seja exclusivamente para conexão de outras APIs mais universais.

IEEE 1003 (POSIX)

O padrão POSIX, definido pela IEEE, oferece uma interface completa para sistemas compatíveis com UNIX. Alguns exemplos são IBM AIX, Solaris, GNU (e daí também Linux), BSD, Mac OS X, MS Xenix e muitos outros.

O trecho de código em C para ler a primeira linha de um arquivo:

FILE *fd = fopen(filename, "r");

if (fd) {
    while (!eof(fd)) {
        char buf;
        fread(&buf, sizeof(char), 1, fd);
        printf("%c", buf);
        if (buf == '\n')
            break;
    }

    fclose(fd);
}

Observação¹: é preciso incluir o cabeçalho stdio.h ou, em C++, cstdio:

#include <stdio.h>

Observação²: a variável filename é do tipo const char *.

Observação³: foi preciso procurar ocorrência do carácter \n pois POSIX não ofereça uma função de alto nível para ler uma linha.

Observação⁴: o padrão POSIX é completamente procedimental – as demais APIs citadas aqui são orientadas a objetos –, sendo um pouco desajeitado para algumas operações.

STL

A linguagem de programação C++ possui uma biblioteca padrão própria bastante completa chamada STL – Standard Library.

Para o exemplo, é preciso incluir o cabeçalho fstream para a manipulação de arquivo e o cabeçalho iostream para a exibição dos dados na tela:

std::ifstream fd(filename);

if (fd.is_open()) {
    char buf[1024];
    fd.getline(buf, 1023);

    std::cout << buf << std::endl;
    fd.close();
}

Observação¹: como citado acima, é preciso incluir pelo menos o cabeçalho fstream ao manipular arquivos:

#include <fstream>

Observação²: a variável filename precisa ser do tipo const char * – std::ifstream não suporta std::string.

OpenStep

A empresa NeXT de Steve Jobs, ora adquirida pela Apple, abriu a API de seu sistema operacional em 1992 num acordo com a SUN Microsystems, sob o nome de OpenStep, o que permitiu, além da criação de aplicações de terceiros para NeXTSTEP, também o desenvolvimento de outros sistemas operacionais compatíveis com sua API e APIs de programação para sistemas já existentes, tornando-os compatíveis com OpenStep.

Exemplos de sistemas compatíveis com essa API são Mac OS X e GNUstep (portável para Windows e qualquer plataforma compatível com POSIX).

A API OpenStep funciona exclusivamente em Objective-C, apesar de haver alguns portes para outras linguagens, como C++, Smalltalk e Guile Scheme.

Vamos ao exemplo em Objective-C:

id fd = [NSFileHandle fileHandleForReadingAtPath: filename];

if (fd != nil) {
    char buf = 0;
    [fd seekToEndOfFile];
    unsigned long long eof = [fd offsetFile];
    [fd seekToFileOffset: 0];

    while (([fd offsetInFile] < eof) && (buf != '\n')) {
        [[fd readDataOfLength: 1] getBytes: &buf length: 1];
        printf("%c", buf);
    }

    [fd closeFile];
}

Observação¹: é preciso importar o cabeçalho Foundation.h:

#import <Foundation/Foundation.h>

Observação²: a variável filename precisa ser do tipo NSString.

Observação³: eu não conheço um método para ler uma linha de um arquivo em OpenStep, portanto usei um esquema similar ao usado acima em POSIX.

GLib

A GLib começou como parte do toolkit gráfico Gtk+ na versão 2.0, tendo evoluído para se tornar uma API multiplataforma orientada a objetos completa e independente da interface gráfica.

Você pode usar GLib em qualquer sistema POSIX e em Windows.

A maior curiosidade da GLib é que ela deixa explícita o equívoco – ou a falácia – de quem crê que não seja possível programar orientado a objetos em uma linguagem não orientada a objetos: é escrita em C e completamente orientada a objetos.

Aliás a base da GLib é o GObject que, curiosamente, não é compatível com a estrutura de orientação a objetos de C++ e outras linguagens clássicas, apesar de haver portes para C++ e outras.

O exemplo a seguir é um trecho de código em Vala, linguagem criada expecificamente para a GLib:

var file = File.new_for_path(filename);

if (file.query_exists(null)) {
    try {
        var fd = new DataInputStream(file.read(null));
        stdout.printf("%s\n", fd.read_line(null, null));
        fd.close(null);
    } catch (Error e) {
        // Ignora exceções
    }
}

[update 2009-03-19]Faltou o close.[/update]

Observação¹: é preciso «usar» GLib:

using GLib;

Observação²: a variável filename é do tipo string – equivalente em C a GString e gchar *.

Observação³: é preciso usar o pacote (--pkg) gio-2.0, que importa GIO, recursos de I/O da GLib.

Java

Em sua linguagem de programação, a SUN Microsystems optou por criar uma API própria (bem complicada e verborrágica em relação às demais, diga-se).

BufferedReader fd = null;
try {
    fd = new BufferedReader(new FileReader(filename));
    System.out.println(fd.readLine());

} catch (Exception e) {
    // Ignora exceções

} finally {
    try {
        if (fd != null)
            fd.close();
    } catch (IOException e) {
        // Ignora exceções
    }
}

Observação¹: as classes usadas estão no pacote java.io:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

Observação²: a variável filename é do tipo String.

**

Fica aqui a dica de três APIs interessantes.

[]'s
Cacilhas, La Batalema

Quem vai pra Vala?

2009-03-11T22:05:00.013-03:00

Dessa vez o pessoal do Gnome acertou a mão. Estou falando da linguagem de programação Vala.

Até hoje, quem queria programar em C# era obrigado a usar ou um sistema operacional problemático, ou uma ferramenta monstruosamente pesada e ineficiente.

Não mais.

O projeto Gnome lançou há algum tempo a linguagem Vala, fortemente baseada na sintaxe do C#, mas voltada para aplicações Gnome. Quem manja de C# ou maja de Java e já viu C# não terá dificuldade em lidar com Vala.

Instalação

Segundo a página do projeto, Vala foi feito para plataforma Gnome. Surgiu aí meu primeiro problema: uso Slackware e o Volkerding decidiu que Slackware não terá mais suporte a Gnome! Em sua total substituição, há o Xfce.

Simplesmente não há um pacote oficial de Gnome para Slackware – e os não-oficiais que já experimentei simplesmente detonaram o sistema todo.

Ainda mais: e quem usa outros SOs? Se não tiver Gnome já era?

Qual não foi minha agradável surpresa quando descobri que Vala compilou e instalou sem problemas no Slackware 12.2?! Sua dependência verdadeira é GTK+ 2.x, que você encontra em praticamente qualquer distribuição GNU/Linux ou BSD.

E Windows? Também tem!

Usando

Um «Olá Mundo» em Vala é bastante simples (tanto quanto Java, pelo menos):

using GLib;

public class HelloWorld : Object {
    public static int main(string[] args) {
        stdout.printf("Olá Mundo!\n");
        return 0;
    }
}

Ao contrário do .NET, não há código escondido do programador. Por exemplo:

using GLib;

public class HelloWorld : Object {

    private Gtk.Window window;


    public HelloWorld() {
        window = new Gtk.Window(Gtk.WindowType.TOPLEVEL);
        window.set_default_size(300, 200);
        window.destroy += Gtk.main_quit;
        window.add(new Gtk.Label("Olá Mundo!"));
    }


    public void show() {
        window.show_all();
        Gtk.main();
    }


    public static int main (string[] args) {
        Gtk.init(ref args);
        var sample = new HelloWorld();
        sample.show();

        return 0;
    }
}

~~Antes que alguém reclame, peço desculpas pelos códigos mal orientados a objetos, mas não quis ter muito o que explicar.~~
[update]Ajeitei pra ninguém ficar me chateando.[/update]

Maturidade

Estranhamente a linguagem já está bastante madura na 0.5.7. Não encontrei quebras inusitadas nem erros bizarros.

[update 2009-04-01]
Encontrei uma quebra inusitada: Vala não lida bem com closures e escopo dinâmico. Ela se perde um pouco gerando alguns erros inesperados.

Outro erro inconveniente está na API com C: o bind de método destruidor não suporta parâmetros, o que pode ocorrer em alguns casos da GLib – lembre-se do que não há métodos destruidores reais em C, mas sim funções de desalocação.
[/update]

A única coisa que tenho a reclamar muito é a documentação precária, bem longe das documentações de API bem organizadas da SUN Microsystems e da Microsoft.

IDE

Por enquanto há uma IDE chamada Val(a)IDE – só que essa já desarmou na minha cara algumas vezes – e a promessa de uma extensão para o Eclipse – que ainda não apareceu na página da própria extensão.

Segundo a página official, há também extensões para MonoDevelop (Deus me livre!) e para GEdit.

**

É isso aí! Quando eu ganhar um pouco mais de intimidade com a linguagem, escrevo mais alguma coisa. Por enquanto foi só divulgação. Um tutorial meia-boca pode ser encontrado aqui.

[]'s
Cacilhas, La Batalema

Calculadora científica com o Vim

2009-03-04T12:25:00.002-03:00

Desta vez vou reblogar…

O voyeg3r publicou um artigo curtinho e muito legal sobre como criar uma calculadora científica no Vim usando Python.

O artigo pode ser encontrado no vivaotux.

Boa leitura!

[]'s
Cacilhas, La Batalema

Propriedades e acessores

2009-01-29T23:30:00.008-03:00

Em Java e em C++ há um bom motivo para que os atributos sejam sempre privados: preservar a interface das classes.

Por exemplo, imagine que temos uma classe que representa o registro de uma pessoa. Nela temos a idade. Sendo um número inteiro, poderia ser um atributo público:

Person person;
person.age = 23;
std::cout << person.age << std::endl;

Faz sentido. Agora imagine que mais tarde descobrimos que é preciso fazer um tratamento do valor recebido – para estar numa faixa aceitável, por exemplo…

Sem alterar a interface – e efetuar uma refatoração total de todo código onde ocorre instância – é impossível.

Então, em Java e C++ é importante usar métodos acessores e manter os atributos privados. Dessa forma qualquer alteração futura pode ser feita na classe sem alterar o restante do código:

Person person;
person.setAge(23);
std::cout << person.getAge() << std::endl;

Propriedades

Já em Python isso não faz sentido!

Em Python, além de atributos e métodos, há as propriedades. Então atributos podem ser públicos e, caso seja necessário adicionar alguma lógica na leitura ou gravação do atributo, basta substituí-lo por uma propriedade, sem prejudicar a interface.

class Person:

    def __init__(self):
        self.name = ""
        self.age = 0

Substituindo por propriedades:

class Person:

    def __init__(self):
        self.name = ""
        self.__age = 0

    def _get_age(self):
        return self.__age

    def _set_age(self, age):
        if 0 <= age < 150:
            self.__age = age

    age = property(_get_age, _set_age)

E a interface permanece imutável!

Aviso: não use propriedade quando não for necessário! Use atributo público. Um pouco de desempenho não faz mal a ninguém, mesmo em scripts.

Aviso²: testei esse código no prompt e não funciona, mas funciona em script. Se alguém puder descobrir o que está acontecendo, agradeço.

[update 2009-08-26]Usando IPython funcionou corretamente, portanto não sei o que causou o erro. =P

Assim assim, valeu Thiago Coutinho por tê-lo identificado (acho que ainda ocorre durante a interpretação em linha do CPython tradicional).[/update]

Usando metaclasse

Uma forma de implementar automaticamente autopropriedades foi sugerida por Guido van Rossum em Unificando Tipos e Classes (original).

Usaremos uma metaclasse:

class autoprop(type):

    def __init__(cls, name, base, dict):
        super(autoprop, cls).__init__(name, base, dict)
        props = {}
        for method in dict:
            if method.startswith("_get_") \
                or method.startswith("_set_") \
                or method.startswith("_del_"):
                props[method[5:]] = True
        for prop in props:
            fget = getattr(cls, "_get_" + prop, None)
            fset = getattr(cls, "_set_" + prop, None)
            fdel = getattr(cls, "_del_" + prop, None)
            setattr(cls, prop, property(fget, fset, fdel))

A ideia por trás dessa metaclasse é identificar métodos iniciados por _get_, _set_ ou _del_ e criar propriedades a partir daí. O método iniciado por _get_ representa a leitura, _set_ representa a escrita e _del_ representa a remoção.

Nossa classe então ficaria assim:

class Person:
    __metaclass__ = autoprop

    def __init__(self):
        self.name = ""
        self.__age = 0

    def _get_age(self):
        return self.__age

    def _set_age(self, age):
        if 0 <= age < 150:
            self.__age = age

Usando decoradores

Mas realmente, ao contrário da metaclasse para singleton, usar metaclasse para autopropriedade é como usar uma escopeta para espantar uma mosca.

Vamos usar decoradores!

O decorador @property pode ser usado para criar propriedades para apenas leitura. Como precisamos de leitura e gravação, podemos usar @apply.

É um pouco gambiarrático, mas funciona muito bem e deixa o código relativamente limpo:

class Person:

    def __init__(self):
        self.name = ""
        self.__age = 0

    @apply
    def age():
        def fget(self):
            return self.__age

        def fset(self, age):
            if 0 <= age < 150:
                self.__age = age

        return property(**locals())

A função deve ter o nome da propriedade. O método de escrita deve chamar-se fset, o de leitura fget e o de remoção fdel. A parte mais feia desse código é o retorno. =)

**

Fica aqui a dica!

[]'s
Cacilhas, La Batalema

Interface fluente

2009-01-28T20:53:00.008-03:00

Outro pattern interessante é conhecido como carrying return (não confundir com carriage return, carácter com código ASCII 13).

[update 2009-01-29]Esse era o nome dado há uns anos atrás, quando conheci esse pattern. Porém ele não ganhou espaço entre os programadores na época e poucos continuaram usando (como eu). =P

Hoje em dia ele voltou com o nome Fluent Interface, Interface Fluente.

A propósito, troquei o título deste artigo para usar uma linguagem mais nova e mais fácil de ser reconhecida.

Valeu Walter e Lucas![/update]

~~Há outros nomes, mas não consigo encontrar no São Google, pois não é um pattern muito usado.~~

Parecido com Smalltalk

Imagine que você tem uma classe Java que recebe muitos parâmetros na instanciação:

Person person = new Person(
    aString, aDate, anotherString, aLoad, aPerson, anotherPerson
);

A quantidade de argumentos pode explodir ao extremo. Python pode apresentar maior visibilidade quanto ao significado dos parâmetros:

person = Person(
    name=aString,
    birthdate=aDate,
    id=anotherString,
    load=aLoad,
    father=aPerson,
    mother=anotherPerson
)

Smalltalk, uma linguagem bem mais antiga do que Python ou Java, já tinha uma abordagem bem mais elegante:

person := Person new.
person
    setName:      aString;
    setBirthdate: aDate;
    setId:        anotherString;
    setLoad:      aLoad;
    setFather:    aPerson;
    setMother:    anotherPerson.

É possível conseguir um código similar em Java usando acessores tipo setter:

Person person = new Person();
person.setName(aString);
person.setBirthdate(aDate);
person.setId(anotherString);
person.setLoad(aLoad);
person.setFather(aPerson);
person.setMother(anotherPerson);

Finalmente

Mas é possível obter um código ainda mais elegante usando o pattern em questão.

A ideia é simples: em vez dos acessores setter não terem retorno (void), basta eles retornarem this:

class Person {
    private String name;
    private Date birthdate;
    private String id;
    private Load load;
    private Person father;
    private Person mother;

    public Person() {
        name = null;
        birthdate = null;
        id = null;
        load = null;
        father = null;
        mother = null;
    }

    public String getName() {
        return name;
    }

    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public Date getBirthdate() {
        return birthdate;
    }

    public Person setBirthdate(Date birthdate) {
        this.birthdate = birthdate;
        return this;
    }

    public Load getLoad() {
        return load;
    }

    public Person setLoad(Load load) {
        this.load = load;
        return this;
    }

    public Person getFather() {
        return father;
    }

    public Person setFather(Person father) {
        this.father = father;
        return this;
    }

    public Person getMother() {
        return mother;
    }

    public Person setMother(Person mother) {
        this.mother = mother;
        return this;
    }
}

Agora podemos usar uma estrutura de código similar à de Smalltalk:

Person person = new Person()
    .setName(aString)
    .setBirthdate(aDate)
    .setId(anotherString)
    .setLoad(aLoad)
    .setFather(aPerson)
    .setMother(anotherPerson);

[]'s
Cacilhas, La Batalema

Singleton

2009-01-27T21:39:00.006-03:00

Um design pattern bastante conhecido na engenharia de software é singleton.

Singleton é quando uma classe possui apenas uma instância e não se deseja que em uma mesma aplicação haja mais de uma.

Exemplos de classes desejadamente singleton são pools e carregadores.

Em C++ a saída para criar uma classe singleton é tornar protegido seu método construtor e criar um método getInstance para retornar a instância única:

class Loader {
    protected:
        Loader();

    public:
        ~Loader();

        static Loader& getInstance();
}

O método getInstance deve guardar uma referência estática para a instância:

static Loader& Loader::getInstance() {
    static Loader *instance = 0;
    if (!instance)
        instance = new Loader();
    return *instance;
}

Java utiliza a mesma abordagem, já outras linguagens, como Perl, Python e Ruby têm uma abordagem bem mais elegante.

Singleton em Python

A ideia de singleton em Python – Perl e Ruby – é usar o próprio construtor da classe para obter a instância.

Por exemplo, em vez de (Java):

Image character = Loader.getInstance().getImage("char.png");

Teremos (Python):

character = Loader().getImage("char.png")

Há três formas de implementar singleton em Python: ¹implementando diretamente na classe, ²herdando um classe pai ou ³usando metaclasse (o mais divertido!).

Implementação direta na classe

Você pode implementar uma classe singleton diretamente, usando os metamétodos __new__ (construtor real) e __init__ (construtor de inicialização).

A classe ainda precisa ter um atributo de classe para armazenar a instância.

A ideia mais simples é implementar __new__ para devolver a instância em vez de uma nova a cada vez:

class Loader:

    __instance = None
    __initialized = False


    def __new__(cls, *args, **keyw):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

Repare no atributo __initialized… isso é porque ainda temos um problema: o construtor de inicialização (__init__) será chamado novamente a cada tentativa de obter a instância.

Então precisamos verificar se a inicialização já foi executada:

    def __init__(self, *args, **keyw):
        if not self.__initialized:
            self.__initialized = True
            # Restante do método...

Pronto! Nossa classe já é singleton.

Herança

Podemos usar uma classe pai que implemente unicidade e estendê-la:

class Singleton:

    __instance = None
    __initialized = False

    def __new__(cls, *args, **keyw):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, *args, **keyw):
        if not self.__initialized:
            self.__initialized = True
            self._init(*args, **keyw)

Assim, para implementar uma classe singleton:

class Loader(Singleton):

    def _init(self, *args, **keyw):
        # Este será o construtor...

A vantagem desta abordagem é sua capacidade de reaproveitamento: é possível reutilizar a classe Singleton como classe pai de cada nova classe singleton.

No entanto traz dois inconvenientes: primeiro os métodos podem conflitar com métodos de outras classes pai em herança múltipla; segundo é preciso prestar atenção à implementação estranha (uso de _init em vez de __init__) e ter cuidado com a sobrescrita de métodos.

A solução para tornar isso mais transparente é usar uma metaclasse.

Metaclasse

Metaclasse é um classe cujas instâncias são classes. Vamos criar uma metaclasse cujas classes sejam singleton:

class singleton(type):

    def __init__(cls, name, base, dict):
        super(singleton, cls).__init__(name, base, dict)
        cls.__instance = None
        cls.__copy__ = lambda self: self
        cls.__deepcopy__ = lambda self, memo=None: self

    def __call__(cls, *args, **keyw):
        if cls.__instance is None:
            cls.__instance = \
                super(singleton, cls).__call__(*args, **keyw)
        return cls.__instance

Agora vem a beleza da metaclasse: para criar uma classe singleton basta fazer:

class Loader:
    __metaclass__ = singleton

Nada mais! Todo o resto da classe pode ser implementado sem preocupações.

A única dúvida que pode ocorrer é: e se a classe tiver outra metaclasse?

É fácil resolver! Por exemplo: imagine uma classe singleton que implemente autopropriedades:

class Loader:

    class __metaclass__(autoprop, singleton):
        pass

**

Está aqui outra dica! Mais sobre singleton pode ser encontrado nas Reflexões de Monte Gasppa e Giulia C..

[]'s
Cacilhas, La Batalema

Mostrando o status e o branch de repositórios git no console

2009-01-27T11:06:00.017-03:00

Com uma função de shell script e a ajuda da variável PS1 podemos fazer uma configuração bem interessante: exibir no próprio console em qual branch estamos e qual o estado dele.

Um exemplo de como fica:

Esse é um screenshot do meu desktop, mostrando o repositório do tracks (um aplicativo interessante para quem pretende usar a metodologia GTD). Em amarelo, o caminho do repositório. Entre os colchetes, o branch no qual estamos, e finalmente, um * indicando se o repositório contém modificações ainda não confirmadas no repositório.

Para configurar, basta adicionar ao seu .bashrc:

function parse_git_dirty {
    [[ $(git status 2> /dev/null | tail -n1) \
        != "nothing to commit (working directory clean)" \
    ]] && echo "*"
}

function parse_git_branch {
    git branch --no-color 2> /dev/null | \
    sed -e '/^[^*]/d' \
        -e "s/* \(.*\)/[\1$(parse_git_dirty)]/"
}

export PS1='\u@\h \[\033[1;33m\]\w\[\033[0m\]$(parse_git_branch)$'

Visto originalmente aqui.

[]'s
- Walter Cruz

Pyglet

2009-01-24T13:11:00.007-03:00

Há alguns módulos em Python de interface com a biblioteca de mídia SDL, sendo o mais conhecido PyGame.

PyGame é legal, lembra a mim a antiga API gráfica do Colour BASIC do MSX (eita saudosismo!).

No entanto o Kao Félix apresentou recentemente um outro módulo menos conhecido, chamado Pyglet, que, a primeira vista, achei mais pythónica. =D

Gostaria então de sugirir dois tutoriais do Kao Félix:

Instalando Pyglet

Se você possui o EasyInstall, basta executar:

bash$ sudo easy_install -U pyglet

Primeira aplicação

Resolvi fazer minha primeira aplicação segundo as dicas do Kao Félix, mas adaptando a meu jeito próprio de programar.

Iniciaremos com o hash-bang, as peculiaridades de Python e os imports dos submódulos de Pyglet que vamos precisar:

#!/usr/bin/env python
# coding: UTF-8

from __future__ import division
__metaclass__ = type

from pyglet import app, clock, resource, sprite
from pyglet.window import key, Window

Carregando os recursos iniciais

Esta é classe singleton para carregar os recursos de mídia que precisaremos.

Fiz o seguinte: baixei a bola do Kao, mas pode também baixar daqui mesmo – preferível, para não sobrecarregar o link dele.

O arquivo de som está no pacote do KDE, mas você pode baixar daqui.

Nessa classe singleton, implementaremos o método __new__ (apenas para singleton) e __init__ para carregar as mídias.

Para carregar uma imagem usamos resource.image(). Para áudio, resource.media():

class Loader:
    """Singleton class for loading resources"""

    __inst = None
    __initialized = False

    def __new__(cls, *args, **keyw):
        if not cls.__inst:
            cls.__inst = object.__new__(cls)
        return cls.__inst

    def __init__(self):
        if not self.__initialized:
            self.__initialzed = True

            self.images = {}
            self.sounds = {}

            image = resource.image("char.png")
            image.anchor_x = image.width // 2
            image.anchor_y = image.height // 2
            self.images["ball"] = image

            self.sounds["pop"] = resource.media(
                "pop.wav",
                streaming=False
            )

O parâmetro streaming=False indica que o arquivo de áudio deve ser completamente carregado para a memória – e não tratado como um fluxo (stream).

Gerenciando o teclado

Uma nova classe será usada para gerenciar o teclado. O construtor armazenará uma referência para a janela principal e o método handle_input() gerenciará as teclas:

class KeyHandler(key.KeyStateHandler):
    """Class for handling key events"""

    def __init__(self, window):
        super(KeyHandler, self).__init__()
        self.window = window

    def handle_input(self, dt):
        speed = 320 * dt
        dx, dy = 0, 0

        if self[key.RIGHT]:
            dx = 1
        elif self[key.LEFT]:
            dx = -1

        if self[key.UP]:
            dy = 1
        elif self[key.DOWN]:
            dy = -1

        self.window.ball.x += dx * speed
        self.window.ball.y += dy * speed

Repare que nosso objeto window terá um atributo ball, que é um sprite.

Agora nosso sprite

Vamos criar agora uma classe que estende sprite.Sprite, a classe de sprite de Pyglet.

O único método que implementaremos será o construtor, que buscará em Loader a imagem que desejamos:

class Ball(sprite.Sprite):
    """Sprite that's a ball"""

    def __init__(self, *args, **keyw):
        super(Ball, self).__init__(
            Loader().images["ball"],
            *args, **keyw
        )

Janela principal

Finalmente a aplicação!

Por um mal hábito adquirido programando Tkinter, tenho o hábito de usar a mesma classe para aplicação e janela principal, porém você não precisa fazer ~~esse bacalhau~~ isso!

No entanto vou mostrar aqui da forma como estou habituado.

O construtor:

ajustará o título da janela (set_caption());
criará uma nova bola (classe Ball);
registrará o manipulador de eventos de teclas (push_handlers());
e registrará o método handle_input() do manipulador de eventos de teclas para execução periódica (clock.schedule_interval()).

class MainApplication(Window):
    """Main window and application"""

    def __init__(self):
        super(MainApplication, self).__init__()
        self.set_caption("Teste de movimento")

        self.ball = Ball(x=300, y=240)

        handler = KeyHandler(self)
        self.push_handlers(handler)
        clock.schedule_interval(handler.handle_input, 1/60)

Manipulando outros eventos

Os métodos de Window que manipulam eventos têm nome iniciado por on_, seguido pelo nome do evento. Por exemplo: on_close, on_draw, on_key_press, on_key_release.

Vamos implementar on_close() para tocar o som ao sair e on_draw() para exibir o sprite:

    def on_close(self):
        Loader().sounds["pop"].play()
        super(MainApplication, self).on_close()

    def on_draw(self):
        self.clear()
        self.ball.draw()

Fazendo funcionar

Para terminar, precisamos instanciar a aplicação e chamar o ciclo principal de Pyglet.

Veja que esse tipo de programação onde um módulo toma o controle e programamos os métodos que atenderão eventos caracteriza um framework.

if __name__ == "__main__":
    window = MainApplication()
    app.run()

Conclusão

Vemos aqui um ótimo módulo – ou melhor, framework – para criação de aplicações gráficas usando as bibliotecas SDL e OpenGL.

[]'s
Cacilhas, La Batalema

Atributos privados onde?

2009-01-10T07:43:00.003-03:00

Os programadores de Java e C++ pregam vigorosamente a favor de métodos e atributos privados, como se isso fosse uma grandíssima vantagem.

É um recurso… faz sentido em seu contexto, mas não traz vantagem alguma por si só – ao contrário da evangelização dos fanáticos.

De qualquer forma, o C++ não bloqueia tanto o acesso do programador quanto é pregado.

Por exemplo, voltemos lá atrás no artigo Portanto GDBM para Lua: havia uma classe GdbmObject com um descritor de arquivo de banco de dados privado.

Digamos que, por alguma razão bizarra, queiramos ter acesso direto ao descritor.

Mas o atributo é privado!

Vamos ao bacalhau:

class GdbmObjectCorrupting {
    public:
        bool closed;
        GDBM_FILE fd;
}

Repare que os atributos públicos aqui têm o mesmo tipo e o mesmo nome dos atributos privados da classe original. Isso garantirá que os símbolos gerados sejam idênticos – e este é o truque.

Agora imagine que temos a instância obj de GdbmObject, da qual queremos acessar os atributos privados. A mágica é:

GdbmObjectCorrupting *aux =
    reinterpret_cast<GdbmObjectCorrupting *>(obj);

Pronto! Já está feit~~o o bacalhau~~a a mágica!

No escopo de aux, aux->fd dá acesso direto ao descritor de obj, assim como aux->closed dá acesso ao booleano closed de obj.

Agora, este artigo é uma prova de conceito! Não aconselho ninguém a fazer isso. Aliás o Kodumaro desaprova fortemente tal prática: reitero, é apenas uma prova de conceito.

[]'s
Cacilhas, La Batalema

Perl6

2008-12-10T22:27:00.006-03:00

Larry Wall, criador do Perl e cocriador do Parrot, declarou que a versão 6 de Perl não será compatível com as versões anteriores.

Realmente dei uma olhada no Perl6 e está muito diferente… só que para melhor. =)

A única coisa de que não gostei foram das mudanças em expressões regulares, no mais as mudanças só acrescentam.

Tipagem

Uma das maiores reclamações que os programadores fazem de Perl é sua tipagem insanamente fraca, apenas três tipos: escalar ($scalar), vetor (@array) e vetor associativo (%hash).

Perl6 traz o suporte a tipos! Pelo que vi na documentação, há seis tipos novos: inteiro (int), ponto flutuante (num), string (str), booleano (bool), bit (bit) e referência (ref), de forma estática:

my int $foo = 5;
my str $bar = "foo";
my num $baz = 5.3;
my bool $foobar = 1;

Conversão:

print str 5;
print scalar @list;

Passagem de parâmetros

Em Perl a passagem de parâmetros sempre foi por cópia, agora passa a ser por referência, exceto para tipos primitivos.

No caso de atribuição de referência de tipos primitivos, em vez do tradicional:

 my $b = \$a;

Passa a ser:

 my $b := $a;

Mudanças em vetores

A criação de vetor passa a suportar um formato mais simples.

Temos o tradicional:

my @fruits = ("apple", "pear", "banana");

Que passa a ser:

my @fruits = "apple", "pear", "banana";

E a lista:

my @fruits = qw/apple pear banana/;

Passa a ser:

my @fruits = <apple pear banana>;

Em Perl5, para se obter um item de um vetor, o primeiro carácter mudava de @ para $: $fruits[0]. Agora, em Perl6, não há mais alteração: @fruits[0].

A quantidade de elementos de um vetor era dada por:

my $count = $#fruits + 1;

Agora, em Perl6 passa a ser:

my int $count = @fruits.elems;

Repara que o famigerado -> virou um simples ponto!

Também para obter o último elemento do vetor, que era:

my $last = $fruit[$#fruit];

Passa a ser:

my $last = @fruit[@fruit.end];

Ou ainda:

my $last = @fruit[*-1];

Para se obter um vetor em um contexto string, Perl6 oferece o atalho ~. Para numérico + e para booleano ?:

my str $str_fruits = ~@fruits;
my num $num_fruits = +@fruits;
my bool $bool_fruits = ?@fruits;

Tratamento de exceções

Em Perl5 era usado eval para avaliar um bloco com possível exceção e $@ recebia os dados de exceção:

eval {
    …
};
if ($@) {
    warn "exception: $@";
}

Perl6 passa a usar try-CATCH:

try {
    …
    CATCH {
        warn "exception: $!";
    }
}

Repare que a mensagem de exceção passa a ser capturada em $! e o bloco CATCH fica dentro do bloco try.

Repetições

Não há uma forma menos dolorosa de dizer isso: foreach vira for, que também passa a suportar algumas construções de while, for vira loop, que também passa a suportar algumas construções de while.

Então:

foreach (@fruits) {

Vira:

for @fruits {

foreach my $fruit (@fruits) {

Vira:

for @fruits -> $fruit {

Agora, olha o while aí:

while (my($age, $sex, $location) = splice @whatever, 0, 3) {

Vira:

for @whatever -> $age, $sex, $location {

Contando até dez em Perl5:

for (my $i = 1; $i <=10; $i++) {
    print "$i\n";
}

Contando até dez em Perl6:

loop (my $i = 1; $i <=10; $i++) {
    say $i;
}

E loop { … } funciona como while (1) { … }.

Vetor associativo

Sofre alterações parecidas com as de vetor.

Por exemplo, em Perl5:

my $c = $days{February};

Em Perl6 vira:

my int $c = %days{'February'};

Ou ainda:

my int $c = %days<February>;

Alguns métodos

Para se obter o tamanho de uma string em Perl5:

my $len = length $string;

Em Perl6 fica:

my int $len = $string.chars;

Para exibir um vetor de modo ordenado em Perl5:

print sort(@fruits);

Em Perl6:

say @array.sort;

Ou ainda:

@array.sort.print;

Variáveis de sistema

Para se obter o valor da variável HOME em Perl5:

print $ENV{HOME};

Em Perl6 passa a ser:

print %*ENV<HOME>;

Ou ainda:

print $+HOME;

Orientação a objetos

Criar uma classe em Perl5 era uma aventura!

Você criava um pacote (package) e «abençoava» um escalar com o pacote… pronto: aí tinha uma instância cuja classe era o pacote.

Um tremendo bacalhau.

Em Perl6 temos as palavras reservadas class, has (para atributos) e method (para métodos), para criar classes reais.

Métodos privados precisam começar com !, por exemplo, $!age, e métodos públicos precisam começar com ., como por exemplo $.name.

A passagem de parâmetros também mudou. Além de ser por referência, como citado, passa a suportar parâmetros nominais e parâmetros excedentes – como *args de Python, mas com a sintaxe *@args.

Se o argumento for mutável precisa ser seguido de is rw.

O que era:

package Square;
@ISA = qw/ Rectangle /;

Passa a ser:

class Square is Rectangle {

E o que era:

my $rect = new Rectangle(4, 5);

Passa a ser:

my Rectangle $rect .= new(4, 5);

Conclusão

Há muito mais! Consulte a página Perl6::Perl5::Differences, mas o que já sabemos é: quem trabalha com Perl vai precisar aprender de novo!

[]'s
Cacilhas, La Batalema

Persistência de dados entre execuções em OpenStep

2008-12-05T15:18:00.002-03:00

OpenStep facilita a persistência de dados entre uma execução e outra do programa através da classe NSUserDefaults.

Para persistir dados para a próxima execução, basta criar um dicionário (NSDictionary) representando um hash dos dados a serem persistidos.

Digamos que o dicionário seja defaults e APP_NAME é uma string (NSString) representando o nome da aplicação:

[[NSUserDefaults standardUserDefaults]
    setPersistentDomain: defaults
    forName: APP_NAME
];

E para recuperar os dados persistidos da última execução:

NSDictionary *defaults = [
    [NSUserDefaults standardUserDefaults]
    persistentDomainForName: APP_NAME
];

Então defaults será um dicionário contendo os dados persistidos!

Simples assim. =)

Referência: GNUstep Base.

[]'s
Cacilhas, La Batalema

Base64

2008-11-20T09:38:00.011-03:00

De vez enquando, não tem como não, nós programadores sempre esbarramos na Base64.

Base64 é um protocolo de codificação que usa apenas seis bits, o que significa um conjunto de sessenta e quatro (64) elementos – daí Base64.

A conversão de oito (byte) para seis bits é feita da seguinte forma:
xxxxxx.xx xxxx.xxxx xx.xxxxxx

Ou ainda:
aaaaaabb bbbbcccc ccdddddd

Os elementos usados são caracteres simples, começando com as letras maiúsculas, A (0) a Z (25), então as letras minúsculas, a (26) a z (51), os números, 0 (52) a 9 (61), e os caracteres + (62) e / (63).

Na conversão de bytes (8b) para Base64 (6b), cada três bytes é convertido em quatro dígitos, então um código Base64 é sempre pensado em grupos de quatro. Se o tamanho de um código Base64 não for múltiplo de quatro, caracteres = são acrescentados ao final até que o tamanho seja múltiplo de quatro.

Python

Em Python, Base64 é tão simples que nem tem graça:

>>> print "Kodumaro".encode("base64")
S29kdW1hcm8=
>>> print "S29kdW1hcm8=".decode("base64")
Kodumaro

Lua

Em Lua, é preciso baixar o módulo Mime do LuaSocket:

> require "mime"
> print(mime.b64 "Kodumaro")
S29kdW1hcm8=
> print(mime.unb64 "S29kdW1hcm8=")
Kodumaro

Smalltalk

Sendo muito sincero sobre o assunto, não sei como fazer conversão de Base64 em Smalltalk. =(

Mas sei que os módulos do Seaside providenciam isso!

Se alguém souber, por favor informe!

[update 2009-11-27]
Sugestão do Hugo:

No Squeak tem isso aqui:
(Base64MimeConverter mimeEncode: 'base64' readStream) contents
(Base64MimeConverter mimeDecode: 'S29kdW1hcm8' as: ByteString) contents
E no Pharo tem métodos para strings:
'base64' base64Encoded
'S29kdW1hcm8' base64Decoded
A implementação usa as coisas do Squeak:
String>>base64Decoded
↑ (Base64MimeConverter mimeDecode: self as: self class)

String>>base64Encoded
↑ (Base64MimeConverter mimeEncode: self readStream) contents
Para outros Smalltalks eu não sei…

Legal né? =)

Muito legal sim, Hugo, valeu!
[/update]

C

Aha! Aqui começa de verdade a brincadeira!

É claro que você pode usar as funcionalidades de Base64 da gLibC, mas descobri que nem todas as versões dela apresentam tais funcionalidades:

#include <glib/gbase64.h>

Vamos precisar usar os cabeçalhos stdlib.h, string.h e sys/types.h. Como também vamos criar um cabeçalho para «compartilhar» algumas funções, ele também será incluído no início de nosso arquivo base64.c:

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include "base64.h"

Agora vamos criar um array com todos os possíveis caracteres Base64 em sua ordem natural:

static const char b64all[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef"
    "ghijklmnopqrstuvwxyz0123456789+/";

Também vamos precisar de três funções locais: uma para obter o índice de um elemento (_getindex), outra para codificar para Base64 um grupo de três bytes (_encode) e mais uma para decodificar um grupo de quatro elementos Base64 (_decode):

int _decode(u_int8_t *, const u_int8_t *);
void _encode(u_int8_t *, const u_int8_t *, int);

Não é preciso uma função para _getindex:

#define _getindex(c) (int) (index(b64all, c) - b64all)

Repara que, em vez de char, estamos usando u_int8_t, que é mais conveniente quando queremos lidar com bytes enquanto bytes, não caracteres.

A partir daqui, se preferir, organize as funções em ordem alfabética – ou na ordem que quiser.

A primeira função que implementaremos será para codificar uma string C (const char *) para Base64. Como a string pode não ser bem formada, a função deverá receber também seu tamanho:

const char *b64encode(const char *original, int length) {
    // Se o tamanho não for informado, consideramos uma string bem
    // formada
    if (length == 0)
        length = strlen(original);

    // Inteiro com o tamanho do código a ser gerado
    int b64length = ((length + 2) / 3) * 4 + 1;

    // Contadores para percorrer as strings
    int i=0, j=0;

    // Alocando memória para o código
    char *b64 = (char *) malloc(sizeof(char) * b64length);
    memset(b64, 0, b64length);

    while (i < length) {
        // Codifica um grupo de três bytes...
        _encode(
            (u_int8_t *) b64 + j,
            (const u_int8_t *) original + i,
            (length - i)
        );

        // E segue para o próximo grupo
        i += 3;
        j += 4;
    }

    // Retorna o código
    return (const char *) b64;
}

A próxima função deve fazer o contrário, converter um código Base64 para uma string. Como a string resultante pode não ser bem formada – pode não ser terminada em carácter nulo ou possuir caracteres nulos no meio –, é preciso uma forma de informar seu tamanho, então ela receberá um ponteiro para um inteiro:

const char *b64decode(const char *b64, int *length) {
    // Inteiro com o tamanho do código
    int b64length = strlen(b64);

    // Se não for múltiplo de quatro, há algo errado
    if (b64length % 4 != 0)
        return NULL;

    // Tamanho máximo da string decifrada
    int prob = (b64length / 4) * 3 + 1;

    // Contadores para percorrer as strings
    int i=0, j=0;

    // Alocando memória para o resultado
    char *s = (char *) malloc(sizeof(char) * prob);

    while (j < b64length) {
        // Decifra um grupo de quatro elementos
        // e conta o resultado
        i += _decode(
            (u_int8_t *) s + i,
            (const u_int8_t *) b64 + j
        );

        // Segue para o próximo grupo
        j += 4;
    }

    // Se foi fornecido um inteiro para contagem, informa o tamanho
    if (length != NULL)
        *length = i;

    // Retorna a string decifrada
    return (const char *) s;
}

Agora precisamos das funções específica para as conversões.

Primeiro para codificar:

void _encode(u_int8_t *dest, const u_int8_t *src, int len) {
    // Menor que 1, nada a fazer
    if (len < 1)
        return;

    // Dados a serem retornados
    int aux[] = { 0, 0, 0, 0 };

    // Primeiro elemento: os 6 bits mais significativos do primeiro
    // byte
    aux[0] = src[0] >> 2;

    // Segundo elemento: os 2 bits menos significativos do primeiro e
    // os quatro bits mais significativos do segundo byte
    aux[1] = (src[0] & 0x03) << 4;

    if (len > 1) {
        // SE houver um segundo...
        aux [1] |= (src[1] & 0xf0) >> 4;

        // Terceiro elemento: os quatro bits menos significativos do
        // segundo e os dois mais significativos do terceiro byte
        aux [2] = (src[1] & 0x0f) << 2;

        if (len > 2) {
            // Se houver um terceiro...
            aux[2] |= src[2] >> 6;

            // Quarto elemento: os seis bits menos significatos do
            // terceiro byte
            aux[3] = src[2] & 0x3f;
        }
    }

    // Codifica agora os valores numéricos para string
    dest[0] = b64all[aux[0]];
    dest[1] = b64all[aux[1]];
    dest[2] = '=';
    dest[3] = '=';
    if (len > 1) {
        dest[2] = b64all[aux[2]];
        if (len > 2)
            dest[3] = b64all[aux[3]];
    }
}

int _decode(u_int8_t *dest, const u_int8_t *src) {
    // Representação numérica do código
    int aux[] = { 0, 0, 0, 0 };

    // Contador
    int i, c = 1;

    // Converte código para valores numéricos
    for (i = 0; i < 4; ++i)
        aux[i] = _getindex(src[i]);

    // Primeiro byte: primeiro elemento seguido dos quatro bits mais
    // significativos do segundo
    dest[0] = (u_int8_t) (aux[0] << 2) | ((aux[1] & 0x30) >> 4);

    // Zera os bytes seguintes
    dest[1] = '\0';
    dest[2] = '\0';

    if (aux[2] != -1) {
        // Se houver um terceiro elemento...
        ++c;

        // Segundo byte: quatro bits menos significativos do segundo
        // elemento seguidos pelos quatro bits mais significativos do
        // terceiro
        dest[1] = (u_int8_t) ((aux[1] & 0x0f) << 4) | (aux[2] >> 2);

        if (aux[3] != -1) {
            // Se houver um quarto elemento...
            ++c;

            // Terceiro byte: dois bits menos significativos do
            // terceiro elemento seguidos pelo quarto elemento
            dest[2] = (u_int8_t)
              ((aux[2] & 0x03) << 6) |
              aux[3];
        }
    }

    // Retorna o tamanho da string
    return c;
}

Cabeçalho

Por último criamos o cabeçalho base64.h, tornando públicas as duas funções de codificação e decodificação:

#ifndef _BASE64_H
#define _BASE64_H

const char *b64decode(const char *, int *);
const char *b64encode(const char *, int);

#endif

Conclusão

Mesmo que ninguém vá implementar uma biblioteca de conversão Base64, espero que este artigo sirva para ajudar a entender melhor do que se trata Base64.

[update]
Se quiser acrescentar algum açucar sintático, coloque em base64.c:

#ifdef C_PLUS_PLUS
const char *b64decode(const char *b64, int &length) {
    return b64decode(b64, &length);
}
#endif

E mude o conteúdo de base64.h para:

#ifndef _BASE64_H
#define _BASE64_H

#ifdef C_PLUS_PLUS
extern "C" {
#endif

const char *b64decode(const char *, int *);
const char *b64encode(const char *, int);

#ifdef C_PLUS_PLUS
}
const char *b64decode(const char *, int &);
#else
#define _b64decode(s, len) b64decode(s, &len)
#endif

#endif

[/update]

[]'s
Cacilhas, La Batalema

Objective C

2008-11-13T21:52:00.011-03:00

Escrevi recentemente um artigo com um exemplo bem simples de desenvolvimento de uma aplicação para ambiente GNUstep, mas cometi a gafe de não dedicar algum tempo falando da linguagem de programação em questão, Objective C.

Objective C, ou Objective-C, ou ObjC, é uma linguagem de programação reflectiva orientada a objetos criada nos idos da década de 1980 – mais ou menos na mesma época que o C++ – pelos fundadores da Stepstone, mais tarde adquirida pela NeXT. É na verdade uma camada bem fina sobre a linguagem C padrão.

Isso significa que, se você sabe programar em C, conseguirá programar em ObjC sem muito esforço.

Diferenças para C

Sobre a linguagem C, ObjC adiciona os seguintes recursos:

Orientação a objetos, adaptada de Smalltalk.
Tipo boleano – BOOL. Verdadeiro é YES e falso é NO.
Comentário de linha, iniciado por // (na época C não suportava).
A diretiva de preprocessador #import, que funciona como #include, mas só inclui o cabeçalho se ele não foi incluído ainda.
O tipo id, similar a void * de C/C++.
A constante nil, que é um objeto id sem valor: (id)0.

A maior parte dos comandos referentes a orientação a objetos começam com @, como @interface, @implementation, @end, @private, @protected, @public, @protocol, etc.… Entre colchetes é avaliado o ambiente de mensagem, com uma sintaxe muito parecida com a de Smalltalk.

Criando uma classe

Como exemplo, vamos criar a classe Point, com os atributos x e y.

Para tanto, primeiro criamos a interface no arquivo Point.h:

#ifndef _POINT_H
#define _POINT_H

#import <Foundation/Foundation.h>

@interface Point : NSObject
{
    int x;
    int y;
}

+ (id) newWithX: (int)valuex Y: (int)valuey;
- (id) initWithX: (int)valuex Y: (int)valuey;
- (int) diagonal;
- (int) getX;
- (int) getY;
- (void) setX: (int)value;
- (void) setY: (int)value;

@end

#endif

As diretivas #ifndef, #define e #endif já são velhas conhecidas dos programadores C/C++. O #import já foi explicado, funciona parecido com #include.

O cabeçalho Foundation/Foundation.h inclui a classe NSObject, definida pela API OpenStep, usada aqui como classe pai de nossa classe Point.

O comando @interface inicia a descrição da interface e o comando @end encerra. O pequeno escopo entre chaves define os atributos de instância, protegidos por padrão – para defini-los como públicos a sintaxe seria:

{
    @public
        int x;
        int y;
}

As linhas começadas por um sinal de menos (-) indicam métodos de instância – métodos de classe são iniciados por +. Por exemplo:

- (id) initWithX: (int)valuex Y: (int)valuey;

Significa um método de instância que recebe dois atributos inteiros – valuex e valuey, e retorna um id.

Agora precisamos implementar a interface. Para isso vamos criar o arquivo Point.m:

#include <math.h>
#import "Point.h"

@implementation Point

+ (id) newWithX: (int)valuex Y: (int)valuey {
    return [[Point alloc]
        initWithX: valuex Y: valuey];
}

- (id) initWithX: (int)valuex Y: (int)valuey {
    if ((self = [super init])) {
        x = valuex;
        y = valuey;
    }
    return self;
}

- (int) diagonal {
    return (int) sqrt((double) ((x * x) + (y * y)));
}

- (int) getX {
    return x;
}

- (int) getY {
    return y;
}

- (void) setX: (int)value {
    x = value;
}

- (void) setY: (int)value {
    y = value;
}

@end

O código é muito parecido com C, e até mesmo com C++, cabendo apenas alguns comentários:

self é uma palavra reservada que representa a instância, como this de Java e C++.
super referencia a classe pai, como em Java.
Repare no comando [super init]: aqui é passada uma mensagem para super e o valor retornado é atribuído a self.

Para instanciar um objeto, a sintaxe é:

id point = [Point newWithX: 4 Y: 5];

Ou, com tipagem estática:

Point *point = [Point newWithX: 4 Y: 5];

Para obter o valor de x:

printf("x = %d\n", [point getX]);

E para mudar seu valor:

[point setX: 2];

OpenStep

OpenStep é a API aberta para desenvolvimento de aplicações para NEXTSTEP, resultado de um trabalho colaborativo da NeXT com a SUN Microsystems.

Diversos sistemas e ambientes oferecem suporte a OpenStep, como OS X e GNUstep.

Diversos recursos interessantes são oferecidos nessa API, desde vantagens semelhantes à STL de C++, até conjunto de widgets para construção de janelas, toolkit.

Já vimos uma classe dessa API, NSObject. Outra interessante é NSString, cuja finalidade é a mesma de std::string de C++ e String de Java.

A criação de uma NSString é:

id url = [NSString stringWithCString: "http://kodumaro.blogspot.com/"];

Há ainda um apelido sintático:

id url = @"http://kodumaro.blogspot.com/";

Um forma legal de conhecer mais sobre OpenStep é ler os manuais de referência do GNUstep (toolkit aqui) e do OS X.

[]'s
Cacilhas, La Batalema

Desenvolvendo aplicações GNUstep

2008-11-07T23:29:00.019-03:00

Sempre fui fascinado pelo NeXTSTEP e gostaria muito tivesse dado certo. Por mais que a Apple negue, seu Mac OS X não é muito mais do que uma versão nova de um NeXTSTEP portado para equipamentos MacIntosh.

Mas não só o OS X herdou os recursos do NeXTSTEP. No começo da década de 1990, em colaboração com a SUN Microsystems a NeXT lançou o OpenStep, uma especificação aberta que define a API para o NeXTSTEP.

Assim ambientes baseados em NeXTSTEP podem rodar em quaisquer sistemas operacionais e aplicações portáteis podem ser criadas.

A Free Software Foundation lançou um projeto de implementação da API OpenStep para sistemas GNU, o GNUstep.

Mais do que uma API de programação, GNUstep é todo um ambiente, desde a API até aplicações e ambiente operacional.

Inicialmente o ambiente gráfico / geranciador de janelas era o AfterStep. Certo dia, na lista de discussão para definir os rumos da versão 2 do AfterStep, um brasileiro chamado Alfredo Kojima sugeriu a reescrita do código do zero.

Enquanto o grupo continuava debadendo, Kojima decidiu iniciar o desenvolvimento da versão 2 do AfterStep, codinome WindowMaker, por conta própria e depois apresentou-o à comunidade. O Window Maker então substituiu o AfterStep como gerenciador de janelas do projeto GNUstep e o AfterStep continuou seu desenvolvimento a parte.

Diversas versões do Window Maker foram lançadas, apesar de nunca ter chegado a uma versão 1.0, um eterno beta – atualmente se encontra na versão 0.92. Porém seu desenvolvimento esfriou gradativamente.

Ano passado o projeto voltou a esquentar e promessas de novas versões estão no ar, o que me inspirou a escrever este artigo.

Consulte o blog do Bardo.

GNUstep

Mas este artigo não é sobre Window Maker, e sim sobre GNUstep.

Para desenvolver aplicações GNUstep, você precisa baixar seu core antes. Acesse a página de recursos, vá ao tópico GNUstep Core e baixe as versões estáveis de cada pacote. Descompacte, compile e instale na ordem em que os pacotes aparecem na tabela (startup, make, base, gui e backend). O core do GNUstep deverá ser instalado em /usr/GNUstep/.

Você precisa acrescentar /usr/GNUstep/System/Tools a seu path de executáveis, /usr/GNUstep/System/Library/Libraries a sua lista de diretórios de bibliotecas – em ambiente GNU/Linux, acrescente esse path ao arquivo /etc/ld.so.conf e execute ldconfig – e crie uma variável de ambiente GNUSTEP_MAKEFILES com o valor /usr/GNUstep/System/Library/Makefiles e outra GNUSTEP_INSTALLATION_DOMAIN com o valor SYSTEM.

Tendo o GNUstep instalado, podemos partir para as ferramentas de desenvolvimento, Gorm e Project Center. Você também encontrará apontadores para as versões estáveis na mesma máquina de recursos, no tópico GNUstep Development Tools.

Criando um projeto

Vamos criar nosso primeiro projeto GNUstep!

Primeiro abrimos o Project Center com o comando:

bash$ openapp ProjectCenter

Vá em Project → New... (ou pressione M-n), vai abrir uma janela de diálogo pedindo o nome do projeto. Selecione o tipo Application e forneça o nome Temperature e clique Ok.

Por enquanto nossa brincadeira com Project Center acaba por aqui. Pode salvar – Project → Save ou M-s – e sair – Quit ou M-q.

Criando uma aplicação

Agora vamos trabalhar no Gorm, execute:

bash$ openapp Gorm

Um segredinho: nas versões anteriores você mandava abrir o Temperature.gorm a partir do Project Center e ele já abria o Gorm para a aplicação atual. Na versão que experimentei – Gorm 1.2.6 e Project Center 0.5.0 – há um bug. O truque é abrir o Gorm a parte e criar uma nova aplicação.

Se quiser testar se está funcionando – em algumas lugares que testei funcionou – para abrir o Gorm, na janela principal do Project Center clique em Interfaces e duplo clique em Temperature.gorm.

No Gorm, crie uma janela e marque como Visible at launch time.

No Gorm então acesse Document → New Application, depois vá em Document → Save As.... Na janela de diálogo encontre seu projeto Temperature, dentro dele Resources e, dentro desse, salve como Temperature.gorm – confirme o Replace.

Vão abrir três janelas: Main Menu, My Window e Temperature.gorm. Se as janelas Palettes e Inspector não estiverem abertas, encontre-as no menu Tools.

Selecione a janela My Window – ela representa a janela principal da aplicação – e veja em Inspector o campo Title contendo My Window – se não estiver vendo, mude o seletor para Attributes. Mude o título para Temperature Converter – repare que o título da janela My Window também mudou.

Repare que na janela Palettes tem alguns widgets. Para acrescentar um widget à janela é só segurar e arrastar (drag'n'drop). Vamos acrescentar três tipos de widget: Text, System Bold e Button. Adicione componentes até ficar mais ou menos com a cara deste corte:

Para mudar o texto de um widget, use o duplo clique. Você também pode mudar a borda no Inspector. Altere os widgets até ficarem mais ou menos assim:

Agora é hora de criar a classe para gerenciar essa janela! Hora de codar? Ainda não…

Na janela Temperature.gorm, na barra principal clique em Classes e selecione NSObject – futuca um pouco que você acha. No menu Operations selecione SubClass. Na lista da direita vai aparecer NewClass e o Inspector vai selecioná-lo – veja a caixa Class com NewClass. Mude o nome da classe para ConverterManager. Apenas confirme na janela Modifying Class.

Podemos agora criar os atributos (outlets) e métodos da classe (actions).

Vamos criar um atributo para cada caixa de texto que criamos – incluside a de Kelvin.

Na janela Inspector há a aba Outlets (0) com o botão Add. Clique nesse botão e teremos NewOutlet com um duplo clique você será capaz de mudar seu nome para degreeC.

Crie mais dois atributos: degreeF e kelvin.

Para criar o primeiro método acesse a aba Actions (0) e siga o mesmo procedimento anterior. Os métodos serão chamados convertC2F: e convertF2C:.

E a classe já está pronta!

Instanciando a classe

Mantendo a classe ConverterManager, no menu principal do Gorm selecione Classes → Instantiate. Na janela Temperature.gorm aparecerá um objeto ConverterManager: é agora que vem parte da mágica…

Precisamos inicialmente ligar o atributo degreeC dessa instância à primeira caixa de texto da janela (ao lado do rótulo °C).

Segure a tecla Ctrl, clique sobre a instância, segure e arraste, solte sobre a caixa de diálogo – vai aparecer um T na caixa –, então, na janela Inspector selecione degreeC e clique no botão Connect. Vai aparecer um S sobre a instância e, na janela Inspector, em Connections, vai aparecer: degreeC (TextField(0)).

Faça o mesmo para as outras caixas ligando cada caixa a um atributo.

Agora precisamos fazer com que os botões acionem métodos da instância, para isso o procedimento é o inverso: segurando a tecla Ctrl clique sobre o botão Celsius to Fahrenheit, segure, arraste e solte sobre a instância de ConverterManager na janela Temperature.gorm.

Na janela Inspector clique em target → convertC2F: e então clique no botão Connect.

Faça o mesmo para conectar o outro botão ao outro método. Agora todas as ações estão conectadas!

Salvando tudo

Na janela Temperature.gorm, selecione Classes e encontre a classe ConverterManager. Selecione-a, então, no menu principal do Gorm clique em Classes → Create Class Files. Apenas confirme as duas janelas de diálogo. Isso criará os dois arquivos ConverterManager.m e ConverterManager.h dentro de Resources.

Agora clique em Document → Save All e Quit.

De volta ao Project Center

Volte ao Project Center e clique em Project → Open... e abra o arquivo PC.project do projeto Temperature.

Na janela principal do projeto dê um duplo clique em Classes e depois em ConverterManager.m, isso adicionará o código ao projeto do Project Center.

Finalmente o código!

Precisamos finalmente editar o conteúdo dos métodos. Duplo clique sobre ConverterManager.m na janela principal e vai abrir a janela do editor:

/* All Rights reserved */

#include <AppKit/AppKit.h>
#include "ConverterManager.h"

@implementation ConverterManager


- (void) convertC2F: (id)sender
{
  /* insert your code here */
}


- (void) convertF2C: (id)sender
{
  /* insert your code here */
}

@end

O código é Objective C, um variante orientado a objetos de C que lembra um pouco Smalltalk.

O método covertC2F deve obter o valor do atributo degreeC – que está ligado à caixa de diálogo com o valor em graus Celsius –, calcular e ajustar os valores em Fahrenreit e Kelvin:

- (void) convertC2F: (id)sender
{
  float celsius = [degreeC floatValue];
  float fahrenreit = (9.0f * celsius / 5.0f) + 32.0f;

  [degreeF setStringValue: [NSString stringWithFormat: @"%1.2f",
    fahrenreit]];

  [kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
    (celsius + 273.15f)]];
}

O método convertF2C deve fazer o contrário:

- (void) convertF2C: (id)sender
{
  float fahrenreit = [degreeF floatValue];
  float celsius = 5.0f * (fahrenreit - 32.0f) / 9.0f;

  [degreeC setStringValue: [NSString stringWithFormat: @"%1.2f",
    celsius]];

  [kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
    (celsius + 273.15f)]];
}

Salve agora (M-s) e feche o editor. Clique no ícone com a chave de fenda para compilar:

Na janela de build há outro ícone igual, clique nele para compilar. Se tudo correr bem você verá uma bela mensagem:

=== Build succeeded! ===

Se falhar, volte e veja o que está errado.

Clique então no ícone do foguete para rodar:

Na janela Launch clique no mesmo ícone e a janela irá abrir. Faça alguns testes para ver se funciona bem.

Para sair clique com o botão direito e escolha Quit.

Se tudo funcionar bem, seu programa está pronto! Salve tudo em Project → Save.

Instalando a aplicação

Para instalar, abra um terminal:

bash$ cd Temperature/
bash$ make
bash$ sudo make install

Assim sua aplicação estará instalada em /usr/GNUstep/System/Applications/Temperature.app – ou /usr/GNUstep/Local/Applications/Temperature.app, se você se esqueceu de ajustar o conteúdo da variável de ambiente GNUSTEP_INSTALLATION_DOMAIN – e você executá-la com o comando:

bash$ openapp Temperature

Conclusão

Espero que com este artigo algumas pessoas se interessem pelo desenvolvimento de aplicações para ambiente GNUstep, que aliás roda sobre Mac OS X também – em plataforma OS X, o WINGs (toolkit de widgets para Window Maker) e o GNUstep são abstrações do Cocoa, toolkit de widgets do OS X.

A facilidade de desenvolvimento de aplicações gráficas para GNUstep com Project Center e Gorm é incrível, apesar de seu jeitão esquisito e do uso da tremendamente estranha linguagem de programação Objective C.

[]'s
Cacilhas

PS: Eu já estava morrendo de sono quando escrevi este artigo, portanto alguns erros de português podem ocorrer. Por favor me avisem!

Portando GDBM para Lua

2008-10-16T21:21:00.015-03:00

Espero que este artigo seja interessante. =)

Além de ser um linguagem de programação brasileira, desenvolvida na PUC Rio, Lua possui uma poderosa API com C, na minha opinião, sua maior vantagem.

A outra parte importante deste artigo é GDBM, um conjunto de sub-rotinas de banco de dados baseado em hash, uma alternativa livre ao Unix DBM.

A ideia aqui é demonstrar um pouco dos recursos da biblioteca GDBM e como é simples estender a linguagem Lua.

O objeto

Pessoalmente, quando crio extensões para Lua, gosto de criar primeiro uma classe que represente meu objeto principal, ou uma classe para cada tipo de objeto que será usado nos scripts; depois crio um módulo que porta cada recurso para Lua.

Neste caso vamos criar uma classe GdbmObject que faça a interface com a base de dados, GDBM_FILE.

É claro que poderia ter usado direto GDBM_FILE, aliás comecei fazendo assim, mas acabei voltando ao procedimento que me é natural.

Quanto a objetos datum, não vi necessidade de criar uma interface, já que datum não passa de uma representação mais flexível de string.

O cabeçalho, gdbmobj.h, começa então com as instruções de preprocessamento triviais e a inclusão do cabeçalho gdbm.h, essencial para lidar com GDBM:

#ifndef _GDBMOBJ_H_
#define _GDBMOBJ_H_

#include <gdbm.h>

Podemos então criar a classe e começar os métodos públicos pelo construtor e o destruidor.

O Construtor precisa criar o GDBM_FILE. Para tanto, temos a função gdbm_open, que recebe cinco parâmetros:

o nome do arquivo
o tamanho de blocos para leitura e gravação em bytes (mínimo 512)
o modo de leitura e gravação
as permissões do arquivo, para caso ele seja criado
uma função de callback a ser chamada quando ocorrer um erro fatal

Assim, pelo menos alguns desses parâmetros precisam ser argumentos do construtor. Para simplificar, vamos reduzir: caso o callback seja nulo, é usada uma função padrão. Vamos ficar com ela:

class GdbmObject {
    public:
        GdbmObject(
            const char *name,
            int block=512,
            int mode=GDBM_READER,
            int perm=0644
        );
        ~GdbmObject();

Nosso construtor então recebe os elementos essencias para gdbm_open.

Os outros métodos públicos importantes precisam representar as funções de gdbm.h que queremos acessar, em ordem alfabética: gdbm_close, gdbm_delete, gdbm_exists, gdbm_fetch, gdbm_firstkey, gdbm_nextkey, gdbm_reorganize, gdbm_setopt, gdbm_store e gdbm_sync:

        bool gclose(void);
        bool gdelete(const char *);
        bool gexists(const char *);
        double gfetch_number(const char *);
        const char *gfetch_string(const char *);
        const char *gnext(const char *key=NULL);
        bool greorganize(void);
        bool gsetopt(int, int);
        bool gstore(const char *, const char *);
        bool gstore(const char *, double);
        bool gsync(void);

Agora um método para verificar se a base está fechada um método para retornar a última mensagem de erro:

        bool isclosed(void) const;
        const char *last_error(void) const;

Entrando em território privado, precisamos de dois atributos: um flag que indique se a base está fechada e o GDBM_FILE em si:

    private:
        bool closed;
        GDBM_FILE fd;

Então um método privado para converter datum em string e outro para fazer o gdbm_fetch comum a gfetch_number e gfetch_string:

        static const char *get_string(datum);
        datum gfetch(const char *);
};

#endif /* _GDBMOBJ_H_ */

Código dos métodos

A lógica em si vai no arquivo gdbmobj.cc, que deve iniciar incluindo nosso cabeçalho e o cabeçalho cstring, para que possamos usar strlen nas conversões entre strings e datum.

#include <cstring>
#include "gdbmobj.h"

O código do construtor é simples: basta pegar os argumentos e passá-lo como parâmetro para gdbm_close – não esqueça de ajudar closed como false!

GdbmObject::GdbmObject(
    const char *name, int block, int mode, int perm
): closed(false)
{
    this->fd = gdbm_open(
        const_cast<char *>(name),
        block, mode, perm, NULL
    );
}

O destruidor deve apenas fechar a base, caso esqueçam de fazê-lo:

GdbmObject::~GdbmObject() {
    this>gclose();
}

Precisamos fazer o gclose. Ele deve:

verificar se a base já não está fechada
fechar a base
verificar se não houve erro
marcar o objeto como fechado

bool GdbmObject::gclose(void) {
    if (this->closed)
        return false;

    gdbm_close(this->fd);

    if (gdbm_errno == GDBM_NO_ERROR) {
        this->closed = true;
        return true;
    } else
        return false;
}

Agora o método gdelete: primeiro verificar se já não está fechado – todos os métodos precisam verificar isso –, em seguida converter a chave string em datum – para isso o cabeçalho cstring – e então fazer o que tem de ser feito:

bool GdbmObject::gdelete(const char *key) {
    if (this->close)
        return false;

    datum dkey;
    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);

    gdbm_delete(this->fd, dkey);

    return gdbm_errno == GDBM_NO_ERROR;
}

O próximo método verifica se uma chave existe e funciona similar ao gdelete, só o retorno é que tem um significado diferente:

bool GdbmObject::gexists(const char *key) {
    if (this->close)
        return false;

    datum dkey;
    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);

    return static_cast<bool>(gdbm_exists(this->fd, dkey));
}

Os métodos gfetch_number e gfetch_string devem retornar um valor para uma chave, um retornando double e outro string (const char *), ambos usando o método privado gfetch para obter a chave em formato datum antes:

double GdbmObject::gfetch_number(const char *key) {
    datum data = this->gfetch(key);
    double resp = -1.;

    if (data.dsize == sizeof(double)) {
        double *aux = reinterpret_cast<double *>(data.ptr);
        resp = *aux;
    }

    delete[] data.dptr;
    return resp;
}

const char *GdbmObject::gfetch_string(const char *key) {
    if (this->closed)
        return NULL;

    datum data = this->gfetch(key);
    const char *aux = get_string(data);

    delete[] data.dptr;
    return aux;
}

O método gnext é mais complexo, pois faz interface com gdbm_firstkey (quando a chave for nula) e com gdbm_nextkey.

const char *GdbmObject::gnext(const char *key) {
    if (this->closed)
        return NULL;

    datum next;
    next.dptr = NULL;
    next.dsize = 0;

    if (key == NULL)
        next = gdbm_firstkey(this->fd);

    else {
        datum current;
        current.dptr = const_cast<char *>(key);
        current.dsize = strlen(key);
        next = gdbm_nextkey(this->fd, current);
    }

    if (next.dptr != NULL) {
        const char *aux = get_string(next);

        delete[] next.dptr;
        return aux;
    } else
        return NULL;
}

O método greorganize é similar a gclose:

bool GdbmObject::greorganize(void) {
    if (this->closed)
        return false;

    gdbm_reorganize(this->fd);
    return gdbm_errno == GDBM_NO_ERROR;
}

O método gsetopt precisa tornar transparente algumas peculiaridades de gdbm_setopt:

bool GdbmObject::gsetopt(int option, int value) {
    if (this->closed)
        return false;

    gdbm_setopt(this->fd, option, &value, sizeof(int));
    return gdbm_errno == GDBM_NO_ERROR;
}

Temos dois métodos gstore: um para armazenar números, outro para strings, mas a lógica é a mesma: converter tudo pra datum e usar gdbm_store para armazenar. Vamos usar apenas o flag GDBM_REPLACE:

bool GdbmObject::gstore(const char *key, double value) {
    if (this->closed)
        return false;

    datum dkey, data;

    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);
    data.dptr = reinterpret_cast<char *>(&value);
    data.dsize = sizeof(double);

    gdbm_store(this->fd, dkey, data, GDBM_REPLACE);
    return gdbm_errno == GDBM_NO_ERROR;
}

bool GdbmObject::gstore(const char *key, const char *value) {
    if (this->closed)
        return false;

    datum dkey, data;

    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);
    data.dptr = const_cast<char *>(&value);
    data.dsize = sizeof(double);

    gdbm_store(this->fd, dkey, data, GDBM_REPLACE);
    return gdbm_errno == GDBM_NO_ERROR;
}

O método gsync é quase idêntico a greorganize:

bool GdbmObject::gsync(void) {
    if (this->closed)
        return false;

    gdbm_sync(this->fd);
    return gdbm_errno == GDBM_NO_ERROR;
}

Agora os métodos constantes, isclosed (está fechado) e last_error (último erro):

bool GdbmObject::isclosed(void) const {
    return this->closed;
}

const char *GdbmObject::last_error(void) const {
    if (this->closed)
        return "database closed";

    else
        return const_cast<const char *>(gdbm_strerror(gdbm_errno));
}

O método gfetch faz a verdadeira interface com gdbm_fetch para gfetch_number e gfetch_string:

datum GdbmObject::gfetch(const char *key) {
    datum data;
    data.dptr = NULL;
    data.dsize = 0;

    if (!this->closed) {
        datum dkey;
        dkey.dptr = const_cast<char *>(key);
        dkey.dsize = strlen(key);

        data = gdbm_fetch(this->fd, dkey);
    }

    return data;
}

O método estático get_string precisa converter datum em string:

const char *GdbmObject::get_string(datum data) {
    if (data.dptr == NULL)
        return NULL;

    char *aux = new char[data.dsize + 1];

    for (int i=0; i<data.dsize; ++i)
        aux[i] = data.dptr[i];
    aux[data.dsize] = '\0';

    return const_cast<const char *>(aux);
}

Aqui cabe um comentário para justificar o uso de for em lugar de strcpy:

O ponteiro de datum não é uma string, é um ponteiro para um grupo de bytes – mais ou menos similiar a uma string de Pascal, que tem a vantagem de suportar carácter nulo como parte. Portanto pode não ter um carácter nulo ou ter caracteres nulos dentro do grupo de bytes.

Então a função strcpy não é aplicável.

Que entre a Lua!

Vamos introduzir então a API com Lua, no arquivo luagdbm.cc.

O código precisa começar incluindo o cabeçalho de nossa classe e o cabeçalho de Lua para C++:

#include <lua.hpp>
#include "gdbmobj.h"

Algumas configurações importantes são dados de versão e nome do módulo:

#define VERSION "1.0"
#define MODULE "gdbm"
const char *modulename = MODULE;

Quando Lua carrega uma extensão, chama a função luaopen_nome_da_função, no caso luaopen_gdbm, que deve receber um ponteiro para um estado Lua e deve responder com um inteiro representando a quantidade de elementos empilhados para o estado Lua ao final.

Outra função interessante é set_info, que serve para separar de luaopen_* os dados de diretos, strings e números.

Também vamos criar uma função para empilhar um objeto GdbmObject para o estado Lua:

extern "C" int luaopen_gdbm(lua_State *);
static void set_info(lua_State *);
static void pushdb(lua_State *, GdbmObject *);

Agora vamos declarar uma função para cada método público de GdbmObject – é nossa interface com Lua:

extern "C" {
    static int luagdbm_close(lua_State *);
    static int luagdbm_delete(lua_State *);
    static int luagdbm_exists(lua_State *);
    static int luagdbm_fetch_number(lua_State *);
    static int luagdbm_fetch_string(lua_State *);
    static int luagdbm_isclosed(lua_State *);
    static int luagdbm_next(lua_State *);
    static int luagdbm_open(lua_State *);
    static int luagdbm_reorganize(lua_State *);
    static int luagdbm_setopt(lua_State *);
    static int luagdbm_store(lua_State *);
    static int luagdbm_sync(lua_State *);
}

Podemos implementar cada uma dessas funções.

Função de carregamento

Como já foi dito, a função de carrgamento é luaopen_gdbm.

Ela deve criar um vetor de luaL_reg relacionando cada função com as chaves no módulo em lua, terminando com nulo:

int luaopen_gdbm(lua_State *L) {
    static const luaL_reg gdbm_funcs[] = {
        {"close", luagdbm_close },
        {"delete", luagdbm_delete },
        {"exists", luagdbm_exists },
        {"fetch_number", luagdbm_fetch_number },
        {"fetch_string", luagdbm_fetch_string },
        {"isclosed", luagdbm_isclosed },
        {"next", luagdbm_next },
        {"open", luagdbm_open },
        {"reorganize", luagdbm_reorganize },
        {"setopt", luagdbm_setopt },
        {"store", luagdbm_store },
        {"sync", luagdbm_sync },
        { NULL, NULL }
    };

Então o módulo deve ser registrado com as funções. Para poder usar o módulo como metatabela para os objetos GdbmObject, vamos também criar também a chave __index apontando para o próprio módulo:

    luaLregister(L, modulename, gdbm_funcs);
    lua_pushliteral(L, "__index");
    lua_getglobal(L, modulename);
    lua_settable(L, -3);

Agora só falta chamar set_info e informar que uma estrutura – o módulo – foi empilhada:

    set_info(L);
    return 1;
}

Função para empilhar um objeto de banco de dados

É a função pushdb, que recebe a pilha e um ponteiro para o objeto a ser empilhado.

A função também deve associar ao objeto o próprio módulo como metatabela:

void pushdb(lua_State *L, GdbmObject *db) {
    lua_pushlightuserdata(L, db);
    lua_getglobal(L, modulename);
    lua_setmetatable(L, -2);
}

Vamos deixar set_info para o final…

Funções de interface com os métodos público

Praticamente todas funções devem:

carregar o ponteiro para objeto GdbmObject do estado
verificar se ele ele não está nulo
fazer o que tem de ser feito
retornar o que foi solicitado ou uma mensagem de erro

Repare que todas as funções retornam a quantidade de elementos empilhados (lua_push*).

Assim como começamos pelo método gclose, vamos começar pela função luagdbm_close:

int luagdbm_close(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    if (db->gclose()) {
        delete db;
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A função luagdbm_delete ainda precisa recuperar a chave a ser deletada:

int luagdbm_delete(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);

    if (db->gdelete(key)) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A função luagdbm_exists é similar à anterior, só que mais simples:

int luagdbm_exists(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);

    lua_pushboolean(L, static_cast<int>(db->gexists(key)));
    return 1;
}

As funções luagdbm_fetch_number e luagdbm_fetch_string são similares, só que, assim como os métodos gfetch_number e gfetch_string, retornam número e string:

int luagdbm_fetch_number(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);
    double value = db->getch_number(key);

    lua_pushnumber(L, value);

    if (value == -1.) {
        lua_pushstring(L, db->last_error());
        return 2;

    } else
        return 1;
}

int luagdbm_fetch_string(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);
    const char *value = db->getch_string(key);

    if (value == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;

    } else {
        lua_pushstring(L, value);
        return 1;
    }
}

A função luagdbm_isclose é extremamente simples:

int luagdbm_isclosed(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    lua_pushboolean(L, static_cast<int>(db->isclosed()));
    return 1;
}

A função luagdbm_next também não é complicada, apenas é preciso verificar se o parâmetro chave foi fornecido:

int luagdbm_next(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = NULL;
    if (lua_type(L, 2) == LUA_TSTRING)
        key = lua_tostring(L, 2);

    const char *value = db->gnext(key);

    if (value == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;

    } else {
        lua_pushstring(L, value);
        return 1;
    }
}

Vamos deixar a função luagdbm_open, devido a sua complexidade, então passamos direto para luagdbm_reorganize:

int luagdbm_reorganize(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    if (db->greorganize()) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A função luagdbm_setopt precisa obter dois inteiros, representando a opção e o valor a ser ajustado:

int luagdbm_setopt(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    int option = static_cast<int>(lua_tonumber(L, 2));
    int value = static_cast<int>(lua_tonumber(L, 3));

    if (db->gsetopt(option, value)) {
        lua_pushboolean(L, 1);
        return 1;
    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

Outra função um pouco mais complicada é luagdbm_store, que deve armazenar um par chave-valor.

A complexidade não está no armazenamento em si, mas na tomada de decisão do tipo da chave, número ou string.

Começamos como as outras funções:

int luagdbm_store(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);
    bool resp = false;

Então precisamos decidir se o próximo parâmetro é número ou string e usar uma variável do tipo conveniente:

    switch (lua_type(L, 3)) {
        case LUA_TSTRING: {
            const char *aux = lua_tostring(L, 3);
            resp = db->gstore(key, aux);
            break;
        }

        case LUA_TNUMBER: {
            double aux = lua_tonumber(L, 3);
            resp = db->gstore(key, aux);
            break;
        }

        default:
            lua_pushnil(L);
            lua_pushstring(L, "not compatible data");
            return 2;
    }

Podemos então retornar convenientemente:

    if (resp) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A última função é luagdbm_sync, que não tem segredos:

int luagdbm_sync(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    if (db->gsync()) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

Abertura de uma base de dados

Finalmente chegamos à função luagdbm_open!

Ela é bem complexa, pois pode receber parâmetros diferentes.

Se o parâmetro for string, será considerada como o nome do arquivo de base de dados e para todas as demais configurações são usados os valores por defeito.

Se for uma tabela:

o valor para a chave name representará o nome do arquivo;
o valor para a chave block representará o tamanho do bloco;
o valor para a chave mode representará o modo de leitura e/ou gravação;
o valor para a chave permission representará as permissões para a criação do arquivo.

No entanto, mais de um parâmetros podem ser passados para o modo, como por exemplo GDBM_WRCREAT e GDBM_SYNC. Para esses casos, o valor para a chave mode deve ser uma tabela indexada contendo os modos desejados – e a função precisa estar preparada para processar isso!

A primeira parte da função é carregar os valores por defeito:

int luagdbm_open(lua_State *L) {
    const char *name = NULL;
    int block = 512;
    int mode = GDBM_READER;
    int perm = 0644;

Então precisamos verificar se o parâmetro é string (nome do arquivo, tudo mais ajustado por defeito) ou tabela:

    switch(lua_type(L, 1)) {
        case LUA_TSTRING:
            name = lua_tostring(L, 1);
            break;

        case LUA_TTABLE: {
            lua_getfield(L, 1, "name");

            if (lua_type(L, -1) == LUA_TSTRING) {
                name = lua_tostring(L, -1);

Agora precisamos pegar o valor de block:

                lua_getfield(L, 1, "block");
                if (lua_type(L, -1) == LUA_TNUMBER)
                    block = static_cast<int>(lua_tonumber(L, -1));

Ao trazermos o valor de mode para cima, precisamos ainda verificar seu tipo:

                lua_getfield(L, 1, "mode");
                switch (lua_type(L, -1)) {
                    case LUA_TNUMBER:
                        mode = static_cast<int>(lua_tonumber(L, -1));
                        break;

Agora, caso seja uma tabela, é preciso percorrer seus valores enquantos estes forem números:

                    case LUA_TTABLE: {
                        int i = 1;
                        lua_rawgeti(L, -1, i);
                        mode = 0;
                        while (lua_type(L, -1) == LUA_TNUMBER) {
                            mode |= static_cast<int>(
                                lua_tonumber(L, -1)
                            );
                            lua_pop(L, 1);
                            lua_rawgeti(L, -1, ++i);
                        }

                        mode = (mode == 0) ? GDBM_READER : mode;
                        break;
                    }

Repare que lua_rawgeti(L, -1, i) empilha o i-ésimo elemento da tabela no fim da pilha (-1) e lua_pop(L, 1) desempilha para voltarmos à tabela.

Agora, caso não seja nem número, nem tabela, ignora:

                    default:
                        break;
                }

Obter as permissões é tão simples quanto obter o tamanho do bloco. Aproveitamos e já encerramos o switch o parâmetro ignorando outros tipos:

                lua_getfield(L, 1, "permission");
                if (lua_type(L, -1) == LUA_TNUMBER)
                    perm = static_cast<int>(lua_tonumber(L, -1));
            }

            break;
        }

        default:
            break;
    }

Repare bem em uma coisa: lua_to*(L, 1) retorna o primeiro parâmetro passado à função, lua_to*(L, 2) retorna o segundo parâmetro. lua_to*(L, -1) retorna o último elemento empilhado por lua_push*, lua_getglobal, lua_getfield, lua_rawget, lua_rawgeti ou qualquer outra função da API que empilhe elementos.

Agora é preciso verificar se, após todo esse trabalho, o nome do arquivo foi realmente ajustado:

    if (name == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "file not supplied");
        return 2;

Finalmente podemos abrir o arquivo de banco de dados e, se tudo correr bem, retorná-lo para o estado Lua – caso contrário, retornar um erro:

    } else {
        GdbmObject *db = new GdbmObject(name, block, mode, perm);

        if (gdbm_errno == GDBM_NO_ERROR) {
            if (db == NULL) {
                lua_pushnil(L);
                lua_pushstring(L,
                    "no error, but no database returned"
                );
                return 2;

            } else {
                pushdb(L, db);
                return 1;
            }
        } else {
            delete db;
            lua_pushnil(L);
            lua_pushstring(L, gdbm_strerror(gdbm_errno));
            return 2;
        }
    }
}

Informações

A função set_info é na verdade a mais chata: primeiro ajusta dados padrão sobre o módulo, depois carrega as constantes usadas pelo GDBM com nomes similares.

É bastante extenso e se não quiser, não precisa ler agora. Está aqui apenas para quem quiser programá-lo.

void set_info(lua_State *L) {
    lua_pushliteral(L, "_COPYRIGHT");
    lua_pushliteral(L, "Copyright (C) 2008 Rodrigo Cacilhas");
    lua_settable(L, -3);
    lua_pushliteral(L, "_DESCRIPTION");
    lua_pushliteral(L, "GDBM interface");
    lua_settable(L, -3);
    lua_pushliteral(L, "_NAME");
    lua_pushliteral(L, MODULE);
    lua_settable(L, -3);
    lua_pushliteral(L, "_VERSION");
    lua_pushliteral(L, VERSION);
    lua_settable(L, -3);

    lua_pushliteral(L, "READER");
    lua_pushnumber(L, GDBM_READER);
    lua_settable(L, -3);
    lua_pushliteral(L, "WRITER");
    lua_pushnumber(L, GDBM_WRITER);
    lua_settable(L, -3);
    lua_pushliteral(L, "WRCREAT");
    lua_pushnumber(L, GDBM_WRCREAT);
    lua_settable(L, -3);
    lua_pushliteral(L, "NEWDB");
    lua_pushnumber(L, GDBM_NEWDB);
    lua_settable(L, -3);
    lua_pushliteral(L, "FAST");
    lua_pushnumber(L, GDBM_FAST);
    lua_settable(L, -3);
    lua_pushliteral(L, "SYNC");
    lua_pushnumber(L, GDBM_SYNC);
    lua_settable(L, -3);
    lua_pushliteral(L, "NOLOCK");
    lua_pushnumber(L, GDBM_NOLOCK);
    lua_settable(L, -3);

    lua_pushliteral(L, "INSERT");
    lua_pushnumber(L, GDBM_INSERT);
    lua_settable(L, -3);
    lua_pushliteral(L, "REPLACE");
    lua_pushnumber(L, GDBM_REPLACE);
    lua_settable(L, -3);


    lua_pushliteral(L, "CACHESIZE");
    lua_pushnumber(L, GDBM_CACHESIZE);
    lua_settable(L, -3);
    lua_pushliteral(L, "FASTMODE");
    lua_pushnumber(L, GDBM_FASTMODE);
    lua_settable(L, -3);
    lua_pushliteral(L, "SYNCMODE");
    lua_pushnumber(L, GDBM_SYNCMODE);
    lua_settable(L, -3);
    lua_pushliteral(L, "CENTFREE");
    lua_pushnumber(L, GDBM_CENTFREE);
    lua_settable(L, -3);
    lua_pushliteral(L, "COALESCEBLKS");
    lua_pushnumber(L, GDBM_COALESCEBLKS);
    lua_settable(L, -3);


    lua_pushliteral(L, "NO_ERROR");
    lua_pushnumber(L, GDBM_NO_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "MALLOC_ERROR");
    lua_pushnumber(L, GDBM_MALLOC_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "BLOCK_SIZE_ERROR");
    lua_pushnumber(L, GDBM_BLOCK_SIZE_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_OPEN_ERROR");
    lua_pushnumber(L, GDBM_FILE_OPEN_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_WRITE_ERROR");
    lua_pushnumber(L, GDBM_FILE_WRITE_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_SEEK_ERROR");
    lua_pushnumber(L, GDBM_FILE_SEEK_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_READ_ERROR");
    lua_pushnumber(L, GDBM_FILE_READ_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "BAD_MAGIC_NUMBER");
    lua_pushnumber(L, GDBM_BAD_MAGIC_NUMBER);
    lua_settable(L, -3);
    lua_pushliteral(L, "EMPTY_DATABASE");
    lua_pushnumber(L, GDBM_EMPTY_DATABASE);
    lua_settable(L, -3);
    lua_pushliteral(L, "CANT_BE_READER");
    lua_pushnumber(L, GDBM_CANT_BE_READER);
    lua_settable(L, -3);
    lua_pushliteral(L, "CANT_BE_WRITER");
    lua_pushnumber(L, GDBM_CANT_BE_WRITER);
    lua_settable(L, -3);
    lua_pushliteral(L, "READER_CANT_DELETE");
    lua_pushnumber(L, GDBM_READER_CANT_DELETE);
    lua_settable(L, -3);
    lua_pushliteral(L, "READER_CANT_STORE");
    lua_pushnumber(L, GDBM_READER_CANT_STORE);
    lua_settable(L, -3);
    lua_pushliteral(L, "READER_CANT_REORGANIZE");
    lua_pushnumber(L, GDBM_READER_CANT_REORGANIZE);
    lua_settable(L, -3);
    lua_pushliteral(L, "UNKNOWN_UPDATE");
    lua_pushnumber(L, GDBM_UNKNOWN_UPDATE);
    lua_settable(L, -3);
    lua_pushliteral(L, "ITEM_NOT_FOUND");
    lua_pushnumber(L, GDBM_ITEM_NOT_FOUND);
    lua_settable(L, -3);
    lua_pushliteral(L, "REORGANIZE_FAILED");
    lua_pushnumber(L, GDBM_REORGANIZE_FAILED);
    lua_settable(L, -3);
    lua_pushliteral(L, "CANNOT_REPLACE");
    lua_pushnumber(L, GDBM_CANNOT_REPLACE);
    lua_settable(L, -3);
    lua_pushliteral(L, "ILLEGAL_DATA");
    lua_pushnumber(L, GDBM_ILLEGAL_DATA);
    lua_settable(L, -3);
    lua_pushliteral(L, "OPT_ALREADY_SET");
    lua_pushnumber(L, GDBM_OPT_ALREADY_SET);
    lua_settable(L, -3);
    lua_pushliteral(L, "OPT_ILLEGAL");
    lua_pushnumber(L, GDBM_OPT_ILLEGAL);
    lua_settable(L, -3);
}

Compilando

Uma forma legal de compilar é através de um arquivo Makefile.

Esse arquivo começa com um comentário informando data e seu criador, e logo em seguida os recursos usados: compilador (CC), link-editor (LD), flags de compilação (CFLAGS) e bibliotecas envolvidas (LIBS), no caso:

# $Id: luagdbm,v 1.0 2008/10/16 23:25:31 cacilhas Exp $

CC ?= c++
LD ?= c++
RM ?= rm -f

CFLAGS ?= 
LIBS ?= -lm -llua -lgdbm -lstdc++

# **********************************************************************

Então os procedimentos de compilação.

O procedimento para compilar os arquivos fontes (*.cc) em objetos (*.o) é:

.cc.o:
    $(CC) -c $< $(CFLAGS) -o $@

Finalmente fazemos a link-edição de tudo na biblioteca compartilhada gdbm.so:

gdbm.so: gdbmobj.o luagdbm.o
    $(LD) -shared $? ($LIBS) -o $@

Agora precisamos informar ao make o que fazer por defeito:

all: gdbm.so

E como limpar a bagunça:

clean:
    $(RM) luagdbm.o
    $(RM) gdbmobj.o

Feito isso já podemos compilar:

bash$ make

Se tudo correu bem, a biblioteca gdbm.so terá sido gerada, se não, verifique os erros e volte corrigindo-os. Caso encontre algum erro neste artigo, por favor informe para que eu possa corrigi-lo!

Fazendo funcionar

Agora mova a biblioteca para um diretório onde Lua possa encontrá-la. Aqui para mim é /usr/lib/lua/5.1/, mas aí para você pode ser qualquer coisa. O conteúdo da variável de ambiente LUA_CPATH pode dar uma dica.

Na ausência dessa variável, entrando no interpretador Lua, a chave package.cpath informa o local correto.

Feito isso, podemos iniciar um interpretador Lua e fazer testes:

bash$ lua
Lua 5.1.3  Copyright (C) 1994-2008 Lua.org, PUC-Rio
> require "gdbm"
> db = assert(gdbm.open { name = "dbtest.db", mode = gdbm.WRCREAT })
> db:store("first", "a")
> db:store("second", "b")
> db:store("thirt", "c")
> db:close()

Saindo do interpretador, você poderá ver o arquivo dbtest.db criado. Vamos reler seu conteúdo:

> db = assert(gdbm.open "dbtest.db")
> k = db:next()
> while k do print(k, db:fetch_string(k)) k = db:next(k) end
first   a
second  b
thirt   c
> db:close()

A ordem de gdbm_next não é necessariamente a ordem de registro.

Conclusão

Acho que este artigo está cheio de informações e é bastante longo, mas se você conseguiu lê-lo até aqui, significa que consegui fazê-lo útil.

Para saber mais, leia a manpage de gdbm e o PiL.

[]'s
Cacilhas, La Batalema

[update 2008-10-23]Valeu pela divulgação no BR-Linux.org, Augusto![/update]

Tcl/Tk

2008-10-15T21:08:00.002-03:00

Uma linguagem de script muito subestimada é Tcl/Tk.

Tcl significa Tool Command Language e foi criada por John Ousterhout para ser uma extensão de C, uma linguagem de agregação de componentes, mais ou menos como o Shell Script.

Tk é uma extensão gráfica para Tcl escrita em C. É um acrónimo para toolkit, nome comumente usado para frameworks gráficos. Em cada plataforma operacional, Tk oferece uma interface homogénia com o sistema de janelas. Outras linguagens também pode acessar a biblioteca Tk – como por exemplo Tkinter.

Tcl e Tk são de código aberto.

Vamos a alguns exemplos:

bash$ tclsh
% puts stdout {Olá Mundo!}
Olá Mundo!

Uma característica fortíssima de Tcl/Tk é que tudo são strings.

Cada token é uma string e strings não precisam de delimitadores, mas aspas (") e chaves ({ e }) podem ser usados como.

No exemplo acima, puts, stdout e {Olá Mundo!} são strings. A primeira string da linha referencia o comando a ser executado, no caso puts «coloca» uma string em um fluxo (stream).

A segunda string (stdout) indica qual o fluxo de saída, no caso a saída padrão.

A terceira string é aquela que será direcionada para a saída selecionada. No caso exibe Olá Mundo! na saída padrão.

Vamos a um exemplo um pouco mais complicado:

puts -nonewline stdout {Informe um número: }
gets stdin num
set dob [expr [set num] * 2]
puts stdout "O dobro é [set dob]"

Como já vimos, puts exibe uma string em uma saída, no caso novamente na saída padrão (stdout). A string -nonewline é um parâmetro que indica a puts para não inserir mudança de linha ao final.

O comando gets recebe uma string de uma entrada – no caso stdin, entrada padrão: o teclado – e a atribui a uma variável referenciada pela última string, num.

O comando set retorna o conteúdo de uma variável, se receber uma terceira string, atribui esta à variável e retorna.

Os colchetes executam o comando interno e tudo é substituído pela string retornada.

O comando expr trata todas as strings como uma expressão matemática, retornando o resultado.

Assim, [set num] retorna o valor da variável num, o expr pega esse valor de num, tratado como um número, e múltiplica por dois (2), retornando.

Daí os colchetes substituem novamente toda a expressão pelo valor retornado, ou seja, uma string representando o dobro do valor de num, então o set mais externo atribui essa valor à variável dob.

No final o último comando exibe na saída padrão a string, substituindo o que estiver entre colchetes. Como set dob retorna o valor de dob, acho que é óbvio o que é exibido.

Só que Tcl/Tk suporta um «apelido» para set, que é o cifrão ($), como em Shell e Perl (não como em PHP):

puts -nonewline stdout {Informe um número: }
gets stdin num
set dob [expr $num * 2]
puts stdout "O dobro é $dob"

Isso deixa o código bem mais limpo. =)

Outras extensões

Há ainda outras linguagens baseadas em Tcl/Tk que valem a pena serem citadas.

A primeira é [incr Tcl], uma variação orientada a objetos.

Outra é TclX (Tcl estendido), que, além de suportar todas os recursos de Tcl/Tk ainda suporta outros similares ao bash, como echo, loop e & (para execução paralela).

Finalizando

Este artigo é apenas um esboço. Outro mais completo pode ser encontrado nas Reflexões de Monte Gasppa e Giulia C..

[]'s
Cacilhas, La Batalema