Introdução ao Clipper

Introdução ao Clipper

 Para se programar em Clipper, você precisa de um editor de textos tipo o Edit do MS-DOS para escrever os programas. Os mais conhecidos são o Qedit e o Side-Kick pela sua gama de opções na editoração do texto que facilita a vida do programador.

 Os programas são compostos de arquivo de texto e tem por padrão a extensão de arquivo *.PRG.

 Cada linha do programa não necessita de indicadores de final de linha, como se verifica em algumas linguagens com o (;) "ponto e vírgula" (Pascal, Javascript, C etc.). Pelo contrário, se o último caractere de uma linha no Clipper for um "ponto e vírgula", indica que a linha não terminou e que a linha abaixo é continuação da linha de cima.

 Ex:

IF (!EMPTY(cCDEBITO) .OR. !EMPTY(cCCREDITO)) .OR.;
   cCDEBITO # cCCREDITO
   EXIT
ENDIF

  Seria o mesmo que:

IF (!EMPTY(cCDEBITO) .OR. !EMPTY(cCCREDITO)) .OR. cCDEBITO # cCCREDITO
   EXIT
ENDIF

  Só que, para visualizar melhor, você preferiu "quebrar" a linha para não ter que ficar usando a rolagem para a direita para ver o que tem depois.

  Para compreender melhor o programa, sempre utilize endentação das linhas, que nada mais é do que os espaços regulares que são dados no início de cada uma delas para indicar que as informações fazem parte de uma rotina (conjunto de informações) específica a ser executada. Quer dizer que você irá dar espaços regulares nas linhas que estiverem dentro de um Loop (DO WHILE...ENDDO, FOR...NEXT) ou que satisfaçam uma condição (IF...ENDIF, DO CASE...ENDCASE, DO WHILE <condição>...ENDDO)

Ex.:

IF !EMPTY(cCCREDITO)
   nTCRED -= tvCAMPO // ESTORNA VALOR ANTERIOR
   nTCRED += vCAMPO // LANCA VALOR ATUAL
   IF nACAO = 3
      IF SA->( DBSEEK(TMP->CREDITO + DTOS(TMP->DATA) ))
         SA->( LOCKREG())
         SA->CREDITO -= tvCAMPO
         SA->CREDITO += vCAMPO
         SA->( DBUNLOCK())
         SA->( DBCOMMIT())
      ENDIF
   ENDIF
