Você está na página 1de 50

Desenvolvimento de

Software Aplicativo I

Enviado por :
Rodrigo dos Reis Lopes Bahia

Rodrigo dos Reis Lopes Bahia


1
ETE DE HORTOLÂNDIA - CEETEPS
CURSO TÉCNICO DE INFORMÁTICA

DESENVOLVIMENTO DE SOFTWARE
APLICATIVO I

1º Módulo

2º Semestre / 2005
Capítulo I.........................................................................................................................................5
Introdução: ..................................................................................................................................5
Conceitos Iniciais: .......................................................................................................................5
Software: .....................................................................................................................................5
Programa: ....................................................................................................................................5
Linguagem de Programação:.......................................................................................................5
O que é o Clipper?.......................................................................................................................6
Compilação e Link-edição ..........................................................................................................7
Nota: Em nossas aulas, utilizaremos um arquivo .bat para executarmos o Clipper....................8
Sistemas:......................................................................................................................................8
Capítulo II: ......................................................................................................................................9
Variáveis de Memória: ................................................................................................................9
Finalidade: ...............................................................................................................................9
Características: ........................................................................................................................9
1. Números .........................................................................................................................10
2. Cadeias de caracteres .....................................................................................................10
3. Lógicas ...........................................................................................................................10
4. Datas...............................................................................................................................10
Operadores: ...............................................................................................................................10
1. Atribuição.......................................................................................................................10
2. Operadores matemáticos ................................................................................................11
3. Operadores de Strings ....................................................................................................12
4. Operadores de Datas ......................................................................................................12
5. Operadores Lógicos .......................................................................................................13
Comentários ..............................................................................................................................14
Expressões Relacionais .............................................................................................................14
Atividade A: ..............................................................................................................................15
Capítulo III: ...................................................................................................................................17
Lógica:.......................................................................................................................................17
Atividade B: ..........................................................................................................................17
Lógica de Programação:............................................................................................................17
Atividade C: ..........................................................................................................................18
Capítulo IV:...................................................................................................................................19
Comandos de Entrada e Saída de Dados:..................................................................................19
1. Entrada de Dados: Comando SAY.................................................................................19
2. Saída de Dados: Comando GET ....................................................................................19
Escrevendo um Dado na Tela....................................................................................................19
O comando SAY ...................................................................................................................19
Formatação ............................................................................................................................20
Lendo um Dado na Tela ............................................................................................................20
O comando GET....................................................................................................................20
Formatação de Entrada..........................................................................................................21
Limpando a Tela........................................................................................................................22
Atividade D: ..............................................................................................................................22
Capítulo IV:...................................................................................................................................23
Estruturas de Controle ...............................................................................................................23
Estrutura de Controle Condicional:...........................................................................................23
1. Estrutura de Controle condicional Simples:...................................................................23
Atividade E................................................................................................................................23
2. Estrutura de Controle condicional Composta: ...............................................................24
Rodrigo dos Reis Lopes Bahia
3
Atividade F ................................................................................................................................25
Capítulo V: ....................................................................................................................................26
Estruturas de Controle de Repetição .........................................................................................26
Repetindo Ações: ..................................................................................................................26
Atividade G ...............................................................................................................................27
Capítulo VII: .................................................................................................................................27
Alguns Comandos e Funções de Formatação de Tela...............................................................27
1. LOG().............................................................................................................................27
2. MOD()............................................................................................................................28
3. SQRT()...........................................................................................................................28
4. @... BOX........................................................................................................................28
5. @ . . . CLEAR................................................................................................................29
6. @. . . TO.........................................................................................................................29
7. SET CENTURY.............................................................................................................29
8. SET COLOR ..................................................................................................................29
9. SET DELIMITERS........................................................................................................30
10. SET DELIMITER TO................................................................................................30
11. SET WRAP ................................................................................................................31
12. ALERT( ) ...................................................................................................................31
13. CTOD( ) .....................................................................................................................31
14. DATE( ) .....................................................................................................................31
15. SET DATE.................................................................................................................31
16. DTOC( ) .....................................................................................................................32
17. OUTRAS FUNÇÕES: ...............................................................................................32
Atividade H ...............................................................................................................................33
Capítulo VII: .................................................................................................................................34
Usando um Banco de Dados .....................................................................................................34
Criação de Banco de Dados ......................................................................................................34
1. Comando USE................................................................................................................34
2. Movimentação de Ponteiro ............................................................................................34
Criar um arquivo e um programa para seu preenchimento ...................................................35
Excluir um registro....................................................................................................................36
Áreas de Trabalho .................................................................................................................36
Bibliografia: ....................................................................................................................50
Capítulo I

Introdução:

Desde os primórdios, o homem vem tentando resolver seus problemas com a maior rapidez e
o menor esforço possível, procurando automatizar as tarefas rotineiras. Isso possibilitou o
aparecimento de instrumentos como roda, roldana, alavanca, carro e até o computador.
No entanto, as tarefas que devem ser realizadas pelo computador de forma automática têm de
ser anteriormente pensadas e colocadas em uma seqüência de ações para, posteriormente, serem
inseridas na máquina. A essa seqüência de ações denomina-se “Programa” e a fase de formular
soluções que gerem programas denomina-se Lógica de Programação.
A meta principal de qualquer programador é resolver problemas por meio de soluções lógicas
para obter resultados eficientes (corretos) e eficazes (com qualidade). Porém, se as soluções não
forem bem planejadas (passo a passo), com certeza essa meta não será atingida.

Conceitos Iniciais:

Software:
“É um conjunto dos programas que comandam o funcionamento do hardware. Programas são
feitos a partir de algoritmos – seqüência de instruções/comandos para se atingir um objetivo.”
Depois de pronto, o algoritmo é convertido para uma linguagem de programação. O produto
dessa conversão é um programa.

Programa:
É o conjunto de instruções que contém as operações necessárias para, a partir de dados
inseridos, obter um resultado que será disponibilizado por algum dispositivo de saída.

Linguagem de Programação:
É o conjunto de representações e/ou regras utilizadas para criar programas. Por meio delas
você estabelece uma comunicação com o computador, fazendo com que ele compreenda e execute o
que você determinar. A proximidade com a linguagem humana determina o nível da linguagem de
programação.

Existem três níveis de linguagens de programação:


1. Linguagem de Máquina: é a linguagem compreendida pelo computador, cujas
instruções são representadas por vários 0 e 1 (bits).
2. Linguagem de Baixo Nível: é a linguagem que utiliza instruções próximas à
compreensão da máquina. Essa linguagem exige um grande conhecimento de hardware. Exemplo:
Assembler.
3. Linguagem de Alto Nível: é a linguagem cujas instruções estão próximas do nível de
compreensão humana (linguagem humana). Exemplo: Visual Basic, Delphi, C, Java, Clipper,
Pascal, etc.

Nesta disciplina usaremos a linguagem de programação Clipper para desenvolvimento


de aplicativos.

Rodrigo dos Reis Lopes Bahia


5
O que é o Clipper?

Clipper é uma linguagem de programação desenvolvida para microcomputadores cujo


principal objetivo é o desenvolvimento simples e rápido de sistemas baseados em bancos de dados.
Sistemas comerciais, desde pequenos controles pessoais como agendas e controle
bancário,passando por sistemas para gerenciamento de operações de pequenas e médias empresas
como cadastros, relatórios diversos ou fluxos financeiros, e até o controle de sistemas de
gerenciamento de grande volume de informações para empresas de porte elevado podem ser
desenvolvidos nesta linguagem de programação. Mesmo sistemas com certa sofisticação gráfica ou
recursos sonoros e vários outros elementos podem tomar como base o Clipper, devido à sua
flexibilidade em trabalhar em conjunto com linguagens como C.
Todos estes recursos são provenientes da filosofia da linguagem, tendo como ponto de partida
um pacote gerenciador de bancos de dados, o DBase III Plus, que trazia várias facilidades no
gerenciamento e acesso rápido às informações armazenadas, mas, por ser um interpretador, possuía
uma série de limitações quanto ao desenvolvimento de programas e sistemas, enquanto o Clipper é
um compilador.
Para tornar esta diferença mais clara, devemos apresentar alguns com conceitos que aparecem
com grande freqüência.
Quando escrevemos um programa em qualquer linguagem de alto nível (como o próprio
Clipper, Pascal, C, Cobol, etc.), utilizamos um editor de textos para escrever uma série de
comandos que desejamos que o computador execute. Este arquivo contendo os comandos de
linguagem de alto nível é chamado de programa fonte e utiliza .prg como extensão de arquivo.
Exemplo: teste.prg.
Entretanto, o computador não é capaz de executar os comandos contidos neste programa (ou
arquivo) fonte, pois a única linguagem que estas máquinas compreendem é uma linguagem de
baixo nível, chamada de linguagem de máquina, extremamente complexa e desagradável para os
padrões de um ser humano. Assim, deve haver um processo de "tradução" que transforme o nosso
programa fonte em um programa equivalente escrito em linguagem de máquina, (programa objeto,
utiliza .obj como extensão de arquivo). As duas principais maneiras de realizar este processo de
tradução são chamadas de interpretação e compilação.
No processo de interpretação, o programa interpretador analisa cada linha de seu programa
fonte separadamente, verifica se esta linha está correta e, caso esteja, gera uma linha equivalente em
linguagem de máquina e realiza a execução. Este processo se repete até que a última linha do seu
programa tenha sido executada. No final, o código em linguagem de máquina resultante da tradução
das linhas de seu programa fonte não é guardado. Todas as linhas são descartadas e todo o processo
de tradução deve ser repetido para uma nova execução.
Já no processo de compilação, o programa compilador da linguagem analisa todo o programa
fonte gerado. Caso nenhum erro seja encontrado, todo o programa fonte será traduzido para
linguagem de baixo nível e armazenado em um arquivo separado, chamado de arquivo objeto. Um
processo adicional, chamado de link-edição, que será detalhado a seguir, transforma este arquivo
objeto em um arquivo executável, capaz de ser compreendido pela máquina. O arquivo executável,
como o próprio nome indica, está pronto para ser executado pelo computador.
Uma das principais vantagens da compilação está no fato de que, uma vez gerado o arquivo
executável, ele pode ser utilizado inúmeras vezes sem a necessidade da presença do compilador ou
qualquer outro utilitário, ao passo que os interpretadores são sempre necessários para a execução de
seus programas.
Outra vantagem está na velocidade de execução. Um programa compilado possui uma
execução muito mais rápida que um equivalente interpretado, pois a interpretação sempre tem de
realizar a tradução de cada linha do seu programa fonte.
Por último, os compiladores garantem segurança em relação ao seu código fonte, já que ele
não é necessário para a execução de um programa já compilado.

