1.

Definições
1.1. Programação e Linguagens
Programar é escrever um conjunto de instruções para que o computador exe-
cute uma determinada tarefa. É similar a uma norma de procedimentos. Estas ins-
truções podem ser interativas ou fazer parte de um programa. Se interativas, a cada
comando dado pelo usuário provoca uma resposta do computador. Se programados
escreve-se um rol de instruções que serão gravadas em um arquivo, as quais serão
executadas posteriormente, ao se executar o arquivo.
Existem muitas linguagens de programação. Cada uma delas apresentam van-
tagens e são destinadas a rodar em determinadas máquinas e seus respectivos Sis-
temas Operacionais sendo adequadas para uma determinada situação.
As linguagens de programação podem ser interpretadas ou compiladas.
Quando elas são interpretadas a conversão de cada comando para o código
nativo do Hardware é feito no ato de sua execução. Neste caso o interpretador pre-
cisa estar sempre presente na memória do computador. O dBase III Plus é interpre-
tado, assim como o Access.
Já o compilador faz a tradução das instruções escritas pelo programador em
um processo autônomo gerando o que se chama de código objeto ou executável que
é carregado na memória quando de sua execução. A vantagem é que neste caso ele
roda de forma independente, sem a necessidade de um interpretador e além disso
seu processamento é muito mais rápido. É o caso do Clipper, Delphi e do Visual
C++.
Existem também os pré-compiladores que tem como maior objetivo esconder
dos usuários o programa fonte, evitando assim que o mesmo possa alterá-lo ou co-
piá-lo, pois somente o executável é disponibilizado para uso. Neste caso necessita-se
do “Run-Time”, que é um interpretador sem possibilidade de se desenvolver novas
rotinas. Em alguns casos, ainda, o interpretador é embutido no executável. É o caso
do Visual dBase, Visual Object e Clipper.
De qualquer forma, todas as linguagens de programação são similares. É o
que se vê quando se estuda mais detalhadamente cada uma delas.

1.2. Componentes do Computador.

Os computadores tem uma grande capacidade de armazenar dados. Isto é
feito nos discos rígidos, tambem conhecidos como “winchester” ou “hard-disk”.
A memória RAM é uma memória é utilizada para a operação e processamento
dos dados e não serve para armazenamento dos mesmos. Portanto não confunda a
memória RAM com a memória de massa que é o disco magnético. A memória RAM é
volátil, ou seja, apaga-se quando se desliga o computador.
Os dados no disco são organizados em arquivos. O disco pode ser dividido em
diretório (ou pastas) e estes diretórios por sua vez podem ser subdivididos em ou-
tros. Desta forma pode-se armazenar cada tipo de arquivo em determinado diretório.
Pense como pastas de documentos, onde cada tipo de documento é guardado em
determinada pasta. Nesta comparação, as pastas são os diretórios e os documentos
são os arquivos.
Os arquivos de dados também podem serem chamados de bancos de dados
ou Tabelas. Estes arquivos são compostos de Registros, também chamados de Li-
nhas. Os registros, por sua vez, são compostos de campos, também chamados de
colunas. Veja o exemplo a seguir:
 00001 Indústria e Comércio S/A São Paulo SP (011)950-4622
00002 Fabrica de Bonecos Ltda. S.B. do Campo SP (011)444-4444
00003 SAEOM Ltda. São Paulo SP (011)950-1767
00004 Computer´s S/A Curitiba PR (041)123-4567

Campos ou
Colunas Registros
ou Linhas

1.3. Outras Definições:

Informática: Estudo da informação, ciência que trata da automação das informações
Dados: Informações que se insere no computador para serem processadas e obter um
resultado ou apenas para serem armazenadas para uso posterior.
Processamento de Dados: Qualquer atividade que provoque a manipulação de dados
com o objetivo de se obter algum resultado.

2. Fluxogramas
Fluxogramas são representações gráficas de algoritmo, onde formas geomé-
tricas diferentes implicam ações (instruções e comandos) distintos.
O algoritmo é a seqüência lógica de alguma atividade ou tarefa. Por exemplo
veja o fragmento de algoritmo abaixo:
1- Armar o despertador
2 - Desligar o despertador
3 - Bocejar
4 - Sacudir a esposa
5 - Sair da Cama
.
.
n – final
 CIDS – Curso Interno para o Desenvolvimento do Suporte

Exemplo de fluxograma para o algoritmo acima...

Início A

Armar o Sim Esposa

Resmungar quer $?
despertador

Não

Desligar o
Dar-lhe $ 100
despertador
Sim
Casado +
5 anos?

Repetir Não
bocejar
3 vezes
Beijar a
esposa

Sacudir a
esposa
Casado +
1 ano?

Não
Sair da cama
Beijar a
esposa

Sim Está
Acender a luz
escuro?
Ir até o carro
Não

Voltar para a Sim Voltar para Não Está c/ as

Está frio?
cama pegá-las chaves?

Não Sim

Dirigir-se para
Ir ao banheiro
o escritório

Tomar café
Fim

3. Lógica
Lógica é a ciência que estuda as leis do raciocínio, coerência e do racional. No
âmbito da informática, lógica é um conjunto de técnicas utilizadas para a resolução
de problemas.
Para se obter uma lógica é fundamental:
• Ter bem claro as informações com que se irá trabalhar;
• Se o problema e/ou processo for grande, deve-se dividi-lo em partes menores;
• Ter bem claro os objetivos e resultados que se deseja obter.
Para a elaboração de um programa deve-se considerar fundamen-
talmente os itens acima e ainda trabalhar em etapas:
• Executar um levantamento geral das tarefas a serem programadas, identificando
os objetivos das mesmas.
• Analisar estas tarefas e os problemas decorrentes delas.
• Executar a resolução lógica destas tarefas e dos problemas.

Lógica e Conceitos Básicos de Programação - 3

 • Codificação dos Programas e Documentação Técnica
• Depuração/Testes dos programas
• Revisão e finalização da documentação.
Note que para a elaboração de um programa é necessário adotar determina-
das ferramentas para o esboço do mesmo, tais como o algoritmo, DFD, etc., depen-
dendo do grau de complexidade do programa e da experiência e prática do progra-
mador.
Além disso, deve-se ter bom senso e prática em lógica, principalmente para
identificar a melhor seqüência de processo, elaboração de fórmulas, tomadas de de-
cisões, quantas vezes o processo deve ser repetido, etc.

3.1. Seqüência do Processo

Para identificar a melhor seqüência de um processo, a melhor maneira é pen-
sar no mesmo como um todo, partindo de uma visão macro (superficial mas abran-
gente) e a partir daí ir detalhando cada etapa, ajustando as seqüências conforme
necessário.
O algoritmo bem como o fluxograma auxiliam bastante neste sentido.

3.2. Fórmulas
Fórmulas são equações que permitirão processar algumas informações para
obter outras. Em matemática, utiliza-se incógnitas e números, sendo que as incógni-
tas são os valores desconhecidos e normalmente são também as respos-
tas/informações que se deseja obter. Os números são as informações conhecidas.
Exemplo:
“Maria comeu duas maçãs e agora restam 3. Quantas maçãs existiam antes ?”
Maças existentes antes = X maçãs
Maria comeu = 2 maçãs
Restam = 3 maçãs
Fórmula:
X maças existentes - 2 maçãs comidas pela Maria = 3 maças restantes
Portanto:
X-2=3
Resolução:
X-2=3;X=3+2;X=5
Outro exemplo:
“Na compra de um determinado produto, sabe-se que o valor do mesmo é de R$
1.000,00, com ICMS de 18% embutido no valor.
1) Qual o Valor do ICMS ?
2) Qual o valor de custo deste produto ?
3) Qual a fórmula a ser adotada se para saber somente o custo do produto ?”
Questão 1: ValorICMS = ValorProduto x AlíquotaICMS
ValorICMS = 1.000,00 * 0.18
ValorICMS = 180,00
Questão 2: CustoProduto = ValorProduto - ValorICMS
CustoProduto = 1.000,00 - 180,00
 CIDS – Curso Interno para o Desenvolvimento do Suporte
