Recriando uma Aplicação dos Anos 90 – Um Tutorial Prático com Clipper

Olá, pessoal!
Que tal uma viagem no tempo? Hoje, vamos deixar de lado os frameworks modernos, o JavaScript e a nuvem, e vamos construir, do zero, uma aplicação de verdade, como a gente fazia nos anos 90. Nossa ferramenta será o lendário Clipper, a linguagem que dominou o desenvolvimento de aplicações comerciais para DOS por uma década.
Nossa missão é criar um cadastro de clientes simples, mas 100% funcional. Teremos uma tela para incluir, consultar, alterar e excluir registros. O objetivo é que, ao final, você, desenvolvedor moderno, sinta na pele como era "programar na unha" e tenha um gostinho da elegância e do poder que essas ferramentas nos davam.

Passo 0: O Ambiente – Preparando a Máquina do Tempo

Para começar, você precisará de algumas coisas:

• Um Emulador de DOS:
  Caso o teu windows não tenha o command(cmd.exe), então uma ferramenta para isso é o DOSBox. É um programa gratuito que emula um ambiente DOS completo dentro do seu Windows, Mac ou Linux. Baixe e instale-o.
• O Compilador Clipper:
  O Clipper 5.2 ou 5.3 era o padrão da indústria na época. Hoje, ele é considerado "abandonware" e pode ser encontrado em arquivos de software antigo na internet. Você precisará dos arquivos CLIPPER.EXE (compilador), RTLINK.EXE (linker) e das bibliotecas, como a CLIPPER.LIB.
• Um Editor de Texto:
  Esqueça o VS Code com suas mil extensões. O Bloco de Notas ou qualquer editor de texto simples é tudo que você precisa.

Crie um diretório de trabalho (ex: C:\CLIPPER) e coloque os arquivos do Clipper nele. Dentro do DOSBox, você pode "montar" esse diretório como seu C: com o comando mount c c:\clipper.

Também vai precisar ajustar as variaveis de ambiente com FILES=150 e SET CLIPPER=F150, respectivamente em variáveis de ambiente ou autoexec.bat/.nt e config.sts/.nt

Passo 1: A Planta Baixa – Criando o Banco de Dados .DBF

No mundo xBase, o banco de dados era um simples arquivo no disco, geralmente com a extensão .DBF. Vamos criar um programa para definir a estrutura do nosso CLIENTES.DBF. Crie um arquivo chamado CRIADBF.PRG com o seguinte conteúdo:

Snippet de Código 1:

// Roda apenas uma vez para criar a estrutura do banco de dados

	// Define a estrutura em um array
	aStru := { ;
    { "CCODI", "N", 6, 0 }, ; // Codigo do Cliente, Numerico, 6 digitos, 0 decimais
    { "CNOME", "C", 40, 0 }, ; // Nome, Caractere, 40 posicoes
    { "CFONE", "C", 15, 0 }, ; // Telefone, Caractere, 15 posicoes
    { "CDATA", "D", 8, 0 }    // Data do Cadastro, Data
	}

	// Cria o arquivo .DBF a partir da estrutura
	CREATE CLIENTES.DBF FROM aStru

	// Cria o arquivo de índice .NTX
	USE CLIENTES
	INDEX ON CCODI TO CLIECAD

	? "Arquivos CLIENTES.DBF e CLIECAD.NTX criados com sucesso!"
	CLOSE DATABASES
	RETURN
	

Para executar, no prompt, digite:

• CLIPPER CRIADBF /n /l (para compilar)
• RTLINK CRIADBF (para gerar o executavel).
• CRIADBF (para rodar).
• Importante: caso você consiga o clipper5\bin completo, dentro dele já existe um arquivo .bat chamado cl.bat. Existindo, pode esquecer os comandos anteriores e basta executar CL CRIADBF

Se tudo deu certo, você terá dois novos arquivos no seu diretório: CLIENTES.DBF (os dados) e CLIECAD.NTX (o índice por código).

Passo 2: O Coração do Programa – A Tela de Cadastro (CADCLI.PRG)

Agora, a aplicação principal. Crie o arquivo CADCLI.PRG. Vamos começar com a estrutura básica e a tela:

Snippet de Código 2:

#include "inkey.ch"  // Define constantes de teclas como K_ESC
#include "box.ch"    // Define constantes para desenhar caixas