ENDIF

 Observe como é dado os espaços no início de cada linha. Viu como ficou mais legível a visualização?! Desta forma fica muito mais fácil interpretar e entender o programa do que se estivesse tudo junto à margem esquerda, não acha?! Use também linhas em branco para separar segmentos de código que executam um determinada tarefa e abuse de linhas de comentário para lembrá-lo rapidamente o que faz cada rotina do seu programa.

 Os espaços, linhas em branco e linhas de comentários são simplesmente ignorados pelo compilador do Clipper. Não pense que você irá estar economizando bytes do seu programa (*.EXE) ao ignorar a dica do parágrafo anterior. Você já percebeu que não consegue marcar uma linha de comentário no depurador (Debug)?!

 Procure padronizar a programação em letras maiúsculas. Quando for criar variáveis de memória, use a primeira letra da variável igual a primeira letra do tipo da variável, em minúscula, (n = NUMÉRICO, c = CARACTERE, d = DATA, m = MEMO e l = LÓGICO). Por exemplo: dINICIAL := CTOD(""). Você saberá que dINICIAL é do tipo DATA (DATE), em qualquer lugar do programa, porque começa pela letra d.

 Se você está aprendendo uma linguagem, não pense que você precisa decorar a sintaxe de todos os comandos e funções para conseguir programar alguma coisa, ao invés disso mentalize o que aquilo faz e tente imaginar quando irá precisar usar, execute o NG (Norton Guide) quando for programar e aí é só pressionar Shift + F1 para consultar a sintaxe correta. Nem os veteranos sabem a sintaxe de tudo e mesmo sabendo, normalmente preferem não arriscar e consultar o NG, por isso não tenha vergonha de usá-lo, use-o sempre!

 Um Loop ("laço") é um conjunto de informações que são executadas automaticamente mais de uma vez. Os comandos DO WHILE...ENDDO e FOR...NEXT, por exemplo, podem fazer loop, podem fazer executar as informações que estão contidas dentro deles mais de uma vez.

  Linguagem de Alto Nível é a linguagem que se aproxima da linguagem dos homens. É aquela que é mais inteligível aos "olhos dos homens" do que aos "olhos da máquina". Quanto mais "alto nível", mais fácil é de programar e maior o tamanho do programa, porque haverá uma grande "tradução" para a linguagem que a máquina entende.

  Linguagem de Baixo Nível é a linguagem que se aproxima da linguagem das máquinas. É aquela que é mais inteligível aos "olhos das máquinas" do que aos "olhos do homem". Quanto mais "baixo nível", mais difícil é de programar e menor o tamanho do programa, porque haverá apenas uma pequena "tradução" para a linguagem que a máquina entende.

  Compilar um programa consiste basicamente em transformar o seu *.PRG em *.OBJ (arquivos OBJetos), que contém informações em linguagem de máquina. É nesta fase que aparece todos os erros de sintaxe do programa, ou seja, se você digitou alguma coisa errada que não existe, dará erro neste momento. Poderão ocorrer outros erros, mas isto é uma outra estória...

  Linkeditar ou Linkar (do inglês Link, ligar, conectar, vincular) um programa consiste em vincular o seu programa objeto (OBJ) às bibliotecas intérpretes (clipper.lib, extend.lib etc) da linguagem. Todos os comandos do Clipper são transformados em funções (Veja o arquivo STD.CH no sub-diretório /INCLUDE) e estas funções são escritas em uma linguagem de baixo nível, a maioria em C ou Assembler (ASM). Isto quer dizer que as funções que você usa em Clipper, são funções prontas  em C ou ASM para facilitar a sua vida.

  Importante: Quando alguém manda você compilar o programa, este alguém quer dizer: COMPILE e LINKEDITE o programa! Transforme-o em um arquivo executável (*.EXE).

  Para usar o Clipper é preciso definir algumas variáveis ambiente do DOS, que apontam os diretórios onde se encontram cada tipo de arquivo usado pelo Clipper onde ele foi instalado, i.e., arquivos de cabeçalho (*.CH), bibliotecas (*.LIB), objetos (*.OBJ) etc. Usa-se o comando interno do MS-DOS chamado SET para definir tais variáveis e é aconselhável que todas elas estejam no arquivo de lote AUTOEXEC.BAT que é executado automaticamente toda vez que o computador é ligado. 

Ex.:

SET PATH=C:\WINDOWS;C:\WINDOWS\COMMAND;C:\CLIPPER5\BIN;C:\NG;C:\BLINKER
SET CLIPPER=S1,F200
SET INCLUDE=C:\CLIPPER5\INCLUDE
SET LIB=C:\CLIPPER5\LIB;C:\BLINKER\LIB
SET OBJ=C:\CLIPPER5\OBJ;C:\BLINKER\OBJ
SET PLL=C:\CLIPPER5\PLL
SET TEMP=C:\TEMP
SET TMP=C:\TEMP

   Veja mais detalhadamente como instalar o Clipper na página: http://caclipperwebsite.com/todos/node/dicas-cfg-win

  Observe que o linkador Blinker possui algumas variáveis ambiente iguais ao do Clipper, usa-se o ";" (ponto e vírgula) entre os valores da variável. Para saber mais sobre o Blinker, entre em Dicas. Se você não usa o Blinker, ignore o conteúdo de fundo amarelo do exemplo acima.
  Para verificar se estas variáveis estão definidas, digite SET no prompt de comando do MS-DOS (e tecle Enter), aparecerá todas as variáveis de ambiente definidas.

  Para compilar um programa em Clipper, digite CL mais o nome do seu programa. Ex.: CL teste

  CL é um arquivo de lote (*.BAT) que vem com o Clipper e fica no sub-diretório \BIN onde o Clipper foi instalado. Observe que este sub-diretório está no PATH do Autoexec.bat.

  Se você tem o Blinker, mas não sabe usar, baixe o arquivo BLI.BAT na página de Downloads, pois serve como o CL.BAT, exceto que, linkando com o Blinker.

  Todos os arquivos que estão dentro dos diretórios listados na variável ambiente PATH do MS-DOS, separados por ";", podem ser executados em qualquer outro diretório como se o referido arquivo nele estivesse.

  Para se obter o valor de uma variável ambiente no MS-DOS usa-se o "%" no início e no fim da variável. No Clipper usa-se a função GETENV(<variável ambiente>).

  Ex.: Digamos que você gostaria que o diretório C:\UTIL estivesse em seu PATH, mas você não quer alterar o Autoexec.bat e reiniciar a máquina agora e também não quer redigitar o PATH inteiro de novo incluindo o referido diretório, o que você faz? SET PATH=%PATH%;C:\UTIL

  Seu arquivo CONFIG.SYS deve estar, no mínimo, assim:

DEVICE=C:\WINDOWS\HIMEM.SYS /TESTMEM:OFF
DEVICEHIGH=C:\WINDOWS\EMM386.EXE 2048 MIN=1024 RAM HIGHSCAN
DOS=HIGH,UMB
BUFFERS=50
FILES=220
BREAK=ON
SHELL=C:\WINDOWS\COMMAND\COMMAND.COM C:\WINDOWS\COMMAND /E:1024 /P

 

Na última linha, o parâmetro /E:1048 acima reserva 1Kb de espaço ambiente (environment space) para variáveis ambiente. Prevenindo o erro out of environment space quando se está definindo novas variáveis ambiente no MS-DOS. Você pode aumentar esse número para 2048. Não se preocupe com isso se você estiver usando o Windows XP, veja como instalar o Clipper em: http://caclipperwebsite.com/todos/node/dicas-cfg-win

 

Se você deseja criar um sistema em Clipper, entre no sub-diretório SOURCE\DBU do Clipper e observe o que fazem os arquivos *.RMK e *.LNK. Observe também os *.PRG, todos são como grandes funções, começando na primeira linha por FUNCTION NOMEDOPROGRAMA(). Veja também que o programa executado primeiramente contém na sua primeira linha FUNCTION MAIN(). Esta é a melhor forma de compilação porque você não precisa compilar todos os programas de novo se alterar apenas alguns programas, só os programas que estiverem sido alterados serão compilados novamente, poupando-se tempo. Além disso, este método evita o erro: Too many symbols e o Too many labels. Veja a seguir o arquivo DBU.RMK comentado:


// Dbu.rmk
//
// Make file padrão para o utilitário DBU

//
// Copyright (c) 1990-1993, Computer Associates International Inc.
// All rights reserved.
//
// NOTA:
// Para compilar o DBU com o DEBUG (CLD) você deve definir

// o nome da macro DEBUG com o parâmetro /d. Isto pode ser feito assim: 

//
// RMAKE DBU /dDEBUG
//

// Determina se DEBUG é ativado

// Veja mais informações no seu Norton Guide (NG) em: Manutençao de Programas RMAKE.EXE (linha de comando)

#ifdef DEBUG
       //
Se foi ativado inclui parâmetro /b correspondente ao DEBUG

       // Veja mais informações no NG em: Compilador do Clipper CLIPPER.EXE (linha de comando)

       CompOptions := /b /m /n
#else
       CompOptions := /m /n
#end

.prg.obj:
clipper $< $(CompOptions)


// aqui é sempre uma lista de todos os programas que compõem seu aplicativo

// sendo que do lado esquerdo o nome do obj e do lado direito o nome do programa, separados por dois pontos (:)
dbu.obj    : dbu.prg
dbuutil.obj: dbuutil.prg
dbuhelp.obj: dbuhelp.prg
dbuview.obj: dbuview.prg
dbuindx.obj: dbuindx.prg
dbuedit.obj: dbuedit.prg
dbucopy.obj: dbucopy.prg
dbustru.obj: dbustru.prg
dbunet.obj : dbunet.prg


// essas linhas abaixo são desnecessárias, visto que é papel do arquivo *.lnk fazer isso

// não entendo porque existem e você pode criar o seu arquivo *.RMK apenas com as linhas que foram listadas acima.
dbu.exe: dbu.obj dbuutil.obj dbuhelp.obj dbuview.obj \
dbuindx.obj dbuedit.obj dbucopy.obj dbustru.obj dbunet.obj
rtlink @dbu

 

Este arquivo *.RMK é lido pelo RMAKE, já o *.LNK é lido pelo RTLINK, BLINKER etc.