Compilação e Link-edição
Mencionamos anteriormente que dois processos são necessários para gerar um programa
executável: compilação e link-edição. A familiarização com estes dois processos é o ponto de
partida para a utilização do Clipper.
Ao contrário de outras linguagens de programação, como Pascal e C, o Clipper não possui um
ambiente integrado, ou seja, você não "entra" no Clipper como é feito em Pascal ou mesmo em
DBase. Tudo é feito a partir do próprio sistema operacional e com o apoio de alguns – utilitários.
Para que o processo fique claro, escreveremos um pequeno programa para exemplificar todas
as fases necessárias no desenvolvimento em Clipper.
Em primeiro lugar, devemos escolher um editor de textos onde escreveremos o nosso
programa fonte. Embora possamos utilizar qualquer editor, PE (editor que acompanha Clipper) ou
O SideKick, já que são editores compactos, de alta velocidade para operação e de simples
utilização; aqui usaremos o EDIT. (do Ms-Dos que é comum à todos).
Uma vez que você tenha escolhido o editor de sua preferência, vamos abri-lo e depois
começaremos a digitar algumas linhas em nosso programa.
Nota: Você pode optar por letras maiúsculas ou minúsculas, ou até uma combinação delas, já
que isso será indiferente para o Clipper.
Em seguida gravaremos o arquivo acima com o nome de EXEMPLO.PRG. Você acaba de
gerar um programa fonte em Clipper!
Agora que temos o programa fonte, devemos compilá-lo. O programa que realiza esta tarefa é
o CLIPPER.EXE. Para compilar o seu programa fonte digite, a partir do MS-DOS, o seguinte:
clipper exemplo
O compilador fará una verificação no seu código fonte à procura de erros. Caso você tenha
digitado incorretamente alguma palavra do programa acima, o compilador emitirá uma mensagem
anunciando “um erro de compilação”, indicará a linha em que esse erro ocorreu e interromperá o
processo. Neste caso, devemos retornar ao editor de textos e corrigir o nosso erro, para depois
efetuar novamente a compilação.
Caso nenhum erro seja detectado, o Clipper irá gerar no diretório corrente um arquivo objeto
com o nome de EXEMPLO.OBJ. Este arquivo é a tradução do que foi escrito no programa
fonte para a linguagem de máquina do computador. Entretanto, como já dissemos, um arquivo
objeto ainda não pode ser executado, pois existem certas funções e comandos definidos dentro das
bibliotecas do Clipper que devem ser anexados ao programa para que ele possa funcionar. O
programa responsável por unir ao programa criado às bibliotecas necessárias é chamado de link-
editor. O link-editor utilizado pelo Clipper é chamado de RTLINK. EXE e para acioná-lo você
deve digitar a seguinte linha de comando no MS-DOS:
rtlink file exemplo
Caso nenhum erro ocorra, será apenas informado o tamanho final do arquivo gerado. Agora,
verificando o diretório de seu disco, observe que foi gerado um arquivo chamado de
EXEMPLO.EXE, que é exatamente um arquivo executável. Para observar a execução deste
programa, basta digitar o nome do arquivo executável, ou seja:
exemplo
O programa então será e executado.
Nota: Em nossas aulas, utilizaremos um arquivo .bat para executarmos o Clipper.

Sistemas:
É um conjunto de subsistemas ou módulos formados por programas que executam operações
específicas.

Instalando Clipper no Windows 2000 e Windows XP:


*após a instalação o Clipper criara um arquivo em lote chamado cl.bat, o qual funciona
corretamente nos sistemas Win95, Win98, porém para que também funcione co Win2000 e
WinXP, é necessário fazer algumas alterações conforme abaixo:

config.nt :
Local: C:\Winnt\systen32\config.nt
Edite o arquivo config.nt, acrescentando:
FILES=251

autoexec.nt:
Local: C:\Winnt\systen32\autoexec.nt
Edite o arquivo autoexec.nt, acrescentando:
set lib=c:\clipper5\lib
set pll=c:\clipper5\pll
set obj=c:\clipper5\obj
set include=c:\clipper5\include
set clipper=F251

Depois:
Meu Computador
Propriedades
Avançado
Variáveis de Ambiente
Sistema
Editar path
Criar variáveis de ambiente
Nova
C:\clipper5\bin;
set lib=C:\clipper5\lib;
set pll=C:\clipper5\pll;
set obj=C:\clipper5\obj;
set include=c:\clipper5\include
set clipper=F251

Outros comandos:
C:\mode con lines=25
Capítulo II:

Variáveis de Memória:

Finalidade:

O objetivo básico de uma variável de memória é armazenar temporariamente um determinado


dado. Dentro de um programa, possuímos uma série de dados que devem ser manipulados, alterados
e combinados, e estes dados precisam de um lugar onde possam ficar armazenados.

Uma das opções para guardar um dado é utilizar um banco de dados, que armazena estes
dados em disco permitindo a sua posterior recuperação sempre que necessário. Falaremos sobre a
utilização de bancos de dados posteriormente.

A outra opção para armazenar um determinado dado (um nome, endereço, número, etc.) são
as variáveis de memória. Ao contrário dos bancos de dados, as variáveis servem apenas para
armazenar temporaramente um valor, pois quando a execução de um programa chega ao fim, o
valor de suas variáveis é perdido. Mesmo assim, as variáveis representam um poderoso instrumento
de trabalho para programadores em qualquer linguagem de programação, e seu uso correto pode
facilitar muito nossas vidas.

Características:

Uma variável, antes de qualquer coisa, deve possuir um nome. E, para escolher o nome de
uma variável, devemos observar as seguintes regras:

• Nomes de variáveis devem ser formados por letras, números ou o símbolo de underscore
(“_”), devendo ser iniciados por uma letra.

Exemplo:
NOME
ENDERECO
TEL_RES
TEL_COM
Dia_da_Sem
Salario

O compilador não faz distinção entre letras maiúsculas e minúsculas. Isto significa que, para
ele, NOME, nome ou Nome são a mesma variável.

• Observar o limite de 10 caracteres para o nome de uma variável.


• Procurar SEMPRE escolher nomes significativos para as variáveis, ou seja, nomes que
indiquem a sua finalidade. Uma de suas variáveis foi criada para armazenar um salário procure não
chamá-la de XYZ ou S!

Além de um nome, uma variável possui também um conteúdo.

Em Clipper, existem quatro tipos básicos de informações que podem ser armazenadas em
variáveis:
1. Números

São informações relativas a dados numéricos, como o salário, de um funcionário ou o número


de peças em estoque. Uma das principais características das variáveis numéricas é que elas
permitem a realização de operações aritméticas (soma subtrações, etc.) e a utilização de funções
para exponenciação raiz quadrada, etc.

2. Cadeias de caracteres

Informações que representam dados como nomes, endereço etc.


Uma cadeia de caracteres pode conter qualquer tipo de cara. em seu interior, desde letras e
símbolos especiais (como #, &, etc.) até números. Entretanto, não podemos efetuar operações
aritméticas com números armazenados em variáveis do tipo caractere, pois o compilador as
considera apenas como uma seqüência de símbolos. O conteúdo de uma variável caracter também
chamada de string, deve ser representado entre aspas.

3. Lógicas

As variáveis lógicas, também conhecidas como booleanas, são uns tipos especiais de variável
que só pode conter dois valores: verdadeiro ou falso, representados em Clipper por.T. (true) e.F.
(false).

4. Datas

Por se tratar de uma linguagem de uso comercial, o Clipper apresenta uma grande facilidade
na manipulação de datas.
Existe um tipo de variável definido no Clipper para o armazenamento e a manipulação de
datas, que permite efetuar operações entre datas de forma extremamente simples, além de uma
checagem automática de datas válidas.

Operadores:

Operadores são sinais especiais que permitem alterar o valor de uma variável ou combinar o
valor de duas ou mais variáveis da forma desejada. Os operadores básicos mais importantes da
linguagem Clipper são:

1. Atribuição

Operador que permite modificar o conteúdo de uma variável. Os dois operadores para
atribuição de valores a variáveis são os simbolos =

Por exemplo, se desejarmos armazenar o número cinco dentro de uma variável chamada
“Número”, basta escrever a seguinte linha de comando:

Numero = 5
ou
Numero:= 5

Ou, então, para armazenar um nome ou um telefone em outra variável:


NOME = “Maria”
Tel := “222-2222”
O operador permite ainda atribuições múltiplas, como no seguinte exemplo:
valor_l:= valor_2:= 10

Na linha acima, o valor 10 foi atribuído a duas variáveis (valor e valor2), simultaneamente.
Podemos ainda atribuir o conteúdo de uma variável a outra qualquer, como no exemplo a
seguir:
var_1 = 5

var_2 = var_1

As duas variáveis possuem agora o valor 5.

Nos tipos de variáveis que já foram mencionados, a exceção nas variáveis do tipo data. Para
armazenar uma data qualquer em uma variável, devemos proceder da seguinte forma:

Data = CTOD(“12/12/99”)

CTOD é uma função da linguagem Clipper que diz ao compilado que o que está dentro das
aspas deve ser encarado como uma data não como uma seqüência normal de caracteres.
Posteriormente, apresentaremos esta e outras funções de forma mais clara. Obs.: Devemos incluir
no início dos programas que manipulam a linha:

Set Date to British

2. Operadores matemáticos

Permitem a realização de operações matemáticas entre variáveis ou constantes numéricas. Os


principais operadores matemáticos são:
—Soma: +
—Subtração: -
—Multiplicação: *
—Divisão: /
—Exponenciação: ^

Exemplos de utilização de operadores matemáticos:


X=2 +3
R=A * 2
Valor = A + B / C
O lado direito das atribuições acima, onde variáveis e constantes são combinadas através de
operadores, é conhecido como expressão.

Na linha de atribuição R = A * 2, ocorrem dois passos distintos. Primeiro, a expressão A * 2 é


avaliada, ou seja, é calculada para que se obtenha um valor numérico (que será o valor atual da
variável A multiplicado por dois). No segundo passo, o resultado da expressão atribuído à variável
R.

Uma expressão, por maior que seja, sempre produz como resultado final um único valor.

• Precedência de Operadores
Vamos considerar a seguinte linha de um programa:
X= 2 * 3 + 4 / 2 - 1
Qual será o valor que a variável X receberá ao final desta linha de comando? Ou seja, qual
será o valor da expressão acima?

Para responder a esta pergunta, devemos apresentar o conceito de precedência de operadores.


Dentre os operadores matemáticos acima (soma, subtração, multiplicação, divisão e
exponenciação) as operações serão executadas sempre na seguinte ordem:

—Exponenciações
—Multiplicações e Divisões
—Somas e Subtrações

Isto significa que multiplicações e divisões possuem uma precedência maior que somas e
subtrações, ou seja, serão sempre calculadas em primeiro lugar em uma expressão.
Dentro de operadores com a mesma precedência, a ordem de cálculo é indiferente, sendo
geralmente realizados da esquerda para a direita.
Então, a expressão acima produziria o seguinte resultado:

X=2 * 3 + 4 / 2 - l
x=6 + 2 - l
x=8 - l
X=7

Uma alternativa para mudar a ordem de cálculo dentro de uma expressão é o uso dos
parênteses. A expressão em seu interior será sempre calculada antes de qualquer outra,
independente do tipo de __Se a expressão anterior fosse reescrita da seguinte maneira:
operadores.
X= 2 * (3 + 4) / 2 - 1
O resultado seria:

X=2 * 7 / 2 - l
X.= 2 * 3.5 - 1
X= 7 - 1
X= 6

3. Operadores de Strings

O principal operador de variáveis do tipo string é a concatenação, realizada através do


operador +.
Concatenar duas ou mais strings significa a junção destas para formar uma nova string. Por
exemplo:

A = “Joao”
B = “da Silva”
C =A+B

O valor da variável C será: “Joao da Silva”

4. Operadores de Datas

Com variáveis do tipo data podemos realizar as seguintes operações básicas:


- Somar um determinado número de dias a uma data.

Exemplo:

Data = CTOD (“12/10/93”)


Data = Data + 5

O novo valor da variável Data será 17/10/93.

- Subtrair um determinado número de dias a uma data.

Exemplo:

Data_2 = ctod (“01/01/94”)


Data_3 = Data_2 - 3

O valor da variável Data_3 será 29/12/93.

- Calcular o número de dias entre duas datas.

Exemplo:

Data_4 = ctod (“15/03/93”)


Data_5 = ctod (“18/03/93”)
Dias =Data5 - Data4

O valor da variável Dias será 3.

5. Operadores Lógicos

Operadores lógicos, como o próprio nome indica, atuam sobre variáveis ou constantes lógicas,
que, como foi dito anteriormente, podem possuir apenas dois valores: verdadeiro (.T.) ou falso (.F.).
Uma particularidade a respeito dos operadores lógicos é que eles sempre são escritos entre pontos,
como será mostrado nos exemplos seguintes.

Os principais operadores lógicos em Clipper são:

- .AND.

Retorna o valor verdadeiro apenas quando os dois operandos possuem o valor verdadeiro.
Caso contrário, retorna falso.
Exemplo:
A =.T.
B =.T.
C = A.and. B
A variável C receberá o valor verdadeiro (.T.).
- .OR.

Retorna o valor falso apenas quando os dois operandos possuem o valor falso, retornando
verdadeiro em outras situações.

Exemplo:
X=.T.
Y =.F.
Z = X .or. Y

O valor da variável Z será verdadeiro (.T.).

-.NOT.
O operador . not . atua sobre um único operando, invertendo seni pre o seu valor.
Exemplo:
Lógico =.T.
L_2 =.not. Lógico
O valor da variável L_2 será falso (.F.).

Comentários

Comentários são linhas acrescentadas aos programas para tomar mais clara a sua
apresentação, facilitando a documentação e a resolução de erros que possam surgir.

Não existe qualquer influência de um comentário sobre a lógica ou sobre a execução de um


programa.
Qualquer linha iniciada por um asterisco (*) é considerada comentário pelo compilador.
Exemplo:
********************
*Isto é um Comentário*
********************

Expressões Relacionais
São expressões compostas por outras expressões ou variáveis numéricas com operadores
relacionais. As expressões relacionais retornam valores lógicos.

• Operadores relacionais:

Operador
Operação
Relacional
= Igualdade
<> Diferença
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
Atividade A:

1) Verifique se os identificadores de nome de variáveis a seguir são válidos. Se não