FUNCTION main()
    // Declara as variáveis que serão usadas na tela
    PRIVATE nCodigo := 0, cNome := SPACE(40), cFone := SPACE(15), dData := DATE()

    // Abre o banco de dados e seu índice
    USE CLIENTES INDEX CLIECAD

    CLEAR SCREEN

    // Loop principal do programa
    DO WHILE .T.
        // Desenha a tela
        @ 5, 10 TO 15, 70 BOX B_SINGLE
        @ 6, 12 SAY "Cadastro de Clientes - CompCet Demonstração"

        // Exibe uma mensagem de ajuda
        @ 17, 10 SAY "Digite o Código (0 para Novo) e pressione Enter, ou ESC para Sair."

        // Define os campos de entrada de dados (os GETs)
        @ 8, 12 SAY "Código..:" GET nCodigo PICTURE "999999" VALID ValCod(@nCodigo)
        @ 10, 12 SAY "Nome....:" GET cNome PICTURE "@!" VALID !EMPTY(cNome) // @! para deixar em maiúsculas
        @ 11, 12 SAY "Telefone:" GET cFone
        @ 12, 12 SAY "Data....:" GET dData

        // Comando mágico que ativa os campos para edição
        READ

        // Verifica a tecla que o usuário pressionou para sair do READ
        IF LASTKEY() == K_ESC
            EXIT // Sai do loop DO WHILE
        ENDIF

        // Se não saiu, chama a função para gravar os dados
        GravaReg(nCodigo, cNome, cFone, dData)

        // Limpa as variáveis para o próximo cadastro
        nCodigo := 0
        cNome   := SPACE(40)
        cFone   := SPACE(15)
        dData   := DATE()

    ENDDO

    CLOSE DATABASES
    CLEAR SCREEN
RETURN

Este é o esqueleto da nossa aplicação. O comando @...SAY...GET é a base de tudo. SAY exibe um texto, GET vincula um campo na tela a uma variável. O comando READ entrega o controle ao usuário, e só devolve o controle para o programa quando ele navegar por todos os campos ou pressionar ESC.

Passo 3: A Lógica – Validando e Gravando

O programa acima chama duas funções que ainda não existem: ValCod() e GravaReg(). Vamos criá-las no mesmo arquivo CADCLI.PRG.

Snippet de Código 3:

// Função de validação, executada sempre que o usuário sai do campo do código
FUNCTION ValCod(nCod)
    IF nCod == 0  // Se digitou 0, é um novo registro
        // Pega o código do último registro e soma 1, garantindo um código único
        GO BOTTOM
        nCodigo := CLIENTES->CCODI + 1
        APPEND BLANK
        cNome   := SPACE(40)
        cFone   := SPACE(15)
        dData   := DATE()
        @ 8, 22 SAY nCodigo PICTURE "999999" // Atualiza o código na tela
    ELSE
        SEEK nCod // Procura o código no índice
        IF FOUND() // Se encontrou...
            // Carrega as variáveis da tela com os dados do arquivo
            nCodigo := CLIENTES->CCODI
            cNome   := CLIENTES->CNOME
            cFone   := CLIENTES->CFONE
            dData   := CLIENTES->CDATA
        ELSE // Se não encontrou...
            ALERT("Código não encontrado!")
            nCodigo := 0 // Limpa a variável para o usuário digitar de novo
        ENDIF
        // Atualiza todos os campos da tela com os valores carregados
        SHOW GETS
    ENDIF
RETURN .T. // Retorna .T. para o GET ser considerado válido

// Função para gravar as alterações no arquivo .DBF
FUNCTION GravaReg(nCod, cNom, cFon, dDat)
    SEEK nCod
    IF FOUND()
        // Se o registro já existe, atualiza os campos
        REPLACE CLIENTES->CNOME WITH cNom, ;
                CLIENTES->CFONE WITH cFon, ;
                CLIENTES->CDATA WITH dDat
        ALERT("Registro alterado/incluído com sucesso!")
    ELSE
        // A inclusão (APPEND BLANK) já foi feita no ValCod,
        // então aqui apenas preenchemos os dados
        REPLACE CLIENTES->CCODI WITH nCod, ;
                CLIENTES->CNOME WITH cNom, ;
                CLIENTES->CFONE WITH cFon, ;
                CLIENTES->CDATA WITH dDat
        ALERT("Registro incluído com sucesso!")
    ENDIF
    // Grava as alterações fisicamente no disco
    COMMIT
RETURN

Passo 4: Compilando e Rodando

Agora, salve o arquivo CADCLI.PRG. No prompt, compile e rode:

• CLIPPER CADCLI /n/l
• RTLINK CADCLI
• CADCLI
• Ou CL CADCLI

Se tudo deu certo, sua aplicação de cadastro estará rodando! Tente digitar 0 no código para incluir um novo cliente. Depois, digite o código de um cliente existente para alterá-lo. Pressione ESC para sair.

Conclusão: A Máquina do Tempo Desliga

Parabéns! Você acaba de criar uma aplicação DOS funcional, usando as mesmas técnicas que usamos para construir sistemas gigantescos nos anos 90.
O que aprendemos? Aprendemos que, naquela época, o programador tinha controle total e uma responsabilidade imensa. Era preciso gerenciar o banco de dados, a interface, o fluxo do programa, tudo de forma explícita. Não havia frameworks para nos ajudar.
Pode parecer "primitivo" para os padrões de hoje, mas havia uma elegância e uma satisfação enormes em construir algo tão "na unha", vendo a tela preta ganhar vida com nossos comandos. Espero que tenham gostado da viagem. Agora, vocês não apenas leram sobre a história, vocês a programaram.