CustoProduto = 820,00
Questão 3: CustoProduto = ValorProduto - ValorICMS
como Valor ICMS = ValorProduto x AliquotaICMS, por substituição:
CustoProduto = ValorProduto - (ValorProduto x AliquotaICMS)

3.3. Tomadas de Decisão com estrutura de decisão tipo Se (If)

Como já foi visto, um programa é um conjunto de instruções. Estas instruções
são colocadas de forma linear dentro do arquivo, e sua execução deve seguir uma
certa lógica. No entanto, determinadas rotinas do programa serão executadas so-
mente se as condições para sua realização estiverem satisfeita.
Exemplo: “Se for produto de estoque, alimente o estoque”; “Se produto importado,
calcule o IPI”; “Se alíquota não for zero, calcule o imposto.”.
Repare que nas condições existem um “Se”. Por isso elas são conhecidas
como “Estrutura de Decisão do tipo SE”. Em praticamente todas as linguagens de
programação, este Se é representado pelo comando If.
Nesta estrutura de condição ocorrerá um resultado verdadeiro ou falso (do in-
glês T = True ou F = False ).
Em termos de fluxograma, uma construção do tipo If será representada como
segue (dentro do quadro pontilhado), onde existem 2 caminhos que podem ser se-
guidos.

Não Calcular o
Alíquota = 0 imposto

Sim

Próximo
Processo

Na estrutura de condição para linguagens como o Clipper, dBase e Rdmake,

poderão haver ainda termos como:
ElseIf - Senão, se...
Else - Senão, ...
.And. - ... E ...
.Or. - ... ou ...
EndIf - Fim da estrutura If
“Se o evento for tipo A, desconte R$ 10,00. Senão, o evento for tipo B, desconte
R$ 20,00. Senão, o evento for tipo C ou tipo D, desconte R$ 30,00. Senão, se o evento
for tipo E e a base for maior que R$ 1.000,00 desconte R$ 40,00. Senão, desconte R$
50,00 (nenhumas das condições anteriores forem atendidas).” Veja abaixo como fica a
estrutura do tipo If:

Lógica e Conceitos Básicos de Programação - 5

 If evento = A
valor = valor - 10
ElseIf evento = B
valor = valor - 20
ElseIf evento = C .Or. evento = D
valor = valor - 30
ElseIf evento = E .And. base > 1000
valor = valor - 40
Else
valor = valor - 50
EndIf

Note que o termo Senão, se... (ElseIf) indica que as condições anteriores
não foram atendidas e que para o próximo processo ainda existe outra análise.
Já o tempo Senão (Else) indica que as condições anteriores não foram aten-
didas e que para o próximo processo não será necessária mais nenhuma análise, ou
seja, eqüivale a Se nenhuma das condições anteriores forem atendidas, exe-
cute isto.

3.4. Repetir um processo determinadas vezes (For/Next)

Analise o exemplo: “A cada 10 notas fiscais, exiba o total acumulado”
Este exemplo é atendido num programa pela estrutura For...To...Next, onde For
determina a variação de um contador, To indica quantas vezes o contador será vari-
ado e Next indica fim da estrutura:
For contador = 1 To 10
SubTotal = SubTotal + valorNF
Next

3.5. Repetir um processo enquanto uma condição for verdadeira,

ou Loop (While... Loop... Exit... EndDo)
A estrutura do tipo While...Loop...Exit...EndDo, possui ocorrências, onde:
While (do inglês “enquanto”) indica a condição “faça enquanto...”,;
Exit (do inglês “sair”) indica sair da estrutura;
Loop (do inglês “volta”) indica voltar ao inicio da estrutura;
EndDo indica fim da estrutura.
No exemplo: “Enquanto houver estoque de MP, execute a produção” a estru-
tura será:

While estoqueMP > 0

.
(processo de produção)
.
EndDo

Incrementando o exemplo: “Enquanto houver estoque de MP, execute a pro-

dução. Porém a cada 10 PA, de uma pausa de 10 minutos para depois reiniciar o
processo” a estrutura será:
 CIDS – Curso Interno para o Desenvolvimento do Suporte

ContadorDePA = 0
While estoqueMP > 0
ContadorDePA = ContadorDePA + 1

If ContadorDePA > 10
(dar uma pausa de 10 minustos)
(ContadorDePA = 0)
Loop
EndIf
.
(processo de produção)
.
EndDo

Note que foi utilizado também a estrutura do tipo If dentro do Loop.

Completando o exemplo: “Enquanto houver estoque de MP, execute a produ-
ção. Porém a cada 10 PA, de uma pausa de 10 minutos para depois continuar e se
for mais de 18:00 H, interrompa a produção. ” a estrutura será:

ContadorDePA = 0
While estoqueMP > 0
ContadorDePA = ContadorDePA + 1

If ContadorDePA > 10
(dar uma pausa de 10 minustos)
(ContadorDePA = 0)
Loop
EndIf

If hora atual > 18:00

Exit
EndIf
.
(processo de produção)
.
EndDo

Lógica e Conceitos Básicos de Programação - 7

4. Programação
Nesta etapa do curso iremos desenvolver alguns programas com o objetivo de trei-
nar a Lógica que é o principal fundamento para tal tarefa. Os programas serão feitos
pelo RDMAKE, que é compilador utilizado nas customizações do Siga Advanced.
Como o objetivo é “apenas” o treinamento da Lógica, serão visto somente alguns
comandos básicos do RDMAKE, sendo que demais comandos e conhecimentos ne-
cessários para operar neste compilador serão visto no curso de RDMAKE.
Para os exercícios, utilize o SigaFAT, e crie uma base de dados para teste conforme
segue:
Cadastre 3 vendedores
Cadastre 4 cliente no estado de SP
Cadastre 3 clientes em outros estados
Cadastre 3 produtos acabados
Cadastre 3 bancos, com os códigos 341, 237 e 033
Cadastre o TES equivalente a Venda de Produto
Cadastre 10 Pedidos de Vendas, variando os clientes, vendedores 1 e os produtos.
Em cada Nota Fiscal, utilize o mesmo TES nos seus respectivos itens.
Gere as respectivas Notas Fiscais ( 1 NF para cada Pedido)

4.1. Operadores
Operadores são sinais para determinadas análises e processos. Os operadores abai-
xo são utilizados no RDMAKE:
> maior que < menor que
>= maior ou igual <= menor ou igual
== exatamente igual := atribuição
+ adicionar - diminuir
* multiplicar / dividir

Não utilize os operadores ++, --, +=, -=, etc., pois não são reconhecidos pelo
RDMAKE.

4.2. Variáveis
Variáveis são dados incógnitos que variam durante um processo, ou ainda serão as
respostas que se deseja obter após a execução do processo Elas podem ser do tipo
Numérica, Caracter, Data, Lógica, etc.
Variáveis tipo Numérica são utilizadas para números que sofrerão variações
matemáticas e devem ser representadas com um “n” minúsculo no início. Os valores
são escritos sem a utilização de delimitadores. Por exemplo:
nValor := 1000
Variáveis tipo Caracter são utilizadas para letras, números e outros símbolos.
Devem ser representadas por um “c” minúsculo no início. Seus valores são escritos
utilizando aspas como delimitador. Por exemplo:
cNome := “Microsiga”
 CIDS – Curso Interno para o Desenvolvimento do Suporte
cCEP := “02511-000”
Variáveis tipo Data são utilizadas para representar datas. Devem ser repre-
sentadas por um “d” minúsculo no início. Seus valores são escritos com a função
CTOD(“ “). Por exemplo:
dVend := CTOD(“01/10/97”)
Variáveis tipo Lógica são utilizadas para representar o Verdadeiro ou Falso.
Devem ser representadas por um “l” minúsculo no início. Seus valores são escritos
utilizando o ponto como delimitador e podem ser apenas .T. (true = verdadeiro) ou
.F. (false = falso). Por exemplo:
lFimArq := .F.

4.3. Comandos e Funções