Veja que as barras duplas para o RMAKE é um comentário, já para o RTLINK é a cerquilha (#) que faz esse papel.

Baixe o Norton Guide (NG) em português na página de Downloads.

Agora veremos o arquivo DBU.LNK comentado:

 

# coloque o arquivo principal do seu sistema na primeira linha e depois o resto.

# observe que basta o nome do arquivo sem a extensão

# todos os programas devem ser precedidos por "file"

file dbu
file dbuutil
file dbuhelp
file dbuview
file dbuindx
file dbuedit
file dbucopy
file dbustru
file dbunet
 

# no final ponha as LIBs que serão compiladas com o seu aplicativo

# as LIBs devem ser precedidas por "lib"
lib clipper
lib extend
lib dbfntx
lib terminal
 

Assim você agiliza a compilação do seu sistema.

É tão fácil programar em Clipper que você não precisa de uma estrutura tão complicada para criar um programa simples, veja como ficaria o clássico programa "Olá Mundo":

 

? "Olá, Mundo!"

 

Pronto! Mais nada. Agora é só salvar o arquivo como ola.prg e compilar com CL OLA. Viu como é facil?

 

Agora veja como seria em C++:

 

#include <iostream>
 
int main()
{
   std::cout << "Olá, Mundo!";
   return 0;
}

Em PASCAL:

Program Ola_Mundo;
Uses crt;
Begin
   Writeln('Olá, Mundo!');
End.

 

Em FORTRAN:

 

 PROGRAM HELLO
WRITE(*,10)
10 FORMAT('Olá, Mundo!')
STOP
END

    Em ASSEMBLY:

.model small
.stack
.data
message   db "Olá, Mundo!", "$"

.code

main   proc
   mov   ax,seg message
   mov   ds,ax

   mov   ah,09
   lea   dx,message
   int   21h

   mov   ax,4c00h
   int   21h
main   endp
end main


__________________________

Fonte: Programa Olá Mundo. In: <http://pt.wikipedia.org/wiki/Programa_Olá_Mundo >. Acessado em 01/05/2010.
 

Agora está vendo o que estou falando, não é?! rs

Veremos a seguir os tipos de campos e variáveis do Clipper:

 

Tipos de campos do Clipper

NUMÉRICO

Aceita apenas números com ou sem casas decimais (decimals). O ponto da casa decimal conta no tamanho (width).

Exemplo:  999.99  (width 6, decimals 2)

CARACTERAceita letras e números. Tamanho máximo de 256 caracteres.
DATAAceita apenas datas.
LÓGICOAceita apenas Verdadeiro (.T.) ou Falso (.F.)
MEMO

Aceita letras e números, é como um tipo de campo Caracter com tamanho de até 64Kb. Usado geralmente para armazenar "Observação" ou outras informações que precisem ser detalhadas.

Ao adicionar um campo Memo no seu DBF, é criado um espelho dele com a extensão .DBT. (Se o RDD usado for o nativo do Clipper DBFNTX).

Só é possível editar um campo memo com a função MEMOEDIT().

 

Exemplo: O DBF "clientes" tem um campo memo para observações dos clientes, então irá existir:

CLIENTES.DBF

CLIENTES.DBT

 

Tipos de variáveis do Clipper

NUMÉRICO

Aceita apenas números com ou sem casas decimais (decimals). O ponto da casa decimal conta no tamanho (width).

Exemplo: 

nTOTAL = 0

nCAMPO = 125

CARACTER

Aceita letras e números. Tamanho máximo de 256 caracteres.

Exemplo:

cNOME = SPACE(35)

cCAMPO = "ANDERSON"

DATA

Aceita apenas datas. Considere o uso do comando SET DATE BRITISH para definir o padrão de data igual ao brasileiro dd/mm/aa. Considere também o uso do comando SET EPOCH TO 1980 para resolver o "Bug do Milênio", veja mais em Know-how - Y2K Bug do Ano 2000.

Exemplo:

dDATA = CTOD("")

dHOJE = DATE()

dDTFINAL = CTOD("06/08/2005")

LÓGICO

Aceita apenas Verdadeiro (.T.) ou Falso (.F.)

Exemplo:

lCOMPLETO = .T.

lERRO = .F.

"MEMO"

Variável do tipo Memo não existe, seria uma variável do tipo caracter com mais de 256 bytes que só caberia em um campo Memo.

Exemplo:

mOBS = MEMOREAD("NOTAS.TXT")

ARRAY

Também chamado de matriz ou vetor. São como vários campos agrupados em uma lista. É uma estrutura de dados que contém uma série de dados ordenados, chamados "elementos". Os elementos são referenciados por número ordinal, primeiro elemento é 1, segundo 2... Os elementos podem ser de qualquer tipo, caracter, numérico, data etc. Veja mais detalhes em TUDO SOBRE ARRAYS.

CODEBLOCK

É um tipo especial de variável que armazena um pedaço de código compilado.

Exemplo:

 @ 10,10 SAY "CODIGO:" GET WCOD PICT "999999" VALID;

 EVAL( { || WCOD := STRZERO(WCOD,6), .T.} )
 

 

Espero que tenha satisfeito os visitantes que sentiam falta de informações iniciais introdutórias ao Clipper. Obrigado pela atenção.

AnexoTamanho
Side Kick69.73 KB
QEdit101.05 KB