2231 Clipper

Rodrigo dos Reis Lopes Bahia 1

Desenvolvimento de Software Aplicativo I

Enviado por : Rodrigo dos Reis Lopes Bahia

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

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.

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 Relacional

Operação

= 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.

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.

Porta fechada Porta fechada

Estado Inicial Estado Final

Ação: Abrir

Tempo: Segundos

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

4

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 é:

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.

Em clipper: IF (Condição) Comandos EndIf

Se (condição) Comandos FimSe

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:

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:

Exemplo:

Se (condição) Comandos Senão Comandos FimSe

Em clipper: IF (Condição) Comandos Else

Comandos EndIf

Faça Caso Caso Variável = valor1

Comandos ... Caso Variável = valor2 Comandos ... Caso Contrário Comandos ...

Fim Casos

Em Clipper: Do Case Case Variável = valor1

Comandos ... Case Variável = valor2 Comandos ... Otherwise Comandos ...

EndCase

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

Mês = 0 Leia “Qual o mês:”, Mês Se Mês = 1 Mostrar (“Janeiro”) Fimse Se Mês = 2 Mostrar (“Fevereiro”) Fimse Se Mês = 3 Mostrar (“Março”) Fimse ... Se Mês = 12 Mostrar (“Dezembro”) Fimse

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$)

1 Big Super Sanduba 2 hambúrgueres, queijo, batata frita e refrigerante

5,00

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 é: 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 é:

Exemplos:

Enquanto (condição) faça Comando1 Comando2 Comando3 ... Fim enquanto

Em Clipper: Do While (condição) Comando1 Comando2 Comando3 EndDo

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

Em Clipper: FOR variável := início TO fim STEP incremento Comando Comando ... NEXT

N1 = 0 N2 = 0 M = 0 Continua = “S” Enquanto (Continua = “S”) faça Ler “1º nº:”, N1 Ler “2º nº:”, N2 M = (N1 + N2) / 2 Mostrar ( M ) Ler “Continuar (S/N):”, continua Fim enquanto

Receita = 0 Despesa = 0 Total = 0 Lucro = 0 Para Dia := 1 to 5 Ler “digite a receita:”, Receita Ler “digite a despesa:”, Despesa Lucro = (Receita – Despesa) Total = Total + Lucro Próximo

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çõe s. (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 preenchimen to 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 SEARCH 1(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 DIG ITAR NOVAMENTE !' INKEY(0) @ 22,15 SAY SPACE(50) LOOP ENDIF @ 04,05 SAY 'NOME.......: 'GET XNOM PICT '@!' VA LID 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(X NAS)<>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 '@!' VA LID 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(X NAS)<>SPACE(8) READ IF LASTKEY()=27 LOOP ENDIF CONF='S' @ 22,15 SAY 'CONFIRMA ALTERACAO (S/N) ? 'GET CON F 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 '99 9999' VALID VAL(XINI)>0 @ 12,10 SAY 'CODIGO FINAL....:'GET XFIM PICT '99 9999' 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 O RDEM 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. PRO W()<=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 O RDEM 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)+c hr(55)+chr(57)+chr(54) tone(500,3)

tone(800,5) @ 23,10 say 'Senha incorreta, digite novam ente !!' 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

Documents

2231 Clipper