Comandos são instruções para o processo, como o IF e o While. Funções
são parecidas com o comando, servem para a execução de um processo, porém po-
dem opcionalmente aceitar um parâmetro (dado para processar) e irão retornar
obrigatoriamente um resultado. Elas podem ser internas (própria do RDMAKE ou do
Clipper, por exemplo) ou do usuário (criadas pelo próprio programador).
Por exemplo, a função CTOD() é uma função interna, que aceita uma expres-
são caractere com formato de data e retorna a expressão convertida para data.
Os comandos e funções no RDMAKE são idênticos ao do Clipper 5.2/5.3. Po-
rém, algumas funções próprias do RDMAKE substituem as funções padrão do Clip-
per. Isto porque elas contemplam estruturas e fluxos utilizados pelo Siga Advanced.
As funções próprias do RDMAKE estão descritas no Manual do Siga Advanced
- Apontamentos Técnicos. Deve-se, obrigatoriamente dar preferências a elas. Entre
as funções do Clipper e os comandos do Clipper que possuem o mesmo objetivo,
deve-se também dar preferência para as funções. Por exemplo:
Para travamento de registro de banco de dados:
do RDMAKE: RecLock( ) do Clipper: Rlock( ) - utilizar a
RecLock( )
Para localizar registro no banco de dados:
do Clipper: dbSeek( ) e Seek - utilizar o dbSeek( )

Lógica e Conceitos Básicos de Programação - 9

4.4. Necessidade 1 - ExecBlock( )
“A empresa exemplo necessita que se controle os bancos informados nos Pe-
didos de Vendas. Os bancos atualmente permitidos são: 341, 237 e 033.”
Com base num dos fundamentos da lógica (Ter bem claro as informações
com que se irá trabalhar), constatou-se que o banco informado no Pedido de Venda
é o banco de cobrança e que os clientes da Empresa Exemplo escolhem em qual
banco preferem a cobrança. Porém a Empresa Exemplo possui conta de cobrança
somente nos bancos Itaú (cód.341), Bradesco (237) e Banespa (033) e é por isso
que ela deseja este controle.
Deve-se, no entanto, criar este controle de forma que, caso a Empresa Exem-
plo abra uma conta em outro banco ou feche algum banco utilizado atualmente, te-
nha uma maneira fácil de atualizar o controle sem que haja necessidade de alteração
do programa.
Portanto crie um parâmetro no qual possa se informar os bancos permitidos.
Utilize o configurador para isto e monte o parâmetro conforme abaixo:
mv_BCOCOB Autor: Luís André Baltarejo Data: 01/10/97
Descrição: Bancos que serão utilizados no faturamento. Conteúdo: 341/237/033
Devem ser cadastrados com “/” entre os códigos.
Móds.: SigaFat
Agora crie um gatilho conforme segue:
Autor: Luís André Baltarejo Data: 13/11/96
Dominio: C5_BANCO Cnt.Dom.: C5_BANCO Seq.: 01
Tipo: P Regra: ExecBlock("Emp001",.F.,.F.)
Posic.: N Alias: Ordem: Chave:
Objetivo: Valida banco no Pedido de Venda, conforme o parâmetro MV_BCOCOB
Por fim, crie o programa Emp001.PRG. Os comandos e funções utilizados nes-
te programa podem ser vistos no Manual de RdMake.
O programa exemplo desta necessidade é conforme segue:
/*/
+---------------------------------------------------------+
¦Funçào¦ EMP001 ¦ Autor¦ Luis A Baltarejo ¦ Data¦01.10.97 ¦ +--
--------+----------------------------------------------¦
¦Descriçào ¦ Valida banco no Pedido de Venda ¦
+----------+----------------------------------------------¦
¦Argumentos¦ Verifica parâmetro MV_BCOCOB ¦
+----------+----------------------------------------------¦
¦Observacao¦ ¦
Documentação inicial +----------+----------------------------------------------¦
do programa. ¦Retorna ¦ M->C5-BANCO ¦
+----------+----------------------------------------------¦
¦Uso ¦ Valid.Usuário em C5_BANCO-Espec.CIDs ¦
+----------+----------------------------------------------¦
¦Revisoes ¦Autor ¦ Luis Baltarejo ¦ Data ¦ 01.10.97 ¦
+----------+----------------------------------------------¦
¦Projeto Original ¦
+---------------------------------------------------------+
/*/

Armazenar a posição e
área atual relativa aos
bancos de dados para
não danificar o proces-
samento normal da roti-
na de Pedido de Vendas.
Função de Help. Utilize-a
sempre que precisar testar
uma situação, permitindo
que o usuário possa en-
tender as críticas, sem
precisar solicitar suporte
Não esquecer nunca de
voltar a situação original
quanto aos bancos de da-
dos para não prejudicar o
processamento normal da
rotina.
4.5. Necessidade 2 (Relatório)
CIDS – Curso Interno para o Desenvolvimento do Suporte
//===============================================//
// Salva Integridade dados de entrada //
//===============================================//
cSvAlias := Alias()
nSvRecno := Recno()
nSvIndex := IndexOrd()
//===============================================//
// Inicializa Variaveis //
//===============================================//
lRetBco := .F.
cBcoCob := AllTrim(GetMv("MV_BCOCOB"))
//===============================================//
// Valida o banco //
//===============================================//
If !( AllTrim(M->C5_BANCO)$ cBcoCob)
Help(,1,"BCOCOBNEXI",,,10,10)
M->C5-BANCO:=SPACE(LEN(C5-BANCO))
EndIf
//===============================================//
// Restaura integridade da entrada //
//===============================================//
DbSelectArea(cSvAlias)
DbSetOrder(nSvIndex)
DbGoTo(nSvRecno)
__Return(M->C5-BANCO)
Teste o programa e aproveite para atualizar o help.
A Empresa Exemplo necessita de um relatório com Lay-Out e informações
conforme o modelo seguinte, sendo que todas os valores devem ser totalizados no
final do relatório.
No levantamento, constatou-se que a Empresa Exemplo emite Notas Fiscais
com natureza e tratamentos dos impostos e duplicatas sempre iguais para os respec-
tivos itens da NF (situação que quase nunca condiz com a realidade do dia-a-dia na
realidade).
Portanto o TES de um item é o mesmo para os demais, dentro da mesma No-
ta Fiscal.
Lógica e Conceitos Básicos de Programação - 11
 Lay-Out do relatório:
Valor até até +de
N.F. Pedido Cliente Vendedor Total 1000 2000 2000
XXXXXX XXXXXX XXXXXXXXXXXXXXX XXXXXXXXXXXXXXX 9.999,99 9.999,99 9.999,99 9.999,99
0 1 2 3 4 5 6 7 8
012345678901234567890123456789012345678901234567890123456789012345678901234567890
Obtendo-se todas as informações necessárias, antes de iniciar a programação,
veremos que Valor Total que a Empresa Exemplo deseja é o valor bruto de vendas
(contido em SF2->F2_VALBRUT); o campo até 1000 corresponde aos faturamentos
até R$ 1000,00; e assim por diante nos campos até 2000 e +de 2000.
Observar também que somente as Notas Fiscais de Vendas devem ser consi-
deradas para o relatório, o que pode ser controlado pelo TES.
O programa exemplo desta necessidade é conforme segue:
/*/
+---------------------------------------------------------+
¦Funçào ¦EMP002¦ Autor ¦Luis Baltarejo¦Data ¦ 01.10.97 ¦
+----------+----------------------------------------------¦
¦Descriçào ¦ Relatorio Estatistico de Faturamento de Venda¦
+----------+----------------------------------------------¦
¦Argumentos¦ Relacionar as NF de Vendas c/ colunas estat. ¦
¦ ¦ de valores ¦
+----------+----------------------------------------------¦
¦Observacao¦ ¦
+----------+----------------------------------------------¦
¦Retorna ¦ Nada ¦
+----------+----------------------------------------------¦
¦Uso ¦ Especifico CIDS - SigaFat ¦
+----------+----------------------------------------------¦
¦Revisoes ¦ Autor ¦ Luis Baltarejo Data ¦ 01.10.97 ¦
+----------+----------------------------------------------¦
¦ ¦ Projeto Original ¦
+---------------------------------------------------------+
necessario: - alimentar arquivo perg/respostas
/*/

#define K_ALT_A 286 // Alt-A

#define K_ESC 27 // Esc
#define VLR "@E 9,999.99" // pict para valores