forem, explique por quê.
a) Nome-do-aluno
b) $
c) Dinheiro
d) Data/de/nascimento
e) Nome2
f) 2Apessoa
g) Maior_de_idade?
h) Nome_da_pessoa

2) Defina o tipo das variáveis abaixo:


a) endereço=´Rua 12 de novembro, 330´
b) dtcad=ctod(´15/12/2005´)
c) fumante=.F.
d) salario=0
e) nota=0
f) nome=´Pedro`

3) Apresente o resultado das variáveis abaixo:


a) data=ctod(´15/04/2005´ )
datah= data + 3
? datah
b) x = 3
z=9
y=x^z
?y
c) A = 5
B=2
C=A*B
?C
d) x1 = y * C
? x1
e) D = z / x
?D
f) E = A – B
?E
g) W = E * D + x
?W
h) var1 = 100
var2 = ´XYZ´
var3 = var1 + var2
? var3
i) sal = 1000
tiposal = ´mensal´
res = sal + tiposal
? res
j) prod1 = ´TESTE´
prod2 = 10
prod3 = prod1 + prod2
? prod3

k) ativo = .F.
status = 1
tot = ativo + status
? tot

l) num1 = 3
num2 = 5
num1 = 7
num1 = 9
?num1
?num2

m) p1 = space(05)
p2 = ´20´
pr = p1 + p2
? pr

4) Declare as variáveis para os algoritmos dos cadastros a seguir:


a) Passagem aérea;
b) Fita de Vídeo de uma locadora;
c) Livros de uma biblioteca;
d) Cd’s de uma coleção de música;
e) Cursos de uma academia;
f) Clientes de uma loja;

5) Atribua valores às variáveis que você declarou no exercício acima.


Capítulo III:

Lógica:

As pessoas utilizam a lógica no cotidiano sem perceber; chegam mesmo a citá-la, sem
entender direito o seu significado.
Segundo o dicionário, lógica é a “coerência de raciocínio, de idéias”, ou ainda a
“seqüência coerente, regular e necessária de acontecimentos, de coisas”. Por exemplo:

1. O número 3 é menor que o número 5.


O número 7 é maior que o número 5.
Logo, o número 3 é menor que os números 5 e 7.

2. Quando chove, não é preciso regar as plantas do jardim.


Hoje choveu.
Logo, hoje não é preciso regar as plantas do jardim.

Porém, às vezes, o raciocínio funciona desordenadamente. Neste outro exemplo estão


descritas ações de quem vai a um banco, entretanto, veja se seria possível retirar o dinheiro
obedecendo à seqüência descrita:

1. Sair do banco.
2. Aguardar a vez de ser atendido.
3. Entrar na fila do caixa.
4. Digitar a senha.
5. Entrar no banco.
6. Informar o valor a ser retirado.
7. Procurar a fila do caixa.
8. Pegar o comprovante do saque, o cartão eletrônico e o dinheiro.
9. Entregar o cartão eletrônico ao funcionário que atende no caixa.
10. Conferir o valor em dinheiro.

Perceba, que embora as ações estejam corretas, a seqüência está errada.

Atividade B:

1. Uma pessoa precisa trocar o pneu furado de um carro. Quais as ações necessárias
para realizar essa tarefa e em qual seqüência?

2. Qual a seqüência para se obter a resposta da operação matemática “5 multiplicado


por 6 mais 2, dividido por 3” em uma calculadora simples?

Lógica de Programação:

Falar em lógica de programação significa apenas contextualizar a lógica na programação de


computadores, buscando a melhor seqüência de ações para solucionar determinado problema.
Na programação de computadores, o nome dessa seqüência de ações é algoritmo, que é, de
maneira bem simples, a seqüência de passos ou ações para atingir um objetivo.
Já ações são um fato que, a partir de um estado inicial, após um período de tempo finito,
produz um estado final previsível e definido. Por exemplo, abrir a porta é uma ação.
Porta fechada Ação: Abrir Porta fechada
Tempo: Segundos
Estado Inicial Estado Final

A partir desse, exemplo, pode-se redefinir o conceito de algoritmo como a descrição de um


conjunto de ações que quando obedecido, dentro de um padrão de comportamento definido, resulta
uma sucessão finita de passos, atingindo-se o objetivo.

Exemplo
Problema: qual a sequência de ações para se abrir uma porta?
Solução:
1. Andar até a próxima porta;
2. Pegar na maçaneta;
3. Girar a maçaneta;
4. Puxar a porta.
Ao se estabelecerem as ações, é definida uma sequência que seria naturalmente executada por
qualquer pessoa, determinando-se um padrão de comportamento.

Atividade C:

1. Imagine que uma pessoa decida ir de táxi a uma reunião de negócios. Monte um
algoritmo com a seqüência de ações para que ela chegue ao prédio onde vai ocorrer a reunião.
2. Monte um algoritmo com a seqüência de ações para fazer um cachorro quente.
3. Monte um algoritmo com a seqüência de ações para encontrar o nome de João
Ferreira Neto em uma lista telefônica.
4. Monte um algoritmo com a seqüência de ações para retirar R$ 100,00 de um caixa
automático de banco.
5. Monte um algoritmo com a seqüência de ações que permita a soma de dois números
inteiros, em uma calculadora. Use termos como “aperte a tecla xx” nas ações.
6. Monte um algoritmo com a seqüência de ações que permita a entrada de dois
números inteiros e que realize as quatro operações básicas em uma calculadora. Use termos como
“aperte a tecla xx” nas ações.
7. Monte um algoritmo com a seqüência de ações para efetuar o cálculo matemático
(5+6)/2, feito em uma calculadora. Use termos como “aperte a tecla xx” nas ações.
Capítulo IV:

Comandos de Entrada e Saída de Dados:


Na elaboração do algoritmo incluem-se os comandos para entrada e saída de dados. Os dados
entram no computador (são “lidos”) por meio dos códigos de barras, teclado, etc. e saem dele (são
“escritos”) por meio da impressora, do monitor, som, etc.
O teclado e o monitor são bons exemplos de dispositivos de entrada e saída de dados: quando
você pressiona uma letra no teclado, o computador recebe e interpreta o sinal que representa o letra
e logo após emite o sinal que vai mostrar a letra no monitor.

1. Entrada de Dados: Comando SAY


Sintaxe do comando: leia (variável)

2. Saída de Dados: Comando GET


Sintaxe do comando: escreva (variável)

Qualquer programa, por mais básico que seja, deve possuir uma entrada e uma saída de dados.
De nada nos adiantaria um programa ao qual não pudéssemos enviar dados ou que simplesmente se
recusasse a nos dar qualquer informação.
A principal forma de entrada de dados ocorre pelo teclado do computador, enquanto a saída
mais utilizada é o monitor de vídeo. Veremos neste capítulo como podemos enviar dados ao nosso
programa a sua execução (entrada de dados), ou receber informações (saída de dados).

Escrevendo um Dado na Tela

O comando SAY

O principal comando que nos permite escrever um dado, constante ou variável, na tela do
computador, possui o seguinte formato básico:

@ linha, coluna SAY valor

Primeiramente, para entender a descrição acima, precisamos saber que a tela do nosso
computador, quando estamos trabalhando com textos, possui um sistema de coordenadas para que
possamos especificar onde uma determinada palavra ou valor deve ser escrito. A nossa tela, do
ponto de vista do computador, é dividida em linhas e colunas numeradas, formando um conjunto de
posições, cada uma com o seu “endereço”, ou seja, a sua linha e a sua coluna. Em modo texto, a tela
do computador possui 25 linhas e 80 colunas, formando um conjunto de posições conforme
mostrado a seguir:

.. 7 8 9 0

5
Exemplo:
@ 1,1 SAY 5
@ 25, 1 SAY “Maria”

V_Nome = ”João”
V_Valor = 10
@ 1, 1 SAY “Nome:”
@ 1, 7 SAY V_Nome
@ 2, 1 SAY “Valor:”
@ 2, 7 SAY V_Valor

Lembramos que o nome de uma variável, independente do tipo do seu conteúdo, jamais é
escrito entre aspas.

Formatação

Uma facilidade do comando SAY é a possibilidade de formatar a sua saída de dados, ou seja,
exibir os seus dados na tela de forma mais conveniente ou organizada para o usuário.
Isto é obtido através da opção PICTURE do comando SAY. Uma PICTURE é uma máscara
para a impressão dos dados e pode ser de qualquer tipo abaixo:
• B : alinha números à esquerda
• C : mostra CR após números positivos
• D : exibe data no formato atual
• E : exibe data no formato britânico
• X : mostra DB após números negativos
• Z : mostra zeros como brancos
• ( : exibe números negativos entre parênteses
• ! : transforma alfanuméricos em maiúsculas
• A, N, X, 9, # : exibe qualquer tipo de dado
• L : exibe valores lógicos no formato .T. ou .F.
• Y : exibe valores lógicos no formato .Y. ou .N.
• $ : exibe $ antes de números
• * : exibe * antes de números
• . (ponto): estabelece a posição do ponto decimal
• , (vírgula): estabelece a posição da vírgula

Exemplos:
@ 1,1 SAY Valor PICTURE “999,999,999.99”
@ 2,1 SAY nome PICTURE “XXXXXXXXXX”

Lendo um Dado na Tela

O comando GET
Assim como um programa deve ser capaz de exibir valores durante a sua execução, devemos
poder também fornecer valores e parâmetros ao nosso programa.
A principal forma de entrada de dados na linguagem CLIPPER é o comando GET, que possui
a seguinte forma geral:

@ linha, coluna GET variável


Como no comando SAY, podemos escolher o ponto da tela em que a leitura será feita, através
da especificação da linha e da coluna desejadas. O nome da variável que segue o comando GET
indica onde será armazenado o valor que será lido do teclado.
Este comando, entretanto, deve sempre estar associado ao comando READ para que a leitura
seja realmente efetuada. Exemplo:

Valor = 0
@ 1, 1 GET Valor
READ

O comando GET admite também uma forma mais “amistosa”, onde podemos enviar uma
mensagem antes da janela de edição informando ao usuário o que deve ser digitado naquele campo.
O formato genérico seria:

@ linha, coluna SAY “Mensagem” GET Variável

Valor = 0
@ 1,1 SAY “Entre com um número:” GET Valor
READ

Exemplo:

Nome = space(10)
Idade = 0
@1,1 say “Digite o nome do aluno:”
@1,26 get Nome
@2,1 say “Digite a sua idade:”
@2, 26 get Idade
READ

Formatação de Entrada

Embora semelhante à formatação de saída, as formatações de entrada possuem objetivas


diferentes:
• Definir qual deve ser o tamanho de cada janela de edição, definindo assim o máximo que
possa ser digitado em cada campo;
• Impedir que o usuário digite letras ou caracteres não numéricos num campo de telefone, por
exemplo;
• Impedir também a entrada de caracteres não numéricos em um campo numérico, assim
como especificar o número de casas decimais possíveis, etc.

O comando para formatação de entrada é o mesmo da formatação de saída: PICTURE.


Exemplo:
Nome = space(10)
Sal = 0
Tel = Space (9)
@ 1,1 SAY “Nome:” GET Nome PICTURE “XXXXXXXXXX”
@ 2,1 SAY “Salário:” GET Sal PICTURE “999,999,999.99”
@ 3,1 SAY “Telefone:” GET Tel PICTURE “9999-9999”
READ
A Opção VALID: Uma outra maneira de verificar a validade de um dado digitado é observar
se ele obedece a uma determinada condição ou conjunto de condições.
A opção VALID do comando GET nos permite fazer isso da seguinte forma:

@ Linha, Coluna SAY “Mensagem” GET Var PICTURE “máscara” VALID condição

Esta opção pode ser utilizada com ou sem a opção PICTURE. Exemplo:

@ 1,1 GET Valor VALID (Valor >= 500)


READ

@ 2,2 SAY “Confirma(S/N):” GET Conf PICTURE “!” VALID (Conf = “S”) .or. (Conf =
“N”)
READ

Limpando a Tela

O comando básico para limpar toda a tela do seu computador é: CLEAR

Atividade D:

1. Usando os algoritmos 5,6 e 7 da Atividade C, passe-os para a linguagem de


programação Clipper usando os comandos acima.
Capítulo IV:

Estruturas de Controle
Permitem o controle do fluxo de execução dos comandos, tornando a solução de um algoritmo
diferente da encontrada em outro algoritmo.

Estrutura de Controle Condicional:


No dia-a-dia, surge a necessidade de tomar decisões. Na lógica de programação isso também
ocorre. Para tomar uma decisão em lógica, você deve utilizar a estrutura de controle condicional.
Essa estrutura executa um ou vários comandos, desde que seja satisfeita uma condição, ou várias,
representadas por uma expressão lógica. A estrutura de controle condicional se classifica em
simples ou composta.

1. Estrutura de Controle condicional Simples:


Ela determina que, se a condição for satisfeita, será executado o comando (ou comandos) que
estiver logo após a condição e antes do fimse. Sua sintaxe é:

Se (condição) Em clipper:
Comandos
FimSe IF (Condição)
Comandos
EndIf
Exemplo:

Numero = 0
Leia (Numero)
Se (Numero > 100)
Numero = Numero + 150
FimSe
Escreva “O número é:”, Numero

Atividade E
Desenvolva em Clipper os itens a seguir:

1. Desenvolver um programa que permita a entrada de dois números e que apresente


uma mensagem dizendo qual é menor e qual é maior.
2. Desenvolver um programa que permita a entrada dos nomes e pesos de duas pessoas
e apresente os dados da pessoa mais gorda.
3. Desenvolver um programa que permita a entrada dos anos de nascimento de duas
pessoas e calcular suas idades. Apresente o nome e a idade de cada pessoa, além de mensagem
indicando qual é a mais nova.
4. Desenvolver um programa que permita a entrada de dois valores e mostrar a
diferença entre eles.
5. Desenvolver um programa que permita a entrada de um número inteiro entre 1 e
5000 e que apresente uma mensagem dizendo se este número é par ou ímpar.
2. Estrutura de Controle condicional Composta:
A estrutura de controle condicional simples possibilita a execução de comandos somente se a
condição for verdadeira. Se a condição for falsa, não se pode executar qualquer comando dentro
dessa estrutura. Para isso, existe a estrutura de controle condicional composta, ou estrutura
condicional composta, formada pela mesma estrutura da condicional simples, acrescida da cláusula
Senão após o último comando da condição verdadeira. Sua sintaxe é representada por:

Se (condição) Em clipper:
Comandos
IF (Condição)
Senão Comandos
Comandos Else
FimSe Comandos

EndIf

A outra estrutura de controle condicional é o “Caso” ou Do Case. Esta estrutura é usada


quando temos uma quantidade considerável de situações e será necessário prever todas elas; O que
ficaria extremamente extenso com a estrutura Se.
Sua sintaxe:
Faça Caso Em Clipper:
Caso Variável = valor1 Do Case
Comandos ... Case Variável = valor1
Caso Variável = valor2 Comandos ...
Comandos ... Case Variável = valor2
Comandos ...

Caso Contrário Otherwise


Comandos ... Comandos ...
Fim Casos EndCase

Exemplo:

Mês = 0 Mês = 0
Leia “Qual o mês:”, Mês Leia “Qual o mês:”, Mês
Se Mês = 1 Faça Caso
Mostrar (“Janeiro”) Caso Mês = 1
Fimse Mostrar (“Janeiro”)
Se Mês = 2 Caso Mês = 2
Mostrar (“Fevereiro”) Mostrar (“Fevereiro”)
Fimse Caso Mês = 3
Se Mês = 3 Mostrar (“Março”)
Mostrar (“Março”) ...
Fimse Caso Mês = 12
... Mostrar (“Dezembro”)
Se Mês = 12 CasoContrário
Mostrar (“Dezembro”) Mostrar (“Mês inválido”)
Fimse FimCasos
Atividade F

Desenvolva em Clipper os itens a seguir:

1) Desenvolver um programa que permita a entrada de três números inteiros entre 1 e 300.
Apresente qual deles é o maior e qual é o menor.
2) Desenvolver um programa que permita a entrada de dois valores, um deles deve ser o salário de
um funcionário qualquer, o outro deve ser o sexo do funcionário.Confeccione uma rotina que
calcule um reajuste salarial de 25% sobre o salário digitado para funcionários do sexo feminino
e de 23% para funcionários do sexo masculino.Apresente o salário atualizado.
3) Desenvolver um programa que permita a entrada do nome do aluno, três notas do aluno e que
calcule a média aritmética das notas e que verifique se o aluno foi aprovado (média maior ou
igual a 7,0). Apresentar á média calculada e mensagem dizendo se o aluno foi aprovado ou não.
4) Desenvolver um programa que permita a entrada de um valor qualquer e que verifique:
a) Se o valor for maior do que 5.000,00; retire 10% do mesmo e apresente o resultado;
b) Se o valor for entre 4.200,00 e 5.000,00; acrescente 4% e apresente o resultado;
c) Se o valor for entre 2.000,00 e 4.1999,99; acrescente 12% e apresente o resultado;
d) Se o valor for entre 1.000,00 e 1.999,99; acrescente 23% e apresente o resultado.
e) Se o valor for menor do que 1.000,00; acrescente 35% e apresente o resultado.

5) Desenvolver um programa que receba o pedido de um cliente de fast food, baseado no menu
abaixo, e que permite entrar com a opção e qtdades desejadas, calcule o valor consumido de
cada item e apresente o total geral consumido.
Opção (única) Promoção Especificação Preço(R$)
2 hambúrgueres, queijo, batata frita e
1 Big Super Sanduba 5,00
refrigerante
2 Quase Super Sanduba 1 hamburguer, batata frita e refrigerante 3,00
3 Mirradus Sanduba 1 misto quente e refrigerante 2,00

6) Desenvolver um programa que permita a entrada de uma quantidade de produtos vendidos e


calcule a comissão dos funcionários, conforme abaixo:
A empresa paga a seus funcionários R$ 1,00 de comissão para cada produto vendido, entretanto, se
forem vendidos mais de 250 produtos, o valor aumenta para R$ 1,50. Se a quantidade for superior a
500 produtos, o valor da comissão sobe para R$ 2,00. Apresente o nome do funcionário e o total de
comissão que ele vai receber.
Capítulo V:

Estruturas de Controle de Repetição

Repetindo Ações:

Às vezes é necessário repetir a mesma tarefa para se chegar a um resultado final. Por
exemplo, para encher uma caixa, você coloca dentro dela um objeto e verifica. Se constatar que a
caixa ainda não está cheia, coloca mais um objeto. A ação se repetirá até você atingir o objetivo:
encher a caixa. Quando isso acontecer, você vai parar de colocar objetos nela.
Para repetir tarefas no algoritmo, evitando escrever várias vezes a mesma coisa, você pode
utilizar a estrutura de controle de repetição, ou estrutura de repetição.
Sua sintaxe é:

Enquanto (condição) faça Em Clipper:


Comando1 Do While (condição)
Comando2 Comando1
Comando3 Comando2
... Comando3
Fim enquanto EndDo

Ao contrário do comando Enquanto, em que não sabemos a priori quantas vezes um laço será
executado, o comando Para possibilita a construção de estruturas de repetição com um número
determinado de repetições, sem o controle de qualquer condição. Sua sintaxe é:

PARA variável := início TO fim STEP incremento Em Clipper:


Comando FOR variável := início TO fim STEP incremento
Comando Comando
... Comando
PRÓXIMO ...
NEXT

Exemplos:

N1 = 0 Receita = 0
N2 = 0 Despesa = 0
M=0 Total = 0
Continua = “S” Lucro = 0
Enquanto (Continua = “S”) faça Para Dia := 1 to 5
Ler “1º nº:”, N1 Ler “digite a receita:”, Receita
Ler “2º nº:”, N2 Ler “digite a despesa:”, Despesa
M = (N1 + N2) / 2 Lucro = (Receita – Despesa)
Mostrar ( M ) Total = Total + Lucro
Ler “Continuar (S/N):”, continua Próximo
Fim enquanto Mostrar (Total)
Atividade G
Desenvolva em Clipper os itens a seguir:
1) Desenvolver um programa que apresente a tabuada dos números 3, 4, 5, 6, 7,9.
2) Desenvolver um programa que permita a entrada de um número e apresente os números
pares entre 100 e 1.
3) Desenvolver um programa que permita somar os números de 1 a 10, apresentando as somas
parciais e, no final, o total.
4) Desenvolver um programa que simule o jogo de adivinhação: o jogador 1 escolhe um
número entre 1 e 10; o jogador 2 insere números na tentativa de acertar o número escolhido pelo jogador 1.
Quando ele acertar, o programa deve informar que ele acertou o número x (escolhido pelo jogador 1) em x
tentativas (quantidade de tentativas do jogador 2).
5) Desenvolver um programa que permita cadastrar os dados de vários professores de um
sistema de administração escolar: nome, endereço, cidade, Of, Cep, telefone, Cpf, Rg, data de nascimento,
grau de escolaridade, curso em que se formou.
6) Desenvolver um programa que permita cadastrar os dados das disciplinas de uma escola:
nome, descrição do conteúdo, freqüência e nota mínima para aprovação do aluno.
7) Na declaração de imposto de renda devem constar os dados: nome do contribuinte, Cpf,
renda anual e número de dependentes. Desenvolva um programa que permita a entrada dos dados citados
anteriormente e que calcule o imposto a ser pago por um número indeterminado de contribuintes conforme
informações abaixo.
a) Desconto de R$ 110,00 por dependente.
b) Com base na renda líquida (renda anual menos descontos) é calculada a alíquota de
contribuição de acordo com a tabela:
Renda líquida Alíquota (%)
Até R$ 900,00 Isento
De R$ 901,00 até R$ 5.000,00 5
De R$ 5001,00 até R$ 10.000,00 10
Acima de R$ 10.001,00 15

8) Uma empresa decidiu fazer um recrutamento para preencher algumas vagas. Os candidatos
serão cadastrados por computador. Faça um programa que permita cadastrar o número do candidato, a idade,
o sexo, a experiência profissional (Sim/Não) e apresente:
a) idade média dos candidatos;
b) número total de candidatos e candidatas;
c) candidatos (homens e mulheres) maiores de idade que tenham experiência no serviço.

Capítulo VII:

Alguns Comandos e Funções de Formatação de Tela

1. LOG()
Propósito: Retorna o logaritmo natural (base e) de um número, ou do resultado de uma
<expressão numérica>.
Sintaxe: LOG(<expressão numérica>)

Argumentos:
<expressão numérica>: é um número maior que zero do qual se deseja determinar o logaritmo
natural. O logarítimo natural tem a base e (número de Neper= 2,7193). A função LOG() retorna o
expoente (x) da seguinte equação:
ex = y
y é o valor da expressão numérica usada como argumento da função LOG(); y deve sempre
ser maior que zero.
A função LOG() retorna o inverso da função EXP().
Se o número definido pela <expressão numérica> for menor ou igual a zero serão retornados
asteriscos, indicando estouro do número (“Numeric Overflow”).

Exemplo:

? LOG(2.71828) && RETORNA 1.00000


X = 10
Y = 3.5
? LOG(X * Y) && RETORNA 3.56

2. MOD()
Propósito: Retorna um número representando o resto da divisão da <expressão
numérica1> pela <expressão numérica 2>.
Sintaxe: MOD(< expressão numérica1>),(<expressão numérica2l>)

Argumentos:
<expressão numérica1>: define o quociente da divisão
<expressão numérica2>: define o divisor.
Nota: a função MOD() foi incluída na biblioteca do clipper para aumentar sua compatilibilidade
com o DBASE III Plus que a possui. Na verdade no Clipper utiliza-se o operador “%” que também
retorna o resto da divisão de dois números.
Exemplo:

? MOD(14,12) && OU 14%12 RESULTA 2


? MOD(4,2) && OU 4%2 RESULTA 0
? MOD(1,-3) && OU 1%-3 RESULTA -2
? MOD(-4,-3) && OU –4%-3 RESUKTA -1

3. SQRT()
Propósito: Retorna a raíz quadrada de um número positivo, especificado pela expressão
numérica.
Sintaxe: SQTR(< expressão numérica>)

Argumentos:
<expressão numérica>: define o valor numérico sobre o qual será calculada e retornada a raiz
quadrada. Deve ser obrigatoriamente um número positivo.

Exemplo:

? SQRT(4) && RETORNA 2.00

4. @... BOX

Propósito: Construir um box (caixa) na tela.


Sintaxe:@ <Lin inicial>,<Col inicial>, <Lin final>, <Col final>, BOX <Cadeia>
Exemplo:

@ 00,00,03,39 BOX CHR(177)


@ 00,40,03,79 BOX CHR(178)

5. @ . . . CLEAR
Propósito: Apagar (limpar) apenas uma área específica da tela.
Sintaxe:@ <Lin. inicial>, <Col.inicial> CLEAR ΤΟ <Lin final>,<Col final>

Exemplo:

@ 10,10 CLEAR TO 20,20 / / limpa uma região da


tela

6. @. . . TO
Propósito:Desenha um quadro (moldura) a partir de coordenadas específicas da tela.
Sintaxe:@ <linhaI> ,<colunaI> TO <linhaF>,<colunaF> [DOUBLE]

Exemplo:

SET COLOR TO B+/N


@ 10,10 CLEAR TO 20,20
@ 10,10 TO 20,20 DOUBLE

7. SET CENTURY
Propósito: Possibilita configurar os dígitos dos séculos das datas.
Sintaxe: SET CENTURY ON|OFF|<(.T.)/(.F.)>

Exemplo:
SET DATE TO BRIT // escolher o formato da data
? date( ) // resultado: DD/MM/AA
SET CENTURY ON // configura as datas para quatro
// dígitos no ANO
? date( ) // resultado: DD/MM/AAAA
SET CENTURY OFF // retorna ao padrão

8. SET COLOR
Propósito: Definir as cores que serão exibidas na tela.
Sintaxe: SET COLOR TO [<padrão>,<destaque>,<borda>,<fundo>,<não
selecionado>]

SET COLOR TO W+*/R,N/W,N,,G/B

Exemplo:
VNOME := SPACE(30)
PADRAO1 := “W/N, N/N”
PADRAO2 := “B/N, N/W”
SET COLOR TO (PADRAO1)
@ 10,10 SAY “DIGITE O NOME...:” GET VNOME PICTURE “@!”
SET COLOR TO (PADRAO2)
READ
SET COLOR TO W+,B
? “VOCÊ DIGITOU O NOME...:”
?? VNOME

Tabela de Cores e Atributos


Cor Letra Número
Preto N 0
Azul B 1
Verde G 2
Palha BG 3
Vermelho R 4
Magenta RB 5
Marron GR 6
Branco W 7
Cinza N+
Amarelo GR+
Ausente X
Sublinhado U
Inverso I
+ Alta Intensidade
* Piscante

9. SET DELIMITERS
Propósito: Ativar ou desativar a edição de caracteres que serão utilizados como
delimitadores de GET’s.
Sintaxe: SET DELIMITERS ON|OFF|(.T.)/(.F.)

10. SET DELIMITER TO


Propósito: Define delimitadores para edições GET’s.
Sintaxe: SET DELIMITERS TO <delimitadores> [DEFAULT]

Exemplo:

CLEAR
VNOME:= VENDERECO:= SPACE(30)
SET DELIMITER ON // liga a edição de delimitadores
SET DELIMITER TO “::” // estabelece novos delimitadores
@ 10,10 SAY “DIGITE O NOME...:” GET VNOME
SET DELIMITER TO “[]” // muda os delimitadores novamente
@ 12,10 SAY “DIGITE O ENDEREÇO..:” GET VENDERECO
READ

11. SET WRAP


Propósito: Liga ou desliga a rolagem da barra entre extremos do menu montado
pelo comando @. . . PROMPT.
Sintaxe: SET WRAP ON|OFF|(.T.)/(.F.)

12. ALERT( )
Propósito: Criar uma caixa de diálogo simples com o usuário.
Sintaxe: ALERT (<mensagem string>).
Exemplo: ALERT (“Data Inválida”)

13. CTOD( )
Propósito: Transformar uma expressão caractere em uma data.
Sintaxe: CTOD(<expressão>).

Exemplo:
VARDATA:= CTOD(“ / / “) // cria uma variável do tipo data em branco.

14. DATE( )
Propósto: Retornar a data do sistema operacional.
Sintaxe: DATE( ).

Exemplo:

? DATE( ) // mostra a data do sistema


VARDATA := DATE( ) // cria uma variável contendo a data do
// sistema, sendo que o tipo da variável
// será D.
? DATE( ) + 4 // mostra a data do sistema + 4 dias

15. SET DATE


Propósto: Permite a determinação do formato de entrada e apresentação das expressões
que retornam datas ou de variáveis e campos tipo data.
Sintaxe: SET DATE BRITISH/ANSI/ITALIAN/FRENCH/GERMAN/AMERICAN

AMERICAN = mes/dia/ano
ANSI = ano.mes.dia
BRITISH = dia/mes/ano
ITALIAN = dia-mes-ano
FRENCH = dia/mês/ano
GERMAN = dia.mes.ano

Exemplo:
? DATE( )
01/19/88
SET DATE BRITISH
?DATE( )
19/01/88

16. DTOC( )
Propósito: Converter um valor data para uma expressão caractere.
Sintaxe: DTOC(<data>).

Exemplo:

? DATE( ) mostra a data de hoje (sistema)


? “DATA DE HOJE É..:” + DTOC(DATE( )) // mostra a data,
no
// formato de expressão caractere, concatenado em conjunto
// com uma cadeia de caracteres.

17. OUTRAS FUNÇÕES:


DTOS(data): Converte uma data em string no formato <ANOMESDIA>
STR(numero): Transforma um número em string.
STRZERO(): Obriga uso de zeros à esquerda.
VAL(string): Transforma uma string numérica em um número.
RECNO(): Retorna número do registro atual do banco de dados.
LASTKEY(): Retorna o código da última tecla pressionada.
INKEY(segundos):Aguarda um tempo especificado em segundos ou até que uma tecla seja
pressionada.
REPLICATE(): Replica uma expressão específica várias vezes.
TIME(): Retorna a hora atual do sistema.
SUBSTR(): Extrai uma parte específica (subcadeia) de uma cadeia de caracteres.
TONE(): Faz soar o alto-falante do equipamento de acordo com a freqüência e tempo
especificados.

Obs.: Pegar com os professores a apostila de funções. (Opcional)


Atividade H
1) Responda qual o resultado das seguintes funções do Clipper, sabendo-se que as
configurações de ambiente são as seguintes:
SET DATE BRITISH
SET CENTURY ON

E sabendo-se que a data atual é a seguinte: 18/04/2002

a) xdat=date();
dtoc(xdat) ?

b) dtos(xdat) ?

c) substr(dtos(xdat),1,4) ?

d) substr(dtoc(xdat),3,1) ?

e) str(val(str(val(substr(dtos(xdat),7,2))))) ?

f) substr(str(val(substr(dtoc(xdat),4,2)),2,0),1,2) ?

g) ctod(dtoc(xdat)) ?

h) dtos(ctod(dtoc(xdat)))?

i) xvar= ´AULA DE LINGUAGEM DE PROGRAMACAO´


val(substr(xvar,1,2)) ?

j) subtr(xvar,9,9) ?

k) str(xvar) ?

l) substr(xvar,22,3) ?

m) substr(dtoc(xvar),1,2) ?

n) xvalor=1200
str(valor) ?

o) substr(str(xvalor(,3,2) ?

p) val(str(val(str(xvalor)))) ?
Capítulo VII:

Usando um Banco de Dados

Criação de Banco de Dados


O Clipper é uma linguagem voltada para a utilização de banco de dados. Portanto, para a
maioria dos seus programas em Clipper você terá um ou mais bancos de dados associados ao seu
programa.
Antes de utilizarmos um banco de dados em nosso programa, devemos definir a estrutura
deste banco (ou seja, definir quais são os seus campos, qual o tamanho e o tipo de cada um), o que
geralmente é feito por um utilitário do Clipper chamado DBU. Com este programa, podemos não só
criar a estrutura de um novo banco de dados como também modificar a estrutura de um banco já
existente ou até mesmo incluir, excluir, consultar e alterar dados de qualquer banco de dados.
Depois de criado pelo DBU, um banco de dados está pronto para ser usado por um programa em
Clipper.

1. Comando USE
Em primeiro lugar, um banco de dados deve ser colocado em uso. Isto significa que devemos
“avisar”ao compilador que pretendemos utilizar os dados daquele nosso arquivo para que ele possa
tomar uma série de atitudes internas e tornar as informações disponíveis.
Em Clipper, o comando que abre um banco de dados é o comando USE, que, na sua forma
mais simples, é usado:
USE <nome do banco de dados>.
USE CADASTRO

2. Movimentação de Ponteiro

O registro com o qual estamos trabalhando em um dados instante é chamado de registro


corrente, e quem determina qual o registro corrente do banco de dados é o ponteiro de registro.
Portanto, mudando a posição do ponteiro de registro podemos mudar o registro corrente e, com isso,
percorrer todos os registros de um bando de dados. São

a) GO número ou GOTO número: como os registros de um banco de dados são


numerados, podemos posicionar o ponteiro diretamente no registro desejado especificando um
número, podendo variar de 1 (primeiro registro) até o número total de registros do banco;
Exemplo: GO 10 ou GOTO 35

b) GO TOP: posiciona o ponteiro no primeiro registro do banco de dados;


c) GO BOTTOM: posiciona o ponteiro no último registro do banco de dados;
d) SKIP número: salta um número especificado de posições a partir da posição atual do
ponteiro, podendo ir para registros posteriores (número positivo) ou registros anteriores (número
negativo).

Exemplo: GO TOP
SKIP 10
SKIP –3
SKIP
e) APPEND BLANK: incluir um registro em branco. Isto é feito com o comando
APPEND BLANK, que inclui um novo registro em branco (com campos não preenchidos) no final
do banco de dados em uso.
f) REPLACE: preencher os campos deste registro com os dados corretos. O
comando que nos permite incluir (ou modificar) o valor de um campo de banco de dados tem a
forma geral abaixo:

REPLACE campo1 WITH valor

Criar um arquivo e um programa para seu preenchimento


Arquivo:CADASTRO
Campos: Tipo: Tamanho:
Nome Caracter 30
Endereco Caracter 40
Telefone Caracter 9
Data_Nasc Data 8
Salario Numérico 9.2

Um exemplo simples de programa para incluir registros neste arquivo poderia ser feito como
indicado a seguir:

*** Exemplo de Inclusão

CLEAR
USE Cadastro
Cont = “S”
DO WHILE Cont = “S”
Vnome = Space(30)
Vend = Space(40)
Vtel = Space(9)
Vdtnasc = CTOD( “__/__/__”)
Vsal = 0
Conf = Space(1)
@ 1, 1 Say “Nome:” Get Vnome Picture “@S30”
@ 2, 1 Say “Endereço:“ Get Vend Picture “@S40”
@ 3, 1 Say “Telefone:” Get Vtel Picture “9999-9999”
@ 4, 1 Say “Data Nascimento:” Get Vdtnasc
@ 5, 1 Say “Salario:” Get Vsat Picture “99,999.99”
@6,1 Say “Confirma Inclusão (S/N):”Get Conf Picture “! “ Valid (Conf=”S”) .or.
(Conf=”N”)
READ
IF Conf = “S”
APPEND BLANK
REPLACE Nome WITH Vnome
REPLACE Endereco WITH Vend
REPLACE Telefone WITH Vtel
REPLACE Data_Nasc WITH Vdtnasc
REPLACE Salario WITH Vsal
ENDIF
@7,1 Say “Continua Cadastro (S/N):“ Get Cont Picture “!” Valid (Cont=”S”) .or.
(Cont=”N”)
READ
ENDDO

Excluir um registro

Por uma questão de segurança o Clipper proporciona a exclusão de registros em duas etapas.
A primeira é a exclusão lógica do registro, onde movimentamos o ponteiro até o registro
desejado e o marcamos para exclusão. Isto significa que ele será ignorado para futuras consultas ou
outras operações, mas ainda estará presente em seu disco caso você mude de idéia e queira tê-lo de
volta. O caminho utilizado pra marcar um registro para exclusão é:
DELETE
Este comando marca o registro atual para exclusão.
Entretanto, muitas vezes temos a certeza de que não precisamos mais dos registros que estão
marcados para exclusão e queremos eliminá-los definitivamente do banco de dados. Esta etapa é a
exclusão física de um registro. Depois que um registro ou grupo de registros foram eliminados
fisicamente, não é mais possível recuperá-los . Portanto, tome cuidado ao tomar esta decisão. O
comando que remove todos os registros marcados para exclusão é: PACK. Exemplo:

USE ESTOQUE
DELETE
SKIP
DELETE
SKIP
DELETE
PACK
Ou, de uma forma mais inteligente:
USE ESTOQUE
DELETE NEXT 3
PACK

O último comando para exclusão de registros é o mais perigoso de todos. O comando ZAP
elimina fisicamente TODOS os registros do banco de dados em uso, sem possibilidade de
recuperação. Portanto, todo cuidado é pouco!

Áreas de Trabalho
Mencionamos anteriormente que podemos trabalhar com uma grande quantidade de bancos de
dados abertos simultaneamente em nossos programas. Entretanto, se tentarmos fazer algo como:

USE BANCO1
USE BANCO2
Descobriríamos que a abertura do Banco2 causaria o fechamento do Banco1. A solução é que
podemos subdividir o nosso espaço de trabalho através da mudança da área de trablho, utilizando o
comando SELECT:
SELECT número ou SELECT Alias
Podemos escolher qualquer número entre 0 e 250 para uma área de trabalho, ou então utilizar
diretamente o ALIAS de um arquivo aberto em outra área para fazer desta a área corrente.
Então, mesmo que só possamos abrir um banco de dados em cada área, podemos trabalhar
com múltiplos bancos abrindo um deles em cada área de trabalho. Exemplo:

SELECT 1
USE Arq1
SELECT 2
USE Arq2
SELECT 3
USE Arq3

BASE DE DADOS DO SISTEMA

CLIENTE.DBF
Campos: Tipo: Tamanho:
CODIGO Caracter 06
NOME Caracter 40
ENDERECO Caracter 40
BAIRRO Caracter 30
CIDADE Caracter 30
ESTADO Caracter 02
CEP Caracter 08
TELEFONE Caracter 10
NASCIMENTO Data 08

Exemplo de programas/sistema mais elaborado:

*MENU
CLEAR
SET DATE BRIT
SET CENTURY ON
SET PROCEDURE TO PROC
SET FUNC 10 TO "?;"
SET WRAP ON
SAVE SCREEN TO TELMENU
DO WHILE .T.
RESTORE SCREEN FROM TELMENU
OP=1
@ 03,03 TO 09,15 DOUBLE
@ 04,04 PROMPT "INCLUSAO "
@ 05,04 PROMPT "ALTERACAO"
@ 06,04 PROMPT "CONSULTA "
@ 07,04 PROMPT "EXCLUSAO "
@ 08,04 PROMPT "RELATORIO"
MENU TO OP
IF LASTKEY()=27
EXIT
ENDIF
DO CASE
CASE OP=1
DO INCCLI
CASE OP=2
DO ALTCLI
CASE OP=3
DO CONCLI
CASE OP=4
DO EXCCLI
ENDCASE
ENDDO
CLEAR
RETURN

*INCLUSAO DE CLIENTES
CLEAR
SELE 1
USE CLIENTES
IF !FILE('INDCOD.NTX')
INDEX ON CODIGO TO INDCOD
ENDIF
IF !FILE('INDNOM.NTX')
INDEX ON NOME TO INDNOM
ENDIF
SET INDEX TO INDCOD,INDNOM
SAVE SCREEN TO TELCLI
DO WHILE .T.
RESTORE SCREEN FROM TELCLI
XCOD=SPACE(6)
XNOM=SPACE(40)
XEND=SPACE(40)
XBAI=SPACE(30)
XCID=SPACE(30)
XEST=SPACE(2)
XCEP=SPACE(8)
XTEL=SPACE(10)
XNAS=CTOD(' / / ')
@ 03,05 SAY 'CODIGO.....: 'GET XCOD VALID SEARCH1(1,'XCOD',03,19)
READ
IF LASTKEY()=27
EXIT
ENDIF
SELE 1
SEEK XCOD
IF FOUND()
TONE(500,3)
@ 22,15 SAY 'CODIGO JA CADASTRADO ! FAVOR DIGITAR NOVAMENTE !'
INKEY(0)
@ 22,15 SAY SPACE(50)
LOOP
ENDIF
@ 04,05 SAY 'NOME.......: 'GET XNOM PICT '@!' VALID XNOM <>SPACE(40)
@ 05,05 SAY 'ENDERECO...: 'GET XEND PICT '@!'
@ 06,05 SAY 'BAIRRO.....: 'GET XBAI PICT '@!'
@ 07,05 SAY 'CIDADE.....: 'GET XCID PICT '@!'
@ 08,05 SAY 'ESTADO.....: 'GET XEST PICT '@!'
@ 09,05 SAY 'CEP........: '
@ 09,19 GET XCEP PICT '@R 99.999-999'
@ 10,05 SAY 'TELEFONE...: '
@ 10,19 GET XTEL PICT '@R (99) 9999-9999'
@ 11,05 SAY 'NASCIMENTO.: 'GET XNAS VALID DTOS(XNAS)<>SPACE(8)
READ
IF LASTKEY()=27
LOOP
ENDIF
CONF='S'
@ 22,15 SAY 'CONFIRMA INCLUSAO (S/N) ? 'GET CONF PICT '@!' VALID CONF $ 'SN'
READ
@ 22,15 SAY SPACE(60)
IF CONF='N'.OR. LASTKEY()=27
LOOP
ENDIF
SELE 1
APPEND BLANK
REPLACE CODIGO WITH XCOD
REPLACE NOME WITH XNOM
REPLACE ENDERECO WITH XEND
REPLACE BAIRRO WITH XBAI
REPLACE CIDADE WITH XCID
REPLACE ESTADO WITH XEST
REPLACE CEP WITH XCEP
REPLACE TELEFONE WITH XTEL
REPLACE NASCIMENTO WITH XNAS
ENDDO
CLOSE ALL
CLEAR
RETURN

*ALTERACAO DE CLIENTES
CLEAR
SELE 1
USE CLIENTES
IF !FILE('INDCOD.NTX')
INDEX ON CODIGO TO INDCOD
ENDIF
IF !FILE('INDNOM.NTX')
INDEX ON NOME TO INDNOM
ENDIF
SET INDEX TO INDCOD,INDNOM
SAVE SCREEN TO TELCLI
DO WHILE .T.
RESTORE SCREEN FROM TELCLI
XCOD=SPACE(6)
@ 03,05 SAY 'CODIGO.....: 'GET XCOD VALID
SEARCH(1,'XCOD','CODIGO','NOME',03,19,04,40,.F.)
READ
IF LASTKEY()=27
EXIT
ENDIF

XNOM=NOME
XEND=ENDERECO
XBAI=BAIRRO
XCID=CIDADE
XEST=ESTADO
XCEP=CEP
XTEL=TELEFONE
XNAS=NASCIMENTO

@ 04,05 SAY 'NOME.......: 'GET XNOM PICT '@!' VALID XNOM <>SPACE(40)
@ 05,05 SAY 'ENDERECO...: 'GET XEND PICT '@!'
@ 06,05 SAY 'BAIRRO.....: 'GET XBAI PICT '@!'
@ 07,05 SAY 'CIDADE.....: 'GET XCID PICT '@!'
@ 08,05 SAY 'ESTADO.....: 'GET XEST PICT '@!'
@ 09,05 SAY 'CEP........: '
@ 09,19 GET XCEP PICT '@R 99.999-999'
@ 10,05 SAY 'TELEFONE...: '
@ 10,19 GET XTEL PICT '@R (99) 9999-9999'
@ 11,05 SAY 'NASCIMENTO.: 'GET XNAS VALID DTOS(XNAS)<>SPACE(8)
READ
IF LASTKEY()=27
LOOP
ENDIF
CONF='S'
@ 22,15 SAY 'CONFIRMA ALTERACAO (S/N) ? 'GET CONF PICT '@!' VALID CONF $ 'SN'
READ
@ 22,15 SAY SPACE(60)
IF CONF='N'.OR. LASTKEY()=27
LOOP
ENDIF
SELE 1
REPLACE NOME WITH XNOM
REPLACE ENDERECO WITH XEND
REPLACE BAIRRO WITH XBAI
REPLACE CIDADE WITH XCID
REPLACE ESTADO WITH XEST
REPLACE CEP WITH XCEP
REPLACE TELEFONE WITH XTEL
REPLACE NASCIMENTO WITH XNAS
ENDDO
CLOSE ALL
CLEAR
RETURN

*CONSULTA DE CLIENTES
CLEAR
SELE 1
USE CLIENTES
IF !FILE('INDCOD.NTX')
INDEX ON CODIGO TO INDCOD
ENDIF
IF !FILE('INDNOM.NTX')
INDEX ON NOME TO INDNOM
ENDIF
SET INDEX TO INDCOD,INDNOM
SAVE SCREEN TO TELCLI
DO WHILE .T.
RESTORE SCREEN FROM TELCLI
XCOD=SPACE(6)
@ 03,05 SAY 'CODIGO.....: 'GET XCOD VALID
SEARCH(1,'XCOD','CODIGO','NOME',03,19,04,40,.T.)
READ
IF LASTKEY()=27
EXIT
ENDIF

@ 04,05 SAY 'NOME.......: '+NOME


@ 05,05 SAY 'ENDERECO...: '+ENDERECO
@ 06,05 SAY 'BAIRRO.....: '+BAIRRO
@ 07,05 SAY 'CIDADE.....: '+CIDADE
@ 08,05 SAY 'ESTADO.....: '+ESTADO
@ 09,05 SAY 'CEP........: '
@ 09,19 SAY CEP PICT '@R 99.999-999'
@ 10,05 SAY 'TELEFONE...: '
@ 10,19 SAY TELEFONE PICT '@R (99) 9999-9999'
@ 11,05 SAY 'NASCIMENTO.: '+DTOC(NASCIMENTO)
INKEY(0)
ENDDO
CLOSE ALL
CLEAR
RETURN

*EXCLUSAO DE CLIENTES
CLEAR
SELE 1
USE CLIENTES
IF !FILE('INDCOD.NTX')
INDEX ON CODIGO TO INDCOD
ENDIF
IF !FILE('INDNOM.NTX')
INDEX ON NOME TO INDNOM
ENDIF
SET INDEX TO INDCOD,INDNOM
SAVE SCREEN TO TELCLI
DO WHILE .T.
RESTORE SCREEN FROM TELCLI
XCOD=SPACE(6)
@ 03,05 SAY 'CODIGO.....: 'GET XCOD VALID
SEARCH(1,'XCOD','CODIGO','NOME',03,19,04,40,.T.)
READ
IF LASTKEY()=27
EXIT
ENDIF

@ 04,05 SAY 'NOME.......: '+NOME


@ 05,05 SAY 'ENDERECO...: '+ENDERECO
@ 06,05 SAY 'BAIRRO.....: '+BAIRRO
@ 07,05 SAY 'CIDADE.....: '+CIDADE
@ 08,05 SAY 'ESTADO.....: '+ESTADO
@ 09,05 SAY 'CEP........: '
@ 09,19 SAY CEP PICT '@R 99.999-999'
@ 10,05 SAY 'TELEFONE...: '
@ 10,19 SAY TELEFONE PICT '@R (99) 9999-9999'
@ 11,05 SAY 'NASCIMENTO.: '+DTOC(NASCIMENTO)
READ
IF LASTKEY()=27
LOOP
ENDIF
CONF='N'
@ 22,15 SAY 'CONFIRMA EXCLUSAO (S/N) ? 'GET CONF PICT '@!' VALID CONF $ 'SN'
READ
@ 22,15 SAY SPACE(60)
IF CONF='N'.OR. LASTKEY()=27
LOOP
ENDIF
SELE 1
DELETE RECORD RECNO()
*PACK
ENDDO
CLOSE ALL
CLEAR
RETURN

*RELATORIO DE CLIENTES EM ORDEM DE CODIGO


CLEAR
SAVE SCREEN TO TELCLI
DO WHILE .T.
RESTORE SCREEN FROM TELCLI
XINI=SPACE(6)
XFIM=SPACE(6)
@ 10,10 SAY 'CODIGO INICIAL..:'GET XINI PICT '999999' VALID VAL(XINI)>0
@ 12,10 SAY 'CODIGO FINAL....:'GET XFIM PICT '999999' VALID XFIM >= XINI
READ
IF LASTKEY()=27
EXIT
ENDIF
SELE 1
SET SOFTSEEK ON
SEEK XINI
SET SOFTSEEK OFF
SET DEVICE TO PRINT
* SET PRINTER TO LPT1
SET PRINTER TO ARQ1.TXT
PAG=0
DO WHILE !EOF() .AND. CODIGO <=XFIM
PAG=PAG+1
@ PROW() ,20 SAY 'RELATORIO DE CLIENTES EM ORDEM DE CODIGO'
@ PROW()+01,00 SAY REPLICATE('-',80)
@ PROW()+01,00 SAY 'EMISSAO :'+DTOC(DATE())
@ PROW() ,70 SAY 'PAG: '+STRZERO(PAG,3,0)
@ PROW()+01,00 SAY REPLICATE('-',80)
@ PROW()+01,00 SAY 'CODIGO NOME
ESTADO TELEFONE'
@ PROW()+01,00 SAY REPLICATE('-',80)
DO WHILE !EOF() .AND. CODIGO <=XFIM .AND. PROW()<=57
@ PROW()+01,00 SAY CODIGO+'-'+NOME+' '+ESTADO
@ PROW() ,60 SAY TELEFONE PICT '@R (99) 9999-9999'
SKIP
ENDDO
EJECT
ENDDO
SET DEVICE TO SCREEN
SET PRINTER TO
ENDDO
CLEAR
RETURN

*RELATORIO DE CLIENTES EM ORDEM DE NOME


CLEAR
SAVE SCREEN TO TELCLI
DO WHILE .T.
RESTORE SCREEN FROM TELCLI
XINI=SPACE(40)
XFIM=SPACE(40)
@ 10,10 SAY 'NOME INICIAL..:'GET XINI PICT '@!' VALID XINI<>SPACE(40)
@ 12,10 SAY 'NOME FINAL....:'GET XFIM PICT '@!' VALID XFIM >= XINI
READ
IF LASTKEY()=27
EXIT
ENDIF
SELE 1
SET ORDER TO 2
SET SOFTSEEK ON
SEEK XINI
SET SOFTSEEK OFF
SET DEVICE TO PRINT
* SET PRINTER TO LPT1
SET PRINTER TO ARQ1.TXT
PAG=0
DO WHILE !EOF() .AND. NOME <=XFIM
PAG=PAG+1
@ PROW() ,21 SAY 'RELATORIO DE CLIENTES EM ORDEM DE NOME'
@ PROW()+01,00 SAY REPLICATE('-',80)
@ PROW()+01,00 SAY 'EMISSAO :'+DTOC(DATE())
@ PROW() ,70 SAY 'PAG: '+STRZERO(PAG,3,0)
@ PROW()+01,00 SAY REPLICATE('-',80)
@ PROW()+01,00 SAY 'CODIGO NOME
ESTADO TELEFONE'
@ PROW()+01,00 SAY REPLICATE('-',80)
DO WHILE !EOF() .AND. NOME <=XFIM .AND. PROW()<=57
@ PROW()+01,00 SAY CODIGO+'-'+NOME+' '+ESTADO
@ PROW() ,60 SAY TELEFONE PICT '@R (99) 9999-9999'
SKIP
ENDDO
EJECT
ENDDO
SET DEVICE TO SCREEN
SET PRINTER TO
SELE 1
SET ORDER TO 1
ENDDO
CLEAR
RETURN

***************************************************
FUNC SEARCH
PARA A,K,C1,C2,L,C,L1,T,F
PRIV A,AR,K,C1,C2,L,L1,C,T,F
COR1=SETCOLOR()
PUBLIC TM
TM=LEN(&K)
AR=SELECT()
SELECT(A)
DO CASE
CASE LASTKEY()=27
SELECT(AR)
RETURN .T.
CASE &K='?'
GO TOP
JANELA(C1,C2)
SET ORDER TO 1
SETCOLOR(COR1)
IF LASTKEY()<>13
&K=SPACE(LEN(&C1))
SELECT(AR)
RETURN .F.
ENDIF
ENDCASE
&K=RIGHT('00000000'+TRIM(&K),LEN(&C1))
@ L,C SAY &K
SEEK &K
IF .NOT. FOUND()
@ 23,10 say "C¢digo N„o Encontrado !!!"
inkey(0)
@ 23,10 say space(60)
&K=SPACE(LEN(&C1))
SELECT(AR)
RETURN .F.
ENDIF
SETCOLOR(COR1)
IF T=0
@ L,C SAY &C1
ELSEIF L<>L1
@ L,C SAY &C1
@ L1,C SAY SUBSTR(&C2,1,T)
ELSE
@ L,C SAY &C1+'-'+SUBSTR(&C2,1,T)
ENDIF
SELECT(AR)
SET INTE ON
RETURN .T.

***************************************************
FUNC JANELA
PARA XC1,XC2
PRIV XCP[2],XCC[2],XA[2]
COR2=SETCOLOR()
SAVE SCRE TO TJ
SET INTE ON
SET COLOR TO w+/b
rodape(24,40," F3-C¢digo F4-Nome ")
@ 6,1 CLEAR TO 19,78
SET COLOR TO w+/r
@ 6,1 TO 19,78
XCP[1]=XC1
XCP[2]=XC2
XA[1]='@!'
XA[2]='@!'
XCC[1]='CODIGO'
XCC[2]='NOME'
DBEDIT(7,2,18,77,XCP,'RET',XA,XCC,CHR(196),CHR(179),CHR(196),' ')
SET ORDER TO 1
SETCOLOR(COR2)
*SET INTE OFF
REST SCREE FROM TJ
RETURN .T.
***************************************************
FUNC RET
PARA XM,XP
COR3=SETCOLOR()
DO CASE
CASE XM=1
@ 18,31 SAY 'Inicio do Arquivo'
INKEY(.5)
@ 18,31 SAY ' '
RETURN 1
CASE XM=2
@ 18,31 SAY 'Fim do Arquivo '
INKEY(.5)
@ 18,31 SAY ' '
RETURN 1
CASE XM=3
RETURN 1
CASE XM=4
DO CASE
CASE LASTKEY()=13
&K=&XC1
RETURN 0
CASE LASTKEY()=27
RETURN 0
CASE LASTKEY()=-2
SET ORDER TO 1
COR4=SETCOLOR()
SET COLOR TO w+/g
SET CONS ON
TT=SAVESCREEN(24,00,24,79)
set colo to w+/b
@ 21,01 SAY ''
ACCEPT "³Mensagem -> C¢digo..: " TO X
X=STRZERO(VAL(X),TM,0)
RESTSCREEN(24,00,24,78,TT)
SET CONS OFF
SETCOLOR(COR4)
IF LASTKEY()=27
RETURN 1
ENDIF
SET SOFT ON
SEEK X
SET SOFT OFF
RETURN 1
CASE LASTKEY()=-3
COR5=SETCOLOR()
SET COLOR TO w+/b
SET CONS ON
TT=SAVESCREEN(24,00,24,78)
set colo to w+/b
@ 21,01 SAY ''
ACCEPT "³Mensagem -> Nome..: " TO X
X=UPPER(X)
RESTSCREEN(24,00,24,78,TT)
SETCOLOR(COR5)
SET CONS OFF
IF F
SET ORDER TO 2
SET SOFT ON
SEEK X
SET SOFT OFF
ELSE
LOCATE FOR &XC2=X
ENDIF
RETURN 1
OTHER
RETURN 1
ENDCASE
OTHER
RETURN 1
ENDCASE
***************************************************
FUNC SEARCH1
PARA A,K,L,C
PRIV A,AR,K,L,C,C1
COR=SETCOLOR()
AR=SELECT()
SELECT(A)
C1=FIELDNAME(1)
DO CASE
CASE LASTKEY()=27
SELECT(AR)
RETURN .T.
CASE &K='?' .OR. &K=SPACE(LEN(&K))
&K=SPACE(LEN(&K))
SELECT(AR)
RETURN .F.
ENDCASE
&K=RIGHT('00000000'+TRIM(&K),LEN(&C1))
@ L,C SAY &K
SEEK &K
IF FOUND()
@ 23,10 say "C¢digo j Cadastrado !!!"
inkey(2)
@ 23,10 say space(60)
&K=SPACE(LEN(&C1))
SELECT(AR)
RETURN .F.
ENDIF
@ L,C SAY &K
SELECT(AR)
RETURN .T.
***************************************************
FUNC PRT
PARA A,V,C1,C2,L,C,T
PRIV A,V,L,C,C1,C2,T,AR
AR=SELECT()
SELECT(A)
SEEK &V
IF .NOT. FOUND()
@ L,C SAY &V+'-'+'CANCELADO !!! '
ELSEIF T<>0
@ L,C SAY &V+'-'+SUBSTR(&C2,1,T)
ENDIF
SELECT(AR)
RETURN .T.

***************************************************
function boxs
parameters ls,cs,li,ci,cor
v =savescreen (li+1,cs+1,li+1,ci+2)
v2=savescreen(ls+1,ci,li,ci+2)
for i = 2 to len(v) step 2
v =stuff(v,i,1,chr(8))
next
for i = 2 to len(v2) step 2
v2=stuff(v2,i,1,chr(8))
next
restscreen(ls+1,ci,li,ci+2,v2)
restscreen(li+1,cs+1,li+1,ci+2,v)
set color to &cor
@ ls,cs clear to li,ci
@ ls,cs to li,ci double
set color to
return (.t.)

FUNCTION SIGLA
PARAMETER L,C,sig
ACHOU =0
DECLARE VET[27]
VET[1]= 'AC'
VET[2]= 'AL'
VET[3]= 'AP'
VET[4]= 'AM'
VET[5]= 'BA'
VET[6]= 'CE'
VET[7]= 'DF'
VET[8]= 'ES'
VET[9]= 'GO'
VET[10] ='MA'
VET[11]= 'MT'
VET[12]= 'MS'
VET[13]= 'MG'
VET[14]= 'PA'
VET[15]= 'PB'
VET[16]= 'PR'
VET[17]= 'PE'
VET[18]= 'PI'
VET[19]= 'RN'
VET[20]= 'RS'
VET[21]= 'RJ'
VET[22]= 'RO'
VET[23]= 'RR'
VET[24]= 'SC'
VET[25]= 'SP'
VET[26]= 'SE'
VET[27]= 'TO'
DECLARE VET1[27]
VET1[1]= 'ACRE AC'
VET1[2]= 'ALAGOAS AL'
VET1[3]= 'AMAPA AP'
VET1[4]= 'AMAZONAS AM'
VET1[5]= 'BAHIA BA'
VET1[6]= 'CEARA CE'
VET1[7]= 'DISTRITO FEDERAL DF'
VET1[8]= 'ESPIRITO SANTO ES'
VET1[9]= 'GOIAS GO'
VET1[10] ='MARANHAO MA'
VET1[11]= 'MATO GROSSO MT'
VET1[12]= 'MATO GROSSO DO SUL MS'
VET1[13]= 'MINAS GERAIS MG'
VET1[14]= 'PARA PA'
VET1[15]= 'PARAIBA PB'
VET1[16]= 'PARANA PR'
VET1[17]= 'PERNAMBUCO PE'
VET1[18]= 'PIAUI PI'
VET1[19]= 'RIO GRANDE DO NORTE RN'
VET1[20]= 'RIO GRANDE DO SUL RS'
VET1[21]= 'RIO DE JANEIRO RJ'
VET1[22]= 'RONDONIA RO'
VET1[23]= 'RORAIMA RR'
VET1[24]= 'SANTA CATARINA SC'
VET1[25]= 'SAO PAULO SP'
VET1[26]= 'SERGIPE SE'
VET1[27]= 'TOCANTINS TO'
ACHOU = ASCAN(VET,&SIG)
IF ACHOU = 0
SAVE SCREEN TO TELAE
SET COLO TO w+/b
@ 05,51 TO 18,75 DOUBLE
SET COLO TO w+/b
ACHOU = ACHOICE(06,52,17,74,VET1)
RETORNA = IIF(ACHOU=0,.F.,.T.)
RESTORE SCREEN FROM TELAE
SET COLO TO w+/gb
IF ACHOU <> 0
SET COLO TO w+/gr
@ L,C SAY VET[ACHOU]
&SIG=VET[ACHOU]
ENDIF
ELSE
SET COLO TO w+/gr
@ L,C SAY VET[ACHOU]
&SIG=VET[ACHOU]
RETORNA = .T.
ENDIF
RETURN(RETORNA)

function rodape
para l,c,m
cor=setcolor()
set colo to w+/r
@ l,c say m
setcolor(cor)
retu .t.

function rodape2
para l,c,s
cor=setcolor()
set colo to
@ l,c say space(s)
setcolor(cor)
retu .t.

function funsen
set inte off
quadro(12,40,12,40,08,20,16,60,"&xcor5",xtemp,10,1," Senha de Acesso ")
xtenta=0
tone(500,3)
do while .t. .and. xtenta < 3
xsen=space(10)
set colo to x
@ 12,37 get xsen pict '@!'
read
if lastkey()=27
exit
endif
if alltrim(xsen) <> chr(49)+chr(57)+chr(48)+chr(55)+chr(57)+chr(54)
tone(500,3)
tone(800,5)
@ 23,10 say 'Senha incorreta, digite novamente !!'
inkey(0)
@ 23,10 say space(60)
xtenta=xtenta+1
else
exit
endif
enddo
if xtenta >= 3 .or. lastkey()=27
close all
set colo to
set cursor on
set inte on
release all
set colo to
resquadro(xtemp,10,1)
set inte on
retu .f.
endif
set colo to
resquadro(xtemp,10,1)
set inte on
retu .t.

function alert2
para men
save screen to telalert
cor=setcolor()
xt1=len(men)
cen=(80-len(men))/2
if (cen-2) <0
cen=0
endif
fim=cen+(len(men))+2
if fim>79
fim=79
endif
tone(500,2)
tone(800,3)
telalert=savescreen(09,00,17,79)
boxs(10,cen-2,15,fim,"w+/r")
set colo to w+/r
@ 12,cen say men
opalert=1
set inte on
@ 14,40 prompt "Ok"
menu to opalert
set inte off
restscreen(09,00,17,79,telalert)
setcolor(cor)
retu .t.

function senha
para l,c,xsen
priv xsen
xs=0
ct=1
@ l,c say ''
do while ct<=20
tk=inkey(0)
if tk=13 .or. tk=27
exit
endif
if tk<48 .and. tk>90
loop
endif
&xsen=&xsen+(tk)
@ l,c say '*'
ct=ct+1
c=c+1
enddo
&xsen=(((&xsen/2)*5)*23)/9
retu .t.

******************************************
ASC

clear
ct=1
l=0
c=0
do while ct<=255
@ l,c say ct pict '999'
@ l,c+4 say chr(ct)
c=c+8
if c>78
c=0
l=l+1
endif
if l>22
@ 24,00 say 'Digite uma tecla...'
inkey(0)
clear
l=0
c=0
endif
ct=ct+1
enddo
inkey(0)
clear
Bibliografia:
• Clipper 5.2 – Método Rápido, Editora: IBPI
• Clipper 5.2 - Ramalho, Editora: Mackron Books