//+-------------------------------------------------------+
//¦ Salva a Integrigade dos dados de entrada ¦
//+-------------------------------------------------------+

cSavScr1 := SaveScreen(3,0,24,79)
cSavCur1 := SetCursor()
cSavRow1 := Row()
cSavCol1 := Col()
cSavCor1 := SetColor("bg+/b,,,")

//+-------------------------------------------------------+
//¦ Define Variaveis ¦
//+-------------------------------------------------------+

Tamanho := "M"
limite := 80
Titulo := "Relatorio Estatistico Faturamento de Vendas"
cDesc1 := "Este programa emite relacao das Notas Fiscais de vendas
dentro do"
cDesc2 := "periodo selecionado, descrevendo por valores ate
1000,00, 2.000,00"
cDesc3 := "e mais de 2.000,00. "
cString := " "
aReturn := { "80 Colunas", 1,"Administracao", 2, 2, 1, "", ""}
nomeprog := "EMP002"
nLastKey := 0
cPerg := "EMP002"
 CIDS – Curso Interno para o Desenvolvimento do Suporte
CbCont := 0
Cbtxt := ''
nLin := 80 // contador de linha
m_pag := 1
wnrel := "EMP002"
cSavScr1 := SaveScreen(3,0,24,79)
nSF2 := 0 // numero de indices do SF2
cArqInd := "" // nome do arquivo de indice temporario
cChave := "" // chave do indice temporario
cFiltro := "" // filtro do indice temporario
nTotFat := 0 // total faturado
nT1000 := 0 // total ate 1.000
nT2000 := 0 // total ate 2.000
nTmais := 0 // total mais de 2.000

//+-------------------------------------------------------+
//¦ Variaveis utilizadas para parametros ¦
//¦ mv_par01 Data Emis.NF de ? ¦
//¦ mv_par02 Data Emis.NF ate ? ¦
//+-------------------------------------------------------+

Pergunte(cPerg,.f.)

//+-------------------------------------------------------+
//¦ Envia controle para a funcao SETPRINT ¦
//+-------------------------------------------------------+

wnrel:=SetPrint(cString,wnrel,cPerg,Titulo,cDesc1,cDesc2,cDesc3,.F.,,.T.,"P",.F.
,.F.)

If ( Lastkey() == K_ESC ) .Or. ( nLastKey == K_ESC )

//+--------------------------------------------------+
//¦ Recupera a Integridade dos dados ¦
//+--------------------------------------------------+

RestScreen(3,0,24,79,cSavScr1)
SetCursor(cSavCur1)
DevPos(cSavRow1,cSavCol1)
SetColor(cSavCor1)
Return
Endif

SetDefault(aReturn,cString)

If ( Lastkey() == K_ESC ) .Or. ( nLastKey == K_ESC )

//+--------------------------------------------------+
//¦ Recupera a Integridade dos dados ¦
//+--------------------------------------------------+

RestScreen(3,0,24,79,cSavScr1)
SetCursor(cSavCur1)
DevPos(cSavRow1,cSavCol1)
SetColor(cSavCor1)
Return
Endif

//+-------------------------------------------------------+
//¦ Cabecalhos ¦
//+-------------------------------------------------------+
Régua do cabeça-
lho, de uso padrão Cabec1 := "Valor até até +de"
na Microsiga. Cabec2 := "N.F. Pedido Cliente Vendedor Total 1000 2000 2000"
// XXXXXX XXXXXX XXXXXXXXXXXXXXX XXXXXXXXXXXXXXX 9.999,99 9.999,99 9.999,99
9.999,99
// 0 1 2 3 4 5 6 7 8

Lógica e Conceitos Básicos de Programação - 13

//
01234567890123456789012345678901234567890123456789012345678901234567890123456789
0

//+---------------------------------------------------------+
//¦ Verifica Caracter de Compactacao ¦
//+---------------------------------------------------------+

nComp := Iif(aReturn [4] == 1,GetMv("MV_COMP"),GetMv("MV_NORM"))

//+---------------------------------------------------------+
//¦ Posiciona indices ¦
//+---------------------------------------------------------+

dbSelectArea("SA1") // Cadastro de Clientes

dbSetOrder(1) // - p/ Filial+Cod

dbSelectArea("SA3") // Cadastro de Vendedores

dbSetOrder(1) // - p/ Filial+Cod

dbSelectArea("SF4") // Cadastro de TES

dbSetOrder(1) // - p/ Filial+CodTES

dbSelectArea("SD2") // Itens da NF Saida

dbSetOrder(3) // - p/ Fili-
al+Doc+Serie+Cliente+Loja+Cod

//+---------------------------------------------------------+
//¦ Cria indice temporario ¦
//+---------------------------------------------------------+

dbSelectArea("SF2")
dbSetOrder(1)
cArqInd := CriaTrab(,.F.)

cChave := "SF2->F2_FILIAL + DTOC(SF2->F2_EMISSAO)"

cFiltro := 'SF2->F2_FILIAL == "' + xFilial("SF2") + '" .And. '+;

'DTOS(SF2->F2_EMISSAO) >= "' + DTOS(mv_par01) + '" .And. '+;
'DTOS(SF2->F2_EMISSAO) <= "' + DTOS(mv_par02) + '"'

IndRegua("SF2",cArqInd,cChave,,cFiltro,"Selecionando Regis-
tros...")
nSF2 := RetIndex("SF2")
DbSelectArea("SF2")
DbSetIndex(cArqInd)
DbSetOrder(nSF2+1)

//+---------------------------------------------------------+
//¦ Impressao - ate o final do arquivo SF2 ¦
//+---------------------------------------------------------+

dbGoTop()
SetRegua( LastRec() )

While !EOF()

IncRegua()

If (LastKey() == K_ALT_A) .Or. (Inkey() == K_ALT_A)

@ Prow()+1, 001 Say "Cancelado Pelo Operador"
Exit
EndIf

//+----------------------------------------------------+
//¦ Posiciona Cliente, Vendedor, Itens da NF e TES ¦
//+----------------------------------------------------+

dbSelectArea("SA1") // Cadastro de Clientes

dbSeek( xFilial() + SF2->F2_CLIENTE )
 CIDS – Curso Interno para o Desenvolvimento do Suporte

dbSelectArea("SA3") // Cadastro de Vendedores

dbSeek( xFilial() + SF2->F2_VEND1 )

dbSelectArea("SD2") // Itens Pedido Venda

dbSeek( xFilial() + SF2->F2_DOC + SF2->F2_SERIE )

dbSelectArea("SF4") // Cadastro de TES

dbSeek( xFilial() + SD2->D2_TES )

//+----------------------------------------------------+
//¦ Verifica se TES gera duplicata ¦
//+----------------------------------------------------+

IF SF4->F4_DUPLIC <> "S"

dbSelectArea("SF2")
dbSkip()
Loop
EndIf

//+----------------------------------------------------+
//¦ Cabecalho da listagem ¦
//+----------------------------------------------------+

If nLin > 56
NLin:= Cabec(titulo,cabec1,cabec2,nomeprog,Tamanho,nComp)+1
EndIf
//+----------------------------------------------------+
//¦ Imprime dados ¦
//+----------------------------------------------------+

@ nLin,000 Say SF2->F2_DOC

@ nLin,007 Say SD2->D2_PEDIDO
@ nLin,014 Say SubStr(SA1->A1_NREDUZ,1,15)
@ nLin,030 Say SubStr(SA3->A3_NREDUZ,1,15)
@ nLin,046 Say SF2->F2_VALBRUT Pict VLR

If SF2->F2_VALBRUT <= 1000

@ nLin,055 Say SF2->F2_VALBRUT Pict VLR
Else
@ nLin,055 Say 0 Pict VLR
EndIf

If SF2->F2_VALBRUT > 1000 .And. SF2->F2_VALBRUT <= 2000

@ nLin,064 Say SF2->F2_VALBRUT Pict VLR
Else
@ nLin,064 Say 0 Pict VLR
EndIf

If SF2->F2_VALBRUT > 2000

@ nLin,073 Say SF2->F2_VALBRUT Pict VLR
Else
@ nLin,073 Say 0 Pict VLR
EndIf

//+----------------------------------------------------+
//¦ Totalizacoes ¦
//+----------------------------------------------------+

nTotFat := nTotFat + SF2->F2_VALBRUT

If SF2->F2_VALBRUT <= 1000

nT1000 := nT1000 + SF2->F2_VALBRUT
EndIf

If SF2->F2_VALBRUT > 1000 .And. SF2->F2_VALBRUT <= 2000

nT2000 := nT2000 + SF2->F2_VALBRUT
EndIf

Lógica e Conceitos Básicos de Programação - 15

 If SF2->F2_VALBRUT > 2000
nTmais := nTmais + SF2->F2_VALBRUT
EndIf

dbSelectArea("SF2")
dbSkip()
nLin:=nLin+1

EndDo

@ nLin,000 Say "Total Geral "

@ nLin,046 Say nTotFat Pict VLR
@ nLin,055 Say nT1000 Pict VLR
@ nLin,064 Say nT2000 Pict VLR
@ nLin,073 Say nTmais Pict VLR

//+---------------------------------------------------------+
//¦ Impressao do rodape ¦
//+---------------------------------------------------------+

Roda(cbcont,cbtxt,Tamanho)

//+---------------------------------------------------------+
//¦ Se impressao em disco, chama Spool ¦
//+---------------------------------------------------------+

Set Device to Screen

If ( aReturn[5] == 1 )
Set Printer TO
DbCommitAll()
OurSpool(wnrel)
EndIf

//+---------------------------------------------------------+
//¦ Libera relatorio para Spool da Rede ¦
//+---------------------------------------------------------+

Ft_Pflush()

//+---------------------------------------------------------+
//¦ Apaga indice temporario ¦
//+---------------------------------------------------------+

DbSelectArea("SF2")
RetIndex("SF2")
DbSetOrder(1)

If !Empty(cArqInd)
Ferase(cArqInd+OrdBagExt())
EndIf

dbSelectArea("SF2")
dbSetOrder(1)

//+---------------------------------------------------------+
//¦ Recupera a Integridade dos dados ¦
//+---------------------------------------------------------+

RestScreen(3,0,24,79,cSavScr1)
SetCursor(cSavCur1)
DevPos(cSavRow1,cSavCol1)
SetColor(cSavCor1)
__Return()
Cadastre as perguntas no arquivo de Perguntas e Respostas (SX1), acrescente
o relatório no menu do SIGAFAT e teste o mesmo.
 CIDS – Curso Interno para o Desenvolvimento do Suporte

5. Vetores
Vetor (Array ou Matriz) é um tipo de variável de memória que permite arma-
zenar um conjunto de dados. Assemelha-se às células de uma planilha eletrônica. A
grande vantagem é a velocidade pois os dados estão em memória e a economia do
código de programação.
Um vetor pode ser unidimensional ou multidimensional. Porém, como o vetor
é uma variável de memória, seu tamanho é limitado.
Para facilitar o seu entendimento, veja a representação matemática abaixo de
uma matriz:

Matriz = a b c d

linhas m n k l

w x y z

colu-
Cada letra da Matriz é chamado de elemento da matriz. Para identificar um
elemento, utiliza-se o número da linha e o numero da coluna. Onde houver o cruza-
mento da linha e da coluna estará o elemento a ser identificado.
Exemplo:
Para identificarmos a letra k dentro desta matriz, utilizamos Matriz[2,3] = k
, sendo que o nº 2 representa a 2ª linha, e o número 3 representa a 3ª coluna.
Para sabermos o valor de Matriz[3,2], verifica-se o cruzamento da linha 2
com a coluna 3. Encontramos, portanto a letra x.
Num programa, como exemplo, um vetor pode conter o código de um cliente,
a razão social e a cidade. Veja o exemplo, comparando-se uma matriz matemática
com o vetor de programação:
Matriz = [ 0001 MICROSIGA SAO PAULO 1000,00 01/10/97 ]
aVetor1 := 0001, MICROSIGA, SAO PAULO, 1000,00, 01/10/97
No exemplo, o vetor aVetor1 possui cinco dados. Cada dado é um elemento
do vetor. Este vetor é unidimensional (pois possui apenas uma linha). Note que os
elementos do vetor podem ser de qualquer tipo, ou seja, caracter, numérico, data,
etc.
A variável tipo vetor é representada por um a minúsculo no início. Seus valo-
res são escritos utilizando as chaves como delimitador, sendo que os valores contido
dentro do vetor devem respeitar os delimitadores do tipo de dado respectivo. Para
identificar os elementos, utiliza-se colchetes com o numero da posição do elemento.
Portanto, a maneira correta de escrever o aVetor1 mostrado anteriormente é:
aVetor1 := { “0001”, “MICROSIGA”, “SAO PAULO”, 1000,00, CTOD(“01/10/97”) }
onde,

Lógica e Conceitos Básicos de Programação - 17

 aVetor1[1] := “0001”
aVetor1[2] := “MICROSIGA”
aVetor1[3] := “SAO PAULO”
aVetor1[4] := 1000
aVetor1[5] := CTOD(“01/10/97”)
Pode-se colocar dentro de um vetor, outros vetores. Neste caso eles são
chamados de multidimensional. Por exemplo:
aVetor2:={ {“0001”,“Microsiga”,“Sao Paulo”,1000,Ctod(“01/10/97”)} ;
{“0002”,“Microsiga University”,“Sao Paulo”,980,Ctod(“02/10/97”)} ;
{“0003”,“Microsoft”,“Sao Paulo”,870,Ctod(“03/10/97”)}}
onde, (note que a representação é aVetor [nLin, nCol], como numa matriz matemá-
tica )
aVetor2[1,1] := “0001”
aVetor2[1,2] := “MICROSIGA”
aVetor2[1,3] := “SAO PAULO”
aVetor2[1,4] := 1000
aVetor2[1,5] := CTOD(“01/10/97”)
aVetor2[2,1] := “0002”
aVetor2[2,2] := “CTP ”
aVetor2[2,3] := “SAO PAULO”
aVetor2[2,4] := 980
e assim por diante.
Neste último exemplo, o vetor é conhecido também como bidimensional, ou
seja, possui duas dimensões. Com três dimensões ele é tridimensional e assim por
diante, porém sua utilização começa a ficar complexa e de difícil assimilação. Sendo
assim e considerando-se ainda que ele possui tamanho limitado evite vetores com
mais de duas dimensões.

5.1. Exemplo de aplicação de Vetor

Um exemplo típico de aplicação de vetor, é como segue abaixo:
“A empresa exemplo precisa de um relatório com os dados dos seus vendedores e o
valor faturado num determinado período. Foi considerando que a empresa possui
poucos vendedores (atualmente 15) e que é praticamente impossível que sequer
duplique seu quadro de vendas.”
Sendo assim, ao invés de utilizarmos um arquivo temporário para esta rotina,
usaremos o vetor (lembre-se que a memória é muito mais rápida que o acesso em
disco).
Este programa ficará próximo ao esquema abaixo:

// criar subvetores para cada registro do cadastro de vendedores

aVend := {}
dbSelectArea(“SA3”)
dbGoTop()

While !EOF()
AADD( aVend, { SA3->A3_COD, SA3->A3_NOME, 0 } )
dbSkip()
EndDo
 CIDS – Curso Interno para o Desenvolvimento do Suporte

Lógica e Conceitos Básicos de Programação - 19

6. Funções de Usuário
Com o objetivo de atender um dos princípios da Lógica “Se o problema e/ou
processo for grande, deve-se dividi-lo em partes menores”, foi criado em pratica-
mente todas as linguagens de programação a Função de Usuário, ou outro recurso
do mesmo gênero, como procedures.
A Função de Usuário tem portanto como objetivo fazer com que um pro-
grama seja “quebrado” em partes menores e/ou permitir que a parte do código que
muitas vezes é repetida várias vezes dentro de um programa, seja substituída pela
função do usuário.
Veja os passos abaixo, necessário para impressão de uma Nota Fiscal (as li-
nhas entre parênteses indicam a quantidade de linhas utilizadas na codificação do
programa):
Passo Ação Linhas
1 Solicitar No. da NF 5
2 Armazenar os dados básicos da Nota Fiscal em variáveis 6
3 Iniciar impressora 6
4 Imprimir cabeçalho da NF 12
5 Imprimir dados do destinatário 13
6 Imprimir dados da duplicata 28
7 Imprimir dados dos produtos 36
8 Imprimir dados dos serviços 31
9 Calcular impostos e totais da NF 44
10 Imprimir impostos 12
11 Imprimir totais 08
Como os passos 06, 07, 08 e 09, por n motivos, são os que demandam a
maior quantidade de códigos de programação, poderemos “quebrar o programa co-
mo segue:

// Solicitar Nº da NF
.
.
.
// Armazenar os dados básicos da Nota Fiscal em variáveis
.
.
.
// Iniciar impressora
.
.
.
// Imprimir cabeçalho da NF
.
.
.
// Imprimir dados do destinatário
.
.
.
// Imprimir dados da duplicata
ImpDup( )

// Imprimir dados dos produtos

 CIDS – Curso Interno para o Desenvolvimento do Suporte
ImpPrd( )

// Imprimir dados dos serviços

ImpSer( )

// Calcular impostos e totais da NF

CalcImp( )

// Imprimir impostos
.
.
.
// Imprimir totais
.
.
.
e criar as funções ImpDup, ImpPrd, ImpSer e CalcImp em seguida, separadamente.
Agora veja abaixo o esquema para imprimir um relatório:
.
.
.
While ... (imprimir)
If nLinha > 60
nLinha := 1
.
.
. (comandos para desenhar o cabeçalho)
.
.
nLin := 5
EndIf
@ nLin,000 Say...
Pode-se isolar os comandos para o cabeçalho e montar o programa como segue:

.
.
.
While ... (imprimir)
If nLinha > 60
nLin:=Cabec( )
EndIf
@ nLin,000 Say...
@ nLin,000 Say... (imprimir dados)
@ nLin,000 Say...
dbSkip( )
nLin := nLin + 1
EndDo
.
.
. Lógica e Conceitos Básicos de Programação - 21
 No SIGA Advanced, existem muitas funções de usuários disponíveis para
uso, inclusive uma para cabeçalho. As funções permitem que sejam enviadas alguns
parâmetros ( que são informados dentro dos parênteses ) e retornam um resultado.
Um exemplo disso no RDMAKE é a função Cabec( ), a qual possui a seguinte sinta-
xe e retorna a última linha utilizada pelo cabeçalho:
nLin := Cabec( cTitulo, cCabec1, cCabec2, cNomPrg, nLargRelat, nCtrImp )
Já nas funções criadas pelo programador, como no exemplo, não é necessário
enviar parâmetros, pois os dados ficam disponível o tempo todo dentro do programa
RDMAKE assim que são declaradas, inclusive dentro das funções do mesmo progra-
ma.
 CIDS – Curso Interno para o Desenvolvimento do Suporte

Anexo A - Comandos e Funções Utilizados nesta apostila.

Para melhor entender os comandos, foi adotado simbologias que fazem indicações conforme segue:

Itálico Indica variáveis ou dados que devem ser substituídos por uma expressão ou valor conforme a necessi-
dade
Negrito É o comando ou função propriamente dito.
[] Indica que o conteúdo do colchetes é opcional, devendo ser usado somente se o programador necessi-
tar. Os colchetes não devem ser digitados.
cExp expressão caractere que deve ser informada pelo programador. Esta expressão deve estar entre aspas.
Por exemplo: SETCOLOR( cExp ) pode ser usada como SETCOLOR( “w/n” )
nExp expressão numérica que deve ser informada pelo programador.
lExp expressão lógica que deve ser informada pelo programador. Esta expressão deve estar entre pontos.
dExp expressão em forma de data que deve ser informada pelo programador. Por exemplo: a função DAY(
dExp ) pode ser usada como DAY( CTOD(“01/01/80”) ) ou como DAY( dNascim ).
aExp expressão de vetor que deve ser informada pelo programador.
xExp expressão de qualquer tipo que deve ser informada pelo usuário. Esta expressão pode ser também uma
outra função, ou ainda vários argumentos, como condições e comparações.
nLin expressão numérica relativa ao nº da linha que deve ser informada pelo programador. Quando ocorrer
nLin1,nCol1,nLin2,nCol2 significa que deve-se especificar duas coordenadas para determinar uma área
retangular. nLin1,nCol1 indicam o canto superior esquerdo e nLin2,nCol2 indicam o canto inferior direito.
nCol expressão numérica relativa ao nº da coluna que deve ser informada pelo programador.

ALIAS expressão relativa ao nome do Banco de Dados que deve ser informada pelo programador.
#define K_... nExp

Por ocasião da compilação, toda ocorrencia da expressão K_... será convertida para a expressão declarada em nExp.
A expressão K_... são as existentes no arquivo inkey.ch.

@ nLin,nCol Say Exp [ Pict cExp ]

Exibe a expressão Exp na coordenada especificada. O comando Pict permite usar uma máscara na expressão (veja
o comando Pict ).
@ nLin,nCol Get Var [ Pict cExp ] [ When lExp ] [ Valid lExp ]
Permite que o usuário informe o dado em tela na coordenada especificada. O dado informado pelo usuário será ar-
mazenado na variável. O comando Pict permite usar uma máscara na expressão (veja o comando Pict ). O comando
When permite configurar se o Get deve ser realmente ativo (veja o comando When ). O comando Valid permite verifi-
car se o dado informado pelo usuário é válido ou não (veja o comando Valid ).
Para ativar um ou vários comandos Get deve-se usar o comando Read

PCol()

Retorna o número da coluna em que a cabeça de impressão da impressora está posicionada. Veja também a função
PRow().

Lógica e Conceitos Básicos de Programação - 23

PRow()

Retorna o número da linha em que a cabeça de impressão da impressora está posicionada. Veja também a função
PCol().

__Return( [Exp] )

Encerra uma função/programa, retornando o valor especificado em Exp. Veja também o co-
mando Return.

AAdd( aExp1, Exp2 )

Adiciona um dado em um vetor. aExp1 deve ser substituída pelo vetor que receberá o dado. Exp2 é o dado que será
adicionado no vetor, que pode ser qualquer tipo de dado.

Alias( [ nExp ] )

Retorna o Alias do banco de dados que estiver aberto na área especificada por nExp. Se não for usado nExp, será
retornado o Alias da área atual.

AllTrim( cExp )

Elimina os espaços em branco no início e no fim da expressão cExp. Veja também as funções LTrim() e RTrim().

AScan( aExp1, Exp2, [ nExp3 ] , [ nExp4 ] )

Pesquisa no vetor especificado em aExp1 a existência do dado especificado em Exp2, retornando o número do ele-
mento ou zero se o dado não for encontrado. nExp3 indica por qual elemento deve-se iniciar a pesquisa; se não for
especificado será considerado o primeiro elemento do vetor. nExp4 indica quantos elementos devem ser pesquisa-
dos; se não for especificado, será considerado todos os elementos do vetor.

BOF()

Verifica se o ponteiro do banco de dados da área atual esta no início do arquivo. Se estiver, a função retornará .T.,
caso contrário retornará .F.. BOF significa begin of file, ou seja, início do arquivo.

Cabec( cExp1, cExp2, cExp3, cExp4, nExp5, nExp6 )

 CIDS – Curso Interno para o Desenvolvimento do Suporte
Monta o cabeçalho de listagem padrão do Siga Advanced e retorna a última linha utilizada. Os parâmetros desta fun-
ção são:
cExp1 Título da Listagem
cExp2 Primeira linha dos títulos das colunas do cabeçalho
cExp3 Segunda linha dos títulos das colunas do cabeçalho
cExp4 Nome do Programa (ou do ExecBlock)
cExp5 Largura da Listagem
cExp6 Caractere de controle da impressora
Cls ou Clear Screen

Limpa toda a tela.

Col()

Retorna a coluna atual do cursor na tela. Esta função é muito usada com a função Row().

CriaTrab( [ aExp ], lExp )

Cria um arquivo de banco de dados temporário retornando um nome para ele, ou simplesmente retorna um nome
para um arquivo qualquer. Para criar um arquivo de banco de dados deve-se informar a expressão aExp que é um
vetor multidimensional com as estruturas dos campos ( a coluna 1 é o nome do campo, a coluna 2 o tipo, a coluna 3 o
tamanho e a coluna 4 as casas decimais) e a expressão lExp deve ser .T. Para se obter apenas um nome não infor-
me aExp e lExp deve ser .F.

CTOD( cExp )

Converte o formato caractere da expressão especificada para o formato data. A expressão caractere que deve ser
informada deve estar montada como se fosse uma data, por exemplo: CTOD( “01/01/90” ), CTOD( “1/1/1990” ),
CTOD( SPACE(8) ).

dbGoBottom()

Move o ponteiro do banco de dados da área atual para o último registro, respeitando o índice ativo se houver.

dbGoTo( nExp )

Move o ponteiro do banco de dados da área atual para o registro cujo numero interno é o especificado em nExp. O
número interno corresponde a posição seqüencial que o registro foi incluído no banco de dados. Os índices não tem
ação sobre este numero interno.

dbGoTop()

Lógica e Conceitos Básicos de Programação - 25

Move o ponteiro do banco de dados da área atual para o primeiro registro, respeitando o índice ativo se houver.

dbSeek( Exp )

Pesquisa todo o banco de dados posicionando o ponteiro no primeiro registro cujo valor seja igual a expressão espe-
cificada. Este comando só funciona em bancos de dados abertos e com o índice ativo. Ele executa a pesquisa tam-
bém somente no campo chave, ou seja, aquele que determina a seqüência do índice ativo. Esta função retorna .T. se
o registro foi localizado ou .F. se o registro não foi localizado. Caso o registro não foi localizado, o ponteiro do banco
de dados será posicionado no fim do arquivo, ou seja, na posição EOF (vide o comando EOF() )

dbSelectArea( cExp )

A área em que estiver o banco de dados especificado em cExp será a área atual. cExp deverá ser o ALIAS do banco
de dados.

dbSetIndex( cExp )

Abre o índice especificado em cExp na área atual, tornando-o o índice ativo.

dbSetOrder( nExp )

Determina qual índice deve estar ativo na área atual. Um banco de dados pode ter vários índices e todos podem estar
abertos simultaneamente. Porém somente um índice estará ativo por vez. Para determinar o índice ativo o seu núme-
ro deve ser especificado em nExp. O número do índice depende de quando ele foi aberto. O primeiro índice aberto na
área atual será o índice 1; o segundo índice aberto na área atual será o 2; e assim por diante.

dbSkip( [ nExp ] )

Move o ponteiro do banco de dados nExp para frente ou para traz. Se nExp não for especificado, será movido 1 regis-
tro para frente. Se nExp for um número negativo, o ponteiro será movido para traz.

DevPos( nLin,nCol )

Movimenta a cabeça de impressão para a posição especificada.

DTOC( dExp )

Converte a data especificada em formado caractere. Dê preferência para a função DTOS( )

 CIDS – Curso Interno para o Desenvolvimento do Suporte
DTOS( dExp )

Retorna a data especificada no formato aaaammdd. Esse formato é útil quando necessita-se criar uma chave de índi-
ce cujo conteúdo é uma data junto com caracteres.

Empty( Var )

Verifica se a variável especificada possui algum valor ou não. Se a variável possuir valor, será retornado .T., se não
possuir será retornado .F. A variável pode ser de qualquer tipo, inclusive campo de banco de dados.

EOF()

Verifica se o ponteiro do banco de dados está no fim do arquivo ou não. Se estiver será retornado .T., se não estiver
será retornado .F. EOF significa end of file, ou seja, fim do arquivo.

Exit

Interrompe o loop While ... EndDo, sendo que o processamento será continuado a partir da linha seguinte ao coman-
do EndDo. (veja o comando While).

FErase( cExp )

Apaga o arquivo especificado em cExp do disco.

For Var := nExp1 To nExp2 [ Step nExp3 ] ... Next

Provoca um loop (execução de um grupo de programas mais de uma vez) entre o comando For e o comando Next.
Var é uma variável que terá um valor inicial especificado em nExp1. Esse valor irá progredindo até que tenha o valor
idêntico a nExp2, quando então o loop será encerrado. Se não for especificado Step a progressão de nExp1 será de
1 em 1. Caso contrario, a progressão será conforme especificado em nExp3.

Ft_Pflush( )

Libera o relatório para o spool da rede.

GetMv( cExp )
Retorna o conteúdo do parâmetro descrito em cExp. Os parâmetros são cadastrados através do módulo SigaCFG.
Help( ,1,cExp )

Monta uma janela de Help em nível de campo. cExp é um título para o Help.

Lógica e Conceitos Básicos de Programação - 27

IF Exp1
comandos...
[ ELSEIF Exp2
comandos... ] ...
ELSE
comandos...
ENDIF

Esta estrutura avalia uma condição em Exp1 para executar os comandos logo abaixo. O ELSEIF é uma segunda
condição, caso necessário, e pode ser usada várias vezes. O ELSE faz com que os comandos logo abaixo sejam
executados caso nenhuma das condições anteriores forem aceitas. O ENDIF encerra a estrutura.

IncRegua( )

Incrementa a régua de processamento, utilizada na impressão de relatórios. Esta função trabalha em conjunto com a
função SetRegua( ).

IndexOrd()

Retorna o número do índice ativo do banco de dados da área atual. O número do índice depende da seqüência com
que os índices foram abertos. Veja a função dbSetIndex( ) e dbSetOrder( ).

Inkey( [ nExp ] )

Para a execução do programa até que uma tecla seja pressionada ou durante um determinado tempo. O tempo deve
ser especificado em nExp. Se não for especificado, nExp será considerado como 0 (zero), ou seja, por tempo inde-
terminado. Se nExp for especificado como 0.5, será considerado meio segundo. Se for especificado como 1, será
considerado 1 segundo, e assim por diante.

Esta função retorna o código ASCII da tecla pressionada para que a execução do programa continue.

IndRegua( cExp1, cExp2, cExp3,, cExp4,cExp5 )

Cria um arquivo de índice temporário. Os parâmetros devem ser:

cExp1 Alias do banco de dados que receberá o novo índice
cExp2 Nome do novo arquivo de índice. Este nome deve ser obtido pela função CriaTrab( ).
cExp3 Expressão chave do índice
cExp4 Filtro para o índice
cExp5 Mensagem para tela enquanto o índice é gerado.

Maiores detalhes desta função será visto no curso de RDMake.

 CIDS – Curso Interno para o Desenvolvimento do Suporte
LastKey( )

Retorna o código ASCII da última tecla pressionada.

LastRec( )

Retorna a quantidade de registros do banco de dados da área atual.

Len( Exp )

Retorna a quantidade de dígitos se Exp for uma expressão caractere ou numérica, contando inclusive os espaços em
branco e zeros. Se Exp for um vetor, retorna a quantidade de elementos que ele possuir.
Loop

Faz com que o Loop do tipo While seja reiniciado a partir da linha onde é iniciado (que possui o próprio comando
WHILE).

OurSpool( cExp )

Chama o spool de impressão. Deve ser chamada quando o quinto elemento de aReturn for igual a 1 (Disco), ou seja,
a impressão for direcionada para disco. O vetor aReturn é montado quando da chamada da função SetPrint( ).

Pergunte( cExp, lExp )

Carrega os parâmetros de perguntas correspondente ao programa especificado em cExp, a qual é o nome do Grupo
de Perguntas, que devem serem especificadas no arquivo SX1. Se lExp for .T., uma janela com as perguntas será
exibida em tela, independente do comando do usuário. Se lExp for .F., a janela não será apresentada.

Pict Exp

Este comando é um argumento que deve ser usado com o comando Say ou com o comando Get e determina uma
máscara na expressão desses comandos. Exp é o formato da máscara que pode ser usado, que são:

“” Determina o espaço ocupado pela variável. O espaço ocupado será o mesmo que o numero de es-
paços dentro das aspas.

“!” Além de determinar o espaço ocupado pela variável, o dado será convertido para maiúsculo. Use !
para cada dígito que queira converter para maiúsculo. Pode ser usado também o ! junto com espa-
ços (por exemplo “!!! “

“@!” Faz com que todos os dígitos da variável sejam convertidos para maiúsculo.

Lógica e Conceitos Básicos de Programação - 29

“@#” Faz com que seja aceito somente números.

“@E” é usado para que o valor fique no formato europeu, com pontos nas casas de milhar e vírgulas na
casa decimal.

“#,###.##” é usado para colocar o separador de milhar. O espaço ocupado pelo dado será o mesmo que o nú-
mero de #. A quantidade de # é indeterminada, podendo ser maior ou menor que a especificada nes-
te exemplo.

“@E #,###.##” é uma combinação dos comandos “@E” e “#,###.##”. Note que apesar de ser especificado a vírgula
na casa da milhar e o ponto na casa decimal, o dado ao ser exibido na tela ou na impressora estará
no formato europeu.

Read

Ativa todos os comandos Get que estiverem pendentes.

Recno( )

Retorna o número do registro atual do banco de dados da área atual.

Replicate( cExp1,nExp2 )

Retorna uma expressão cujo o conteúdo será o mesmo que especificado em cExp1, sendo que esta expressão será
repetida nExp2 vezes. Por exemplo: Replicate( “x”,10 ) retorna “xxxxxxxxxx”.

RestScreen( nLin1,nCol1,nLin2,nCol2,Var )

Restaura um tela previamente gravada com a função SaveScreen( ) nas coordenadas especificadas. Veja a função
SaveScreen( ).

RetIndex( cExp )

Retorna os índices padrão do SigaAdvanced, referente ao banco de dados especificado em cExp.

Return

Retorna para a função/programa anterior, exatamente para linha seguinte àquela que acionou a função atual.

Roda( 0, “ ”, cExp )
 CIDS – Curso Interno para o Desenvolvimento do Suporte
Imprime o rodapé de relatório padrão do SigaAdvanced. cExp é o tipo do relatório (P pra pequeno, M para Médio e G
para Grande)

Row( )

Retorna o número da linha da tela em que o cursor está posicionado. Veja o comando Col().

SaveScreen( nLin1,nCol1,nLin2,nCol2 )

Esta função retorna para uma variável caracter o conteúdo da tela dentro das coordenadas informadas. A tela poderá
ser restaurada com o uso da função RestScreen( ), na qual deve-se especificar a mesma variável utilizada para ar-
mazenar o conteúdo do retorno desta função. Veja a função RestScreen( ).

SetColor( [ cExp ] )

Ativa cores para vídeo conforme os códigos especificados em cExp. Se cExp não for especificado, esta função retor-
nará uma expressão contendo os códigos das cores atualmente em uso.

Os códigos usados nesta função são letras, conforme abaixo:

Cor Letra Cor Letra

Preta N Cinza N+

Azul B Azul claro B+

Verde G Verde claro G+

Cyan BG Cyan claro BG+

Vermelha R Vermelho claro R+

Magenta RB Magenta claro RB+

Marron GR Amarelo GR+

Branco W Branco intenso W+

SetCursor( nExp )

Ajusta o formado e tamanho do cursor. nExp deverá ser um código conforme a tabela abaixo:

Lógica e Conceitos Básicos de Programação - 31

 Tipo de cursor código Constante *

Nenhum ( ) 0 SC_NONE

Sublinhado ( _ ) 1 SC_NORMAL

Meio bloco inferior ( ▄ ) 2 SC_INSERT

Bloco inteiro ( █ ) 3 SC_SPECIAL1

Meio bloco superior ( ▀ ) 4 SC_SPECIAL2

* Obs.: as constantes poderão ser usadas no lugar do código se for especificado o respectivo #define no início do
programa.

SetDefault( aExp,cExp )

Habilita os padrões para impressão que são definidos pela função SetPrint( ). aExp é o vetor aReturn que é montado
pela função SetPrint( ) e cExp é o alias do arquivo a ser impresso.

SetPrint( cExp1, cExp2, cExp3, cExp4, cExp5, cExp6, cExp7, lExp8,,Exp9,cExp10, lExp11, lExp12, IExp13 )

Permite ajustar os padrões dos relatórios. Esta função trabalha em conjunto com a função SetDefault( ). Ela retorna o
nome do arquivo gerado em disco, caso seja solicitado este arquivo pelo usuário. Ao ser executada, SetPrint( ) mon-
ta o vetor aReturn. Os parâmetros são:

cExp1 Alias do arquivo principal a ser impresso, se existir.

cExp2 Nome padrão do relatório.
cExp3 Nome do grupo de perguntas. Pode ser o mesmo que cExp2
cExp4 Título do relatório
cExp5 Descrição do relatório (linha 1)
cExp6 Descrição do relatório (linha 2)
cExp7 Descrição do relatório (linha 3)
lExp8 Habilita (.T.) ou não (.F.) o dicionário de dados
aExp9 Vetor com ordens de indexação
lExp10 Habilita (.T.) ou não (.F.) a compressão do relatório
cExp11 Classificação do Relatorio por tambalho ( P para 80 cols., M para 132 colunas ou G para 220 colunas)
lExp12 Informe sempre NIL
lExp13 Habilita (.T.) ou não (.F.) o filtro do relatório.

O vetor aReturn gerado por esta função possui a seguinte estrutura:

 CIDS – Curso Interno para o Desenvolvimento do Suporte
elemento 1 reservado para Formulário
elemento 2 reservado para nº de vias
elemento 3 destinatário (departamento que irá utilizar o relatório_
elemento 4 Formato (1 para Comprimido ou 2 para Normal)
elemento 5 Mídia (1 para disco ou 2 para Impressora)
elemento 6 Porta (1-LPT1..., 4-COM1)
elemento 7 Expressão do Filtro
elemento 8 Ordem a ser selecionada
elemento 9, 10... Campos a processar (se houver)

SetRegua( nExp )

Configura a régua padrão de processamento dos relatórios do SigaAdvanced. nExp corresponde ao total de dados
(linhas, registros) a serem impresso. Esta função trabalha em conjunto com a função IncRegua( ).

Space( nExp )

Retorna uma variável com espaços em branco. A quantidade de espaços em branco é especificada pelo número em
nExp.

SubStr( cExp1, nExp2 [ , nExp3 ] )

Retorna uma parte da expressão cExp1. A parte de cExp1 considerada para retorno começará na posição de nExp2 e
terminará até que atinja o tamanho especificado em nExp3. Se nExp3 não for especificada, será considerado o resto
final de cExp1. Por exemplo:

SubStr( “ALEXANDRE” , 5) retornará “ANDRE”

SubStr( “P087G65D03” , 5 , 7 ) retornará “G65”.

Transform( cExp1,cExp2 )

Transforma o dado especificado em cExp1 em um formato genérico e com a máscara utilizada em cEsp2. As másca-
ras possíveis de serem utilizadas são as mesmas do comando Pict.

Valid Exp

Este comando deve ser usado junto com o comando @...Get ou com @...Say...Get. O Valid determina se a entrada
obtida no comando Get é válida ou não. Exp deve ser substituída por uma comparação ou por uma função de usuá-
rio. Se for usado a função de usuário, ela deve retornar .T. se a entrada for válida ou .F. se a entrada não for válida.

Lógica e Conceitos Básicos de Programação - 33

When Exp

Este comando deve ser usado junto com o comando @...Get ou com @...Say...Get. O When configura se o comando
Get deve ou não ser realmente executado. Exp deve ser substituída por uma comparação ou por uma função de usu-
ário. Se for usado a função de usuário, ela deve retornar .T. se a o Get tiver que ser executado ou .F. se não tiver que
ser executado.

While cExp
comandos
[ Loop ]
[comandos]
[ Exit ]
[comandos]
EndDo

Provoca um loop (faz com que os comandos existentes entre While e EndDo sejam executados várias vezes). cExp é
uma comparação ou uma função de usuário (que deverá retornar .T. ou .F.) que determinarão se o loop deve ser
executado e até quando. O comando Loop provoca um reinicio do loop (veja o comando). O comando Exit provoca a
interrupção do loop (veja o comando). E o comando EndDo determina onde o termina o conjunto de comandos que
pertencem ao loop.