INTRODUÇÃO A PROGRAMAÇÃO EM
LDR(r)
CR SISTEMAS LTDA.
AGOSTO/2011
HUMANUS® - PROGRAMAÇÃO EM LDR®
2
ÍNDICE
Introdução...................................................................................... 4
PDR - Processador Dirigido por Regra................................................... 5
Ajuda do Sistema............................................................................. 8
Algoritmo........................................................................................ 9
Regras........................................................................................... 11
LDR – Linguagem de Definição de Regras.............................................. 12
Exemplo de regra............................................................................. 17
Referência da Linguagem
Comados da LDR.......................................................................... 18
Atribuição .............................................................................. 18
BuscaMovimento .................................................................... 19
BuscaDados .......................................................................... 21
BuscaGrade........................................................................... 22
BuscaStatus .......................................................................... 22
CalcBenefício ........................................................................ 23
Caso...Seja (seleção múltipla)................................................... 25
Desvie ................................................................................. 26
EnquadraBenef....................................................................... 27
Exec Se ............................................................................... 28
Execute ............................................................................... 29
GravaStatus ......................................................................... 31
Interrompe .......................................................................... 32
Mensagem ........................................................................... 33
Pare ................................................................................... 33
Rótulo ................................................................................ 33
SalvaDados ......................................................................... 34
Se...Senao (execução condicional)............................................ 35
SetDecimais ........................................................................ 36
SetGrava ............................................................................ 36
SetProcRFixa ....................................................................... 37
Funções da LDR........................................................................... 39
Arredonda ............................................................................. 39
HUMANUS® - PROGRAMAÇÃO EM LDR®
3
Busca .................................................................................. 39
BuscaAcm ............................................................................ 40
BuscaUlt (BuscaUltima)............................................................ 41
BuscaVT ............................................................................... 41
CalcData .............................................................................. 42
CalcMedia ............................................................................. 42
CampoDeUsuario ................................................................... 45
Data .................................................................................... 45
DataTransferencia .................................................................. 46
DataUltimaAltSalarial .............................................................. 46
DataUltimoAfastamento .......................................................... 47
DataUltimoDissidio ................................................................. 47
DiasAfastados ....................................................................... 48
DiasAfastadosEspeciais ........................................................... 48
DiaDaSemana ....................................................................... 49
DiasCalendario ...................................................................... 49
DiasLicMatAno ....................................................................... 50
DifData ................................................................................ 51
Divisão (funções aritméticas).................................................... 51
Enquadra .............................................................................. 53
IndEconomico......................................................................... 55
MontaData ............................................................................ 55
MotivoUltimaAltSalarial............................................................. 56
NroPontosBeneficio................................................................. 56
ParteData ............................................................................. 56
Produto, soma, subtração (funções aritméticas)........................... 51
TemData .............................................................................. 57
TemMovimento ..................................................................... 57
Totaliza ................................................................................ 58
UltDiaMes ............................................................................. 59
ValorFolhaOrigem ................................................................... 59
HUMANUS® - PROGRAMAÇÃO EM LDR®
4
INTRODUÇÃO
Ao projetar a folha de pagamento do HUMANUS® tínhamos em mente criar um sistema
aberto, onde o usuário pudesse facilmente, ele mesmo, alterar os cálculos das rubricas da
folha, bem como modificar a ordem em que deveriam ser calculadas.
Na época (1995) o máximo de modernidade em termos de programação de folha de
pagamento era associar a cada rubrica uma função de avaliação de expressões aritméticas,
que manipulariam o cálculo final do valor da rubrica.
Como esta solução nos parecia insuficiente, partimos para uma definição própria. Definimos
um processador dedicado ao calculo de contas (uma rubrica nada mais é que uma conta),
baseado numa arquitetura como a dos processadores de hardware (Motorola, Intel, Microchip,
etc). Para esse processador definimos um conjunto de instruções de máquina (chamada
assembly) que resolve os problemas de comparação, controle e cálculo de valores.
Implementamos, então, um programa para emular esse processador, batizado de Processador
Dirigido por Regra (PDR).
Para controlar esse processador foi criada um ambiente de controle (uma placa-mãe por assim
dizer), que faz o “boot” do programa, carrega rubricas e dados dos colaboradores e efetua a
comunicação com outras partes do sistema.
Como é muito complicado para o ser humano programar diretamente em assembly, a
linguagem do processador, criamos a LDR-Linguagem de Definição de Regras, que é um
conjunto de instruções em português, fácil de aprender e usar, que tem todos os recursos para
definir os cálculos que a folha deve fazer. A regra de cálculo escrita em LDR é então traduzida
para o assembly do processador.
Nos capítulos seguintes abordaremos em detalhes o processador e faremos uma introdução ao
mundo da programação em LDR.
HUMANUS® - PROGRAMAÇÃO EM LDR®
5
PDR® – Processador Dirigido por Regra
O Processador Dirigido por Regra - PDR® foi especificamente projetado para o
HUMANUS® para executar o código gerado pelo tradutor da LDR® - Linguagem de
Definição de Regras. O processador é o componente central do ambiente operacional de
cálculo das folhas de pagamento. Para entender o funcionamento das Regras, que serão vistas
nos próximos capítulos, é necessário compreender esse ambiente onde se ocorre a execução
do código gerado para regra.
Inicialmente, é necessário saber que o código executável (chamado de código assembly
porque é o código que o processador entende) fica armazenado no banco de dados, numa
tabela própria. Veja mais detalhes no capítulo que trata das regras.
A estrutura interna do processador é formada por quatro bancos de memória de trabalho, uma
Memória de Programa (MP) e a Unidade de Cálculo e Lógica (UCL). Os quatro bancos de
memória são os seguintes:
banco de Rubricas: endereça todas as rubricas do sistema. Cada rubrica calculada
(chamadora) aponta para o (se diz que está linkada ao) código executável gerado pela
tradução do fonte da regra associada.
banco de variáveis: é uma memória de 32 posições onde são armazenados valores
durante o cálculo de uma regra. O escopo das variáveis é a regra.
banco de registradores globais: é uma memória de 32 posições globais, onde
podem ser armazenados valores durante a sessão de cálculo. O escopo é a sessão de
cálculo, portanto o conteúdo dos registradores globais é preservado entre o cálculo de
uma regra e outra. Podem ser vistos como se fossem variáveis globais.
banco de registradores internos: é um banco de memória especial, pré-definido,
que recebe os dados do ambiente operacional e do colaborador sendo calculado.
Na Memória de Programa (MP) é onde é carregado o código executável das regras.
A Unidade de Cálculo e Lógica é onde são executadas as instruções assembly do processador
geradas pela tradução das regras.
O processador é parte de uma estrutura operacional mais ampla, que efetua algumas
operações básicas de controle sempre que um cálculo é disparado.
Ao abrir o Diálogo de Cálculo de alguma Folha de Pagamento, o ambiente carrega na sua
memória de trabalho (MP) o código executável das regras associadas às rubricas da folha de
HUMANUS® - PROGRAMAÇÃO EM LDR®
6
pagamento sendo calculada. Em seguida, a rotina de controle seleciona as pessoas que
participarão do cálculo e selecionada a primeira pessoa (se for um cálculo individual esta é
única pessoa selecionada) e executa os seguintes passos:
i) carrega os lançamentos (movimento) da folha de pagamento no banco de rubricas do
processador, para a pessoa e folha selecionadas. As rubricas que tem lançamento são
assinaladas como tendo recebido movimento, o que aparece no registrador interno 57.
ii) carrega os Registradores Internos com os dados do ambiente (competência, folha
selecionada e seus parâmetros, dados da pessoa selecionada, etc).
iii) ativa a UCL e passa o controle para o código executável da primeira rubrica da folha, na
ordem de prioridade de cálculo.
O processador começa então a executar sequencialmente, de acordo com a prioridade
estabelecida pelos usuários, todas as regras associadas às rubricas chamadoras. Durante o
processamento, todos os valores sintetizados para cada rubrica ficam alimentados no próprio
banco de rubricas. Ao final da seqüência da pessoa selecionada, o banco de rubricas é
descarregado (gravado) na Ficha Financeira. Em seguida, o controle seleciona a próxima
pessoa e volta ao passo inicial (i) ou encerra, se o cálculo for individual.
Devido às características do ambiente, se uma alteração for feita em uma regra enquanto o
PDR® estiver ativo, esta alteração não terá efeito sobre o código já carregado.
O PDR® é implementado como um componente do sistema usando tecnologia ActiveX do
Windows®. (CRPDR77.dll)
A figura abaixo mostra esquematicamente a estrutura do processador PDR®.
HUMANUS® - PROGRAMAÇÃO EM LDR®
7
Copyright©1995,2011 - Linguagem de Definição de Regras - LDR® e Processador
Dirigido por Regra - PDR® são Marcas Requeridas de CR Sistemas Ltda.
Copyright© CR Sistemas Ltda. Todos os direitos reservados.
HUMANUS® - PROGRAMAÇÃO EM LDR®
8
AJUDA DO SISTEMA
O HUMANUS possui uma ajuda on-line detalhada e completa da LDR: sua estrutura, tipos de
dados, comandos e funções, todos com exemplos de utilização.
Também há uma ajuda sobre o ambiente de programação, que é parte do módulo Gerenciador
de Regras. Este ambiente é o Editor de Regras, que possui todos os recursos para programar e
testar as regras desenvolvidas, inclusive com recursos de depuração (técnica de caçar erros
num programa) que permite inclusive o monitoramento de execução linha a linha da regra.
HUMANUS® - PROGRAMAÇÃO EM LDR®
9
ALGORITMO
Para que possamos solucionar um problema, qualquer que seja, necessitamos cumprir um
certo número de passos, quais sejam:
analisar o problema
identificar as soluções possíveis
verificar os recursos disponíveis
escolher a solução mais adequada
Para começar a implementar a solução escolhida, é necessário decompor o problema em
problemas menores, menos complexos, mais gerenciáveis. Estabelecer os procedimentos
necessários, em que ordem devem ser executados, com que recursos, etc. O roteiro da
solução do problema, com todos os seus passos, pode ser chamado de programa ou de
algoritmo.
Dando um exemplo. Imaginemos a operação de troca de um pneu furado de um automóvel.
Obviamente que a roda com o pneu furado não pode ser removida se o carro não for antes
levantado com o macaco. Antes, e preciso verificar uma condição: o carro está com o freio-de-
mão acionado? Se não estiver, acione-o; se estiver siga adiante. Agora, para obter o macaco, é
necessário abrir o porta-malas ou outro compartimento onde ele se encontra. Mesmo com o
carro levantado no macaco, não podemos tirar a roda sem remover os parafusos que a
prendem. Precisamos da chave de rodas.
Se fossemos escrever em bom português num pedaço de papel todos os passos necessários
para esta operação aparentemente simples, descobriríamos que inúmeros passos (instruções)
e recursos são necessários; que devem ser executados numa ordem lógica; que certas
condições têm que ser verificadas, etc. Ou seja, teríamos escrito um pequeno programa ou
algoritmo que define com precisão cada passo da solução de uma problema, não deixando
espaço para adivinhações ou chutes. A este texto de instruções compreensíveis pelo ser
humano se chama fonte da solução (ou do programa).
Quando se trata de computadores a coisa se torna um pouco mais crítica porque computadores
são máquinas burrinhas: é necessário dizer a elas exatamente o que fazer e como fazer. Nada
pode ser deixado para o acaso. O computador não adivinha coisa alguma e não tem
capacidade de "chutar" uma saída.
Uma ferramenta muito útil para estruturar um algoritmo é o fluxograma. Como o nome diz, um
fluxograma mostra de forma gráfica a seqüência das instruções, os testes de condição e
desvios para trechos específicos, permitindo visualizar a solução do problema antes de
começar a implementá-la numa linguagem de programação.
HUMANUS® - PROGRAMAÇÃO EM LDR®
10
No capítulo seguinte abordaremos como são estruturadas as regras de cálculo do Humanus®,
que são algoritmos que resolvem cálculos das rubricas das folhas de pagamento.
HUMANUS® - PROGRAMAÇÃO EM LDR®
11
REGRAS
Uma regra nada mais é do que um pequeno programa de computador, escrito numa linguagem
própria do sistema batizada de LDR®, cuja finalidade é definir como deve ser realizado o
cálculo de determinado valor associado a uma Rubrica de uma dada Folha de Pagamento.
Para tanto a regra tem acesso aos dados do sistema, disponíveis através de um conjunto de
registradores (os Registradores Internos). A regra pode testar os valores dos registradores,
alterá-los, armazená-los em variáveis ou Registradores Globais para usar mais tarde, tudo
obedecendo a uma lógica, a mesma lógica que seria usada provavelmente se o cálculo fosse
feito de forma manual.
Os comandos e funções da linguagem permitem que a regra faça qualquer cálculo, busque
dados no Banco de Dados, busque médias históricas, altere formatos de saída, habilite ou
desabilite rubricas para cálculo, etc.
Os comandos permitem execuções condicionais de certos trechos da regra dependendo do
valor de uma dado que pode ser testado.
As regras se dividem em Vinculadas (chamadoras) e Independentes (chamadas).
A regra Vinculada (chamadora) tem que estar associada a uma Rubrica de qualquer natureza
diferente de base, para ser executada pelo PDR®, que é máquina de cálculo do sistema. Uma
regra associada a uma Rubrica pode invocar a execução de outra regra independente.
O texto contendo as instruções da regra é chamado de fonte da regra.
As regras ficam armazenadas no Banco de Dados em duas tabelas distintas: uma contém os
fontes das regras e outra contém o código executável (gerado pela tradução da regra) aceito
pela máquina de cálculo. Com esta última o usuário não precisa se preocupar, pois ela é
inteiramente gerenciada pelo sistema.
Os fontes das regras constituem as próprias regras e ficam armazenada no Cadastro de
Regras. No próximo capítulo examinaremos a estrutura da LDR® em mais detalhe.
HUMANUS® - PROGRAMAÇÃO EM LDR®
12
LDR® - Linguagem de Definição de Regras
A LDR® define o sistema HUMANUS® como um sistema aberto (nada a ver com GNU/GPL e
software livre) no que se refere ao conjunto de Rubricas e aos cálculos das folhas de
pagamentos. Nenhuma rubrica é pré-definida no sistema e nenhum cálculo de folha está
codificado (hardcoded) nos programas do sistema. Todos os cálculos são efetuados por regras
escritas em LDR®. O sistema já sai de fábrica com um conjunto básico de regras que
compõem as formas mais comuns de folhas de pagamento.
A LDR® é uma linguagem baseada num subconjunto de termos da língua portuguesa e
objetiva dar ao usuário liberdade e flexibilidade para criar procedimentos particularizados de
cálculos que atendam às suas necessidades. Adicionalmente, o usuário fica livre para fazer ele
mesmo os ajustes nas regras de cálculo dos diversos tipos de folhas de pagamentos que
possuir, sempre que alterações legais o exigirem, sem depender de eventualmente custosas e
demoradas alterações de programas do sistema.
É uma linguagem simples, com poucos comandos, porém poderosa. Permite ao usuário
resolver praticamente qualquer forma de cálculo que ele necessitar. Além disso, é uma
linguagem evolutível, que vai recebendo constantemente novas extensões que a tornam cada
vez mais possante.
O tradutor da LDR® está implementado como um componente ActiveX do sistema
(CRLDR77.dll).
HUMANUS® - PROGRAMAÇÃO EM LDR®
13
Estrutura da Linguagem
A linguagem LDR® possui uma estrutura muito simples. É composta de uma estrutura de
dados e de poucos comandos e várias funções. A maioria das operações é realizada pelas
funções.
Tipos de Dados
Cada elemento da estrutura de dados da LDR® possui um tipo que caracteriza a natureza
de seu conteúdo e forma de apresentação. Os tipos de dados tratados na LDR® são os
seguintes:
Numérico: representam valores inteiros ou reais (decimais), positivos ou negativos. O
sistema controla para não ocorrer estouro da capacidade de representação dos valores e limita
o número de casas decimais após a vírgula em 6 (seis). O formato de saída depende de cada
tela da aplicação.
Nas regras a precisão de uma dado numérico pode ser controlada pelo comando
SetDecimais.
Data: como é óbvio, representam apenas datas, sempre no formato dd/mm/aaaa. Somente
datas válidas são armazenadas. Este tipo de dado é manipulado através de funções de
tratamento de datas. A ausência de conteúdo é representada pela string nula (par de aspas
duplas-""). Admite a constante tipo data no formato dd/mm/aaaa, sem aspas.
String: representam seqüências de caracteres alfanuméricos (letras, dígitos e alguns
caracteres especiais), limitadas em tamanho a 32 caracteres. Strings são envoltas por aspas
duplas. Ex.: "dado tipo texto", "M", etc. Uma string pode conter uma data no formato
"dd/mm/aaaa", que seve ser tratada pela função Data().
Estruturas de Dados
Por Estruturas de Dados se compreende as diversas formas de representar e manipular as
diferentes informações no contexto de um programa de computador.
A Linguagem de Definição de Regras - LDR®, embora simples, é uma linguagem de
programação e possui uma estrutura de dados simples mas poderosa, composta dos seguintes
elementos de dados:
Variáveis: representam lugares, localizações internas da máquina de cálculo (processador),
numeradas de 0 a 31 (são 32 localizações ou endereços), as quais o usuário poderá utilizar
para armazenar diversos dados temporariamente, durante os cálculos. O usuário não lida
HUMANUS® - PROGRAMAÇÃO EM LDR®
14
diretamente com os endereços numéricos, mas atribui nomes a eles. Este processo se chama
declarar uma variável. Ao ser declarada, a variável e seu tipo é inserida numa caixa de
variáveis do Editor. A partir daí poderá ser usada no fonte da regra.
Rubricas: permitem que as regras trabalhem com as rubricas cadastradas. Cada rubrica
possui dois campos que são utilizados pelas regras: referência e Valor. A LDR® referencia
os campos das rubricas com o seguinte formato: #nnnR e #nnnV , respectivamente campo
de Referência e Valor da rubrica nnn. Rubricas têm sempre o tipo de dado Numérico, pois só
lidam com valores.
Assim como as variáveis, as rubricas precisam ser definidas para serem usadas na regra. A
isto se chama declarar a rubrica. Ao ser declarado, o Identificador da Rubrica é inserido numa
caixa de rubricas do Editor.
Registradores Internos(RI): são estruturas pré-definidas do sistema que armazenam dados
do Colaborador e do ambiente operacional. O usuário não pode incluir novos registradores nem
remover quaisquer dos existentes. Os Registradores Internos não precisam ser declarados
previamente para serem usados, como ocorre com as rubricas e variáveis, e possuem os
mesmos tipos de dados definidos pela LDR®. A picklist dos Registradores mostra, na última
coluna à direita, o tipo de dado do Registrador Interno. O escopo dos Registradores Internos é
em nível de Colaborador.
Registradores Globais(RG): assim como os Registradores Internos, os Registradores
Globais são estruturas pré-definidas na arquitetura do Processador PDR®. Mas,
diferentemente dos RI, estres registradores não trazem qualquer informação pré-definida e
seu escopo é a seção de cálculo, isto é, do primeiro ao último Colaborador. Seu conteúdo é
preservado do cálculo de um Colaborador para outro e de uma regra para outra.
Constantes: como o próprio nome sugere, constantes são informações fixas que o usuário
escreve no texto do fonte da regra. São informações autônomas, que não vêm de qualquer
lugar do sistema e são supridas através da própria regra. Constantes tipo string devem ser
envoltas por aspas "", constantes numéricas podem ser compostas por dígitos, o sinal de
negativo e a vírgula como separador decimal. A constante data deve ser escrita sem aspas e
no formato dd/mm/aaaa.
Os elementos de estruturas de dados acima descritos possuem Tipos de Dados que definem a
natureza e formato dos dados que elas representam.
As Variáveis, Registradores Internos e Globais e Constantes podem ter qualquer dos
três tipos de dados. Rubricas são sempre numéricas (tipo N).
O tipo das variáveis são prefixados no nome das mesmas pelos caracteres %, !, $,
respectivamente: numérico, data e texto (string).
HUMANUS® - PROGRAMAÇÃO EM LDR®
15
Comentários:
A LDR® permite que o usuário escreva comentários explicativos no fonte da regra, o que é
uma boa prática, pois facilita a compreensão dos objetivos da regra, nas alterações futuras,
especialmente se forem realizadas por outra pessoa que não aquela que criou a regra.
Comentários não são traduzidos para o código executável da regra. Um comentário começa
com o caracter / (barra invertida) e vai até o final da linha.
Comandos da LDR
A LDR® - Linguagem de Definição de Regras possui os seguintes comandos:
Atribuição
BuscaMovimento
BuscaDados
BuscaGrade
BuscaStatus
CalcBenefício
Caso...Seja
Desvie
EnquadraBenef
Exec Se
Execute
GravaStatus
Interrompe
Mensagem
Pare
Rótulo
SalvaDados
Se...Senao
SetDecimais
SetGrava
SetProcRFixa
Funções da LDR
A LDR® - Linguagem de Definição de Regras possui as seguintes funções:
Arredonda
Busca
BuscaAcm
BuscaUlt
BuscaVT
CalcData
CalcMedia
CampoDeUsuario
Data
DataTransfer
HUMANUS® - PROGRAMAÇÃO EM LDR®
16
DataUltimaAltSalarial
DataUltimoAfastamento
DataUltimoDissidio
DiasAfastados
DiasAfastadosEspeciais
DiaDaSemana
DiasCalendario
DiasLicMatAno
DifData
Divisão
Enquadra
IndEconomico
MontaData
MotivoUltimaAltSalarial
NroPontosBeneficio
ParteData
Produto
Soma
Subtração
TemData
TemMovimento
Totaliza
UltDiaMes
ValorFolhaOrigem
HUMANUS® - PROGRAMAÇÃO EM LDR®
17
EXEMPLOS DE REGRA
REGRA: R108 [Calc. Horas Noturnas]
/ cálculo das horas noturnas
se RI0057 = 0 / não há movimento
Pare
senao
se RI0055 <> 0
#108R=#108R
#108V=#108V
Pare / o valor foi informado
fim
fim
se RI0057 = 1 / gerado pelo sistema (horário)
#108R = mult(#108R ; RI0051)
senao
#108R=#108R
fim
V1=mult(#611V ; 0,20)
#108V = mult( #108R ; V1)
Representação em fluxograma da mesma regra:
HUMANUS® - PROGRAMAÇÃO EM LDR®
18
REFERÊNCIA DA LINGUAGEM
Comandos da LDR
Atribuição
Copia (atribui) um valor num identificador. É representado pelo símbolo de igual (=).
Sintaxe:
<ident> = <operando> | <expr_aritmética>
Descrição:
<ident> :deve ser uma Variável declarada, identificador de Rubrica, Registrador Interno ou
Global.
<operando> :poder ser qualquer dado válido ou uma função. O tipo de dado do <operando> deve
ser igual ao do <ident>.
<expr_aritmética> : avalia a expressão aritmética e atrubui o seu resultado em <ident>.
Notas:
1)O lado esquerdo da atribuição (<ident>) nunca pode ser uma constante, pois estas não
representam endereços dentro da máquina de cálculo.
2)Se o lado esquerdo da atribuição for uma Rubrica, a máquina de cálculo verificará as bases de
incidências desta rubrica e executará as acumulações que houver. Portanto, dentro de uma regra, é
necessário cuidar para que a atribuição numa rubrica seja executada apenas uma vez. Se a rubrica
receber várias atribuições, poderá acumular nas bases várias vezes, gerando um erro de cálculo. Use
variáveis pára cálculos intermediários, se necessário.
Exemplo de comando de ATRIBUIÇÃO:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando de atribuição
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: calcular um adicional de 30% sobre o salário nominal
/ *********************************************************
SALARIO = RI00001 / a variável SALARIO recebe o valor do Reg. Interno RI0001
ADIC = Mult ( SALARIO ; 0,3) / atribui 30 % do salário à variável ADIC
/ Atribui ao campo Referencia da rubrica 150 o percentual
#150R = 0,3
/Atribui ao campo Valor da mesma rubrica o adicional calculado
#150V = ADIC
HUMANUS® - PROGRAMAÇÃO EM LDR®
19
BuscaMovimento
Recupera (busca) valores de uma rubrica do Movimento e retorna-os nas variáveis passadas como
argumento.
Sintaxe:
BuscaMovimento ( <dtCompet> ; <folha> ; <dtIniVig> ; <idRub> ; <modo> ; <idVarRef> ;
<idVarVlr> )
Descrição:
<dtCompet> : data da competência.
<folha> : Código da Folha cujo movimento contém a rubrica a ser buscada. É um dado tipo
String.
<dtIniVig> : Opcional. Data de início de vigência da folha dentro da competência. Deve ser um
dado tipo DATA. Uma constante tipo String nula ("") deve ser informada, se não interessar a
vigência. A busca será baseada apenas na competência e tipo de folha.
<IdRub> : Código da Rubrica a ser buscada.Deve ser uma constante numérica. O tipo da rubrica
depende do proximo parâmetro <modo>.
<modo> : determina como serão obtidos os dados da rubrica:
0 - será efetuado o somatório das rubricas do Movimento vinculadas à uma BASE, passada
como parâmetro em <IdRub>.
1 - será buscada apenas a rubrica identificada em <IdRub>.
<IdVarRef> - deve ser uma variável Numérica, previamente declarada. Recebe o valor (ou
somatória) do campo Referência da Rubrica.
<IdVarVlr> - deve ser uma variável Numérica, previamente declarada. Recebe o valor (ou
somatória) do campo Valor da Rubrica.
O comando retorna zeros nas variáveis se não existir a rubrica especificada por <idRub> no
Movimento, se <idRub> não for uma base e o <modo> for zero ou se não houver rubricas
incidentes sobre a base passada como parâmetro.
Como funciona:
O comando busca diretamente a rubrica passada como parâmetro se o <modo>=1 for indicado; se
passado <modo>=0, então a rubrica passada deve ser uma base e as rubricas a serem somadas
devem estar assinaladas como incidentes nesta base.
As variáveis passadas para receber os campos Referência e Valor devem ser usadas na linha
imediatamente seguintes à linha onde está a chamada do comando. Lembrar que as variáveis são
visíveis em toda a Regra. Assim, se uma nova Atribuição for feita na variável ANTES de usar o
valor retornado pelo comando, este valor será perdido (sobregravado pelo novo valor atribuído).
HUMANUS® - PROGRAMAÇÃO EM LDR®
20
Exemplo de comando BuscaMovimento:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando CalcBeneficio
/**********************************************************
/ Regra XXXX criada em 11/10/1999 por C.Carravetta
/ Objetivo: somar os lancamentos nas rubricas associadas a base 843
/ **********************************************************
/ ------------------------- uso correto ---------------------
BuscaMovimento ( RI0049 ; /Competencia
"0111" ; /Folha do Movimento
"" ; /Vigência (opcional)
843 ; / Rubrica base
V1 ; V2 ) / V1 e V2 devem estar declaradas
/ usa os valores retornados imediatamente após
#MMMV = V1 / campo referência (somatória)
#NNNV = V2 / campo valor (somatória)
/
/ ----------------------- uso incorreto --------------------
BuscaMovimento ( RI0049 ; /Competencia
"0111" ; /Folha do Movimento
"" ; /Vigência (opcional)
843 ; / Rubrica base
V1 ; V2 ) / V1 e V2 devem estar declaradas
V1 = 23 /atribui novo valor antes de usar a variável retornada pelo comando
#MMMV = V1 /aqui vai atribuir 23 à rubrica #MMMV e não o
/valor retornado pelo comando
#NNNV = V2 / V2 não foi alterada, mantendo o valor calculado
HUMANUS® - PROGRAMAÇÃO EM LDR®
21
BuscaDados
Recupera (busca) valores de um registro de status individual identificado por um identificador e
informações de folha e competência e retorna os valores nas variáveis passadas como argumento.
Este registro deve ter sido gerado pelo comando SalvaDados.
Sintaxe:
BuscaDados ( <idData> ; <idFolha> ; [idCarac>] ; <idData> ; <idStr> ; <idVarNum> ;
<idVarData> ; <idVarString> )
Descrição:
<idData> - data de competência.
<idFolha> - código da folha de pagamento a que se referem os dados.
<idCarac> - característica da folha: 0-Normal, 1-Complementar. É opcional e pode ser informada a
string nula "".
<idData> - data de vigência da folha.
<idStr> - nome de indentificação do registro de dados.
<idVarNum> - deve ser uma variável Numérica, previamente declarada. Recebe o valor
recuperado do primeiro campo.
<idVarData> - deve ser uma variável tipo Data, previamente declarada. Recebe o valor recuperado
do segundo campo.
<idVarString> - deve ser uma variável tipo String, previamente declarada. Recebe o valor
recuperado do terceiro campo.
Comentários:
A posição das variáveis define o seu tipo, sendo a primeira Numérica, a segunda Data e a terceira
String. O Tradutor verifica se esta semântica é obedecida.
As posições que não interessam recuperar devem ser deixadas em branco, isto é, sem indicação de
variável de retorno. Entretanto, ao menos uma variável tem que estar indicada.
As variáveis passadas para receber os campos de dados devem ser usadas na linha imediatamente
seguintes à linha onde está a chamada do comando. Lembrar que as variáveis são visíveis em toda a
Regra. Assim, se uma nova Atribuição for feita na variável ANTES de usar o valor retornado pelo
comando, este valor será perdido (sobregravado pelo novo valor atribuído).
O comando BuscaDados funciona de forma semelhante ao comando BuscaStatus.
HUMANUS® - PROGRAMAÇÃO EM LDR®
22
BuscaGrade
Comando específico utilizado por alguns clientes sob forma de customização. Retorna a situação do
grade do colaborador dentro do intervalo de datas especificado, baseando-se na última condição e
data da última alteração independente do intervalo informado.
Sintaxe:
BuscaGrade ( <dtInicio>; <dtFim>; <tipoAlteracao>; <condicao>; <dtUltimaAlteracao> )
Descrição:
Parâmetros Informados:
<dtInicio> : data de Início do intervalo (dd/mm/aaaa).
<dtFim> : data de Fim do intervalo (dd/mm/aaaa).
Parâmetros Retornados:
<tipoAlteração> : último tipo de alteração.
<condicao> : última condição.
<dtUltimaAlteracao> : data da última alteração independente do intervalo acima (dd/mm/aaaa).
BuscaStatus
Recupera (busca) valores de um registro de status individual identificado por número e retorna os
valores nas variáveis passadas como argumento. Este registro deve ter sido gerado pelo comando
GravaStatus.
Sintaxe:
BuscaStatus ( <idNum> ; <idVarNum> ; <idVarData> ; <idVarString> )
Descrição:
<idNum> - constante numérica de 1 a 99, que identifica o registro de status.
<idVarNum> - deve ser uma variável Numérica, previamente declarada. Recebe o valor
recuperado do primeiro campo.
<idVarData> - deve ser uma variável tipo Data, previamente declarada. Recebe o valor recuperado
do segundo campo.
<idVarString> - deve ser uma variável tipo String, previamente declarada. Recebe o valor
recuperado do terceiro campo.
Comentários:
A posição das variáveis define o seu tipo, sendo a primeira Numérica, a segunda Data e a terceira
String. O Tradutor verifica se esta semântica é obedecida.
HUMANUS® - PROGRAMAÇÃO EM LDR®
23
As posições que não interessam recuperar devem ser deixadas em branco, isto é, sem indicação de
variável de retorno. Entretanto, ao menos uma variável tem que estar indicada.
As variáveis passadas para receber os campos de status devem ser usadas na linha imediatamente
seguintes à linha onde está a chamada do comando. Lembrar que as variáveis são visíveis em toda a
Regra. Assim, se uma nova Atribuição for feita na variável ANTES de usar o valor retornado pelo
comando, este valor será perdido (sobregravado pelo novo valor atribuído). Veja Exemplos.
Exemplo de comando BuscaStatus:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando BuscaStatus
/**********************************************************
/ Regra XXXX criada em 05/11/1999 por C.Carravetta
/ Objetivo: recupera registro de status número 3
/ **********************************************************
/ ------------------------- uso correto ---------------------
/ usar os valores retornados imediatamente após o comando
/ VNUM, VDATA e VSTR são variaveis declaradas
/ Recuperando os três campos
BuscaStatus ( 3 ; VNUM ; VDATA ; VSTR )
#MMMV = VNUM / usa informação Numerica
/ Recuperando apenas o primeiro
BuscaStatus ( 3 ; VNUM ; ; )
#MMMV = VNUM / usa informação Numerica
/ Recuperando apenas o segundo
BuscaStatus ( 3 ; ; VDATA ; )
..... / ----------------------- uso incorreto --------------------
BuscaStatus ( 3 ; VNUM ; ; )
VNUM = 23 /atribui novo valor antes de usar a variável
/ retornada pelo comando
#MMMV = VNUM /aqui vai atribuir 23 à rubrica #MMMV e não o
/valor retornado pelo comando
CalcBeneficio
Avalia os valores, para o Benefício especificado, do Colaborador sendo calculado e seus
dependentes.
Sintaxe:
CalcBeneficio ( <"códBeneficio"> ; <parteColaborador> ; <parteEmpresa> )
HUMANUS® - PROGRAMAÇÃO EM LDR®
24
Descrição:
<"códBenefício"> : código do Benefício cujos valores serão avaliados. Deve ser uma constante
string, entre aspas duplas.
<parteColaborador> : deve ser uma variável com tipo de dado Numérico, previamente declarada.
Recebe a parte do valor total do Benefício que corresponde ao Colaborador, ponderado de acordo
com o complemento da parte assumida pela Empresa em relação a 100% (cem por cento).
<parteEmpresa> : deve ser uma variável com tipo de dado Numérico, previamente declarada.
Recebe a parte do valor total do Benefício assumido pela Empresa, calculado de acordo com o
percentual assumido pela Empresa, definido em cada Faixa de Valores.
As variáveis acima devem ser diferentes entre sí.
Como funciona:
O comando avalia todas as ocorrências do Benefício especificado, para o Colaborador e seus
dependentes beneficiários, retornando nas variáveis as somas dos valores das Faixas de Valores
para cada Plano do Benefício, de acordo com o Tipo de Beneficiário de cada ocorrência, já
ponderados conforme os percentuais assumidos pela Empresa em cada Faixa.
O comando deve ser chamado (executado) para cada Benefício a ser calculado. Se o Benefício
expresso por <"códBenefício"> não existir, uma mensagem de erro será exibida e o cálculo
interrompido.
As variáveis passadas para receber a <parteColaborador> e <parteEmpresa> devem ser usadas na
linha imediatamente seguintes à linha onde está a chamada do comando. Lembrar que as variáveis
são visíveis em toda a Regra. Assim, se uma nova Atribuição for feita na variável ANTES de usar o
valor retornado pelo comando, este valor será perdido (sobregravado pelo novo valor atribuído).
Veja Exemplos.
Exemplo de comando CalcBeneficio:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando CalcBeneficio
/**********************************************************
/ Regra XXXX criada em 27/03/1999 por C.Carravetta
/ Objetivo: calcular os valores para o Benefício B001
/ **********************************************************
/ ------------------------- uso correto -------------------------------
CalcBeneficio ( "B001" ; V1 ; V2 ) / V1 e V2 devem estar declaradas
/ usa os valores retornados imediatamente após
HUMANUS® - PROGRAMAÇÃO EM LDR®
25
#MMMV = V1 / parte do colaborador
#NNNV = V2 / parte da Empresa
/
/ ----------------------- uso incorreto --------------------------------
CalcBeneficio ( "B001" ; V1 ; V2 ) / V1 e V2 devem estar declaradas
V1 = 23 /atribui novo valor antes de usar a variável retornada pelo comando
#MMMV = V1 /aqui vai atribuir 23 à rubrica #MMMV e não o
/valor retornado pelo comando
#NNNV = V2 / a var V2 não foi alterada, mantendo o valor calculado
Seleção Múltipla
O comando executa apenas um dentre vários blocos de comandos, dependendo do valor de uma
expressão relacional.
Sintaxe:
Caso <ident>
Seja <opRelacional> <operando> :
<comandos>
....
Seja <opRelacional> <operando>:
<comandos>
fim
Descrição:
<ident> : pode ser qualquer estrutura de dados exceto constante.
<opRelacional> : é um Operador Relacional.
<operando> : deve ser uma constante compatível em tipo de dado com <ident>.
<comandos> : quaisquer comandos ou funções, inclusive outro comando CASO...SEJA.
HUMANUS® - PROGRAMAÇÃO EM LDR®
26
O comando avalia cada expressão formada por <ident><opRelacional><operando> e executa o
bloco de <comandos> da entrada Seja que resultar verdadeira e desvia para o primeiro comando
após a cláusula fim. Se nenhuma condição for verdadeira, o comando termina sem executar
qualquer dos blocos de comandos.
Os blocos de <comandos> podem conter outros comandos CASO...SEJA.
Exemplo de comando CASO...SEJA:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando CASO...SEJA
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: calcular um adicional de 30% , 20% ou 10% sobre o salário nominal
/ dependendo do valor deste
/ *********************************************************
SALARIO = RI00001 / a variável SALARIO recebe o valor do Reg. Interno RI0001
Caso SALARIO / inicializa a condição
Seja > 1000,00 :
ADIC= Mult ( SALARIO ; 0,1 )
Seja > 700,00 :
ADIC=Mult ( SALARIO ; 0,2 )
Seja <= 700,00 :
ADIC=Mult ( SALARIO ; 0,3 ) / em último caso entra aqui e calcula 30%
fim
Desvie
Desvia incondicionalmente o fluxo de execução da regra para o rótulo indicado.
Sintaxe:
Desvie [ para ] :<rotulo> [:]
HUMANUS® - PROGRAMAÇÃO EM LDR®
27
Descrição:
<rotulo> : nome dado a uma posição do texto fonte que corresponde a uma linha dentro do código
executável. O rótulo é simplesmente declarado no ponto mais conveniente do texto fonte da regra,
de acordo com a lógica traçada pelo usuário. Se <rotulo> não for declarado um erro de sintaxe será
emitido pelo Tradutor.
Exemplo de comando de DESVIO INCONDICIONAL:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando de desvio incondicional
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: aplicar algum tratamento apenas aos salários menores que 1000,00
/ **********************************************************
SALARIO = RI00001 / a variável SALARIO recebe o valor do Reg. Interno RI0001
/ testa: se SALARIO é maior que 1000,00 sai fora e não calcula nada
Se SALARIO > 1000,00
Desvie para :SAIDA:
fim
/
/ comandos para o caso de SALARIO <= 1000,00
/
:SAIDA:
/comandos para a saida
..........
EnquadraBenef
Comando específico utilizado por alguns clientes sob forma de customização. Funciona de forma
idêntica a função Enquadra, a diferença é a utilização de um conjunto de tabelas de faixas de
valores própria para o cálculo de benefícios.
Enquadra o vlrBase na Tabela <idTab>.
HUMANUS® - PROGRAMAÇÃO EM LDR®
28
Sintaxe:
EnquadraBenef ( "idTab"; <data>; <modoEnq>; <vlrEnq>; <vlrBase>; <vlrResult>;
<nroDias> )
Descrição:
Parâmetros Informados:
"idTab" : deve ser uma constante String especificando o Código da Tabela de Faixas de Valores.
Deve ser envolta por aspas duplas (").
<data> : data de vigência da tabela. Deve ser um dado tipo Data.
<modoEnq> : determina a forma de identificação da tabela em relação à data de vigência:
0 (zero): a função toma a tabela cuja data de vigência é igual ou menor que a data
especificada em <data> , isto é, busca a mais recente anterior.
1 (um): a função busca exclusivamente a tabela da <data> . Se não encontrar um erro
ocorre e força a interrupção do cálculo.
A função leva à tabela identificada, da data de vigência dada por <data>, o <valorEnq> a
enquadrar. Identificando em que faixa este valor recai, aplica os fatores desta faixa sobre o
<valorBase>, conforme a fórmula abaixo:
((<valorBase> x FatMult ) / FatDiv ) + (VlrAgregar - VlrDeduzir)
O resultado desta fórmula é comparado com o valor de Teto. Se for menor ou igual, retorna o
resultado. Caso contrário retorna o teto.
<valorEnq> : valor para enquadramento. É o valor que será levado à tabela para ser identificada a
faixa de cálculo. Pode ser um dado do tipo Numérico.
<valorBase> : valor sobre o qual serão aplicados os fatores de Multiplicação e Divisão da faixa.
Pode ser um dado do tipo Numérico.
Parâmetros de Retorno:
<vlrResult> : retorna o resultado da operação citada acima.
<nroDias> : campo número de dias da faixa selecionada.
Exec Se
Testa se o valor de um identificador pertence a uma lista de constantes.
Sintaxe:
Exec [Se] <ident> Em [ <constante> [ ; <constante> ...] ] <comandos> Fim
Descrição:
O comando testa se o conteúdo de <ident> está contido na lista de constantes entre colchetes e
executa o bloco de <comandos> caso esteja. Senão, desvia para o primeiro comando após a palavra
HUMANUS® - PROGRAMAÇÃO EM LDR®
29
reservada fim. O <ident> pode ser variável, Idendifcador de Rubrica, Registrador Interno ou
Global , todos do tipo Numerico ou string.
As constantes <constante> da lista podem ser Numéricas ou Strings de acordo com o tipo de dado
do <ident>. É obrigatório pelo menos uma constante na lista e pode ter tantas constantes quantas
forem necessárias, separadas por ponto e vírgula (;). Vale lembrar que o número de constantes na
lista impacta o tempo de execução do comando, ou seja, quanto maior a lista, mais tempo leva para
avaliá-la.
Exemplo de comando EXEC...SE:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando Exec Se
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: calcular um adicional se o Estado Civil constar de uma lista
/ *********************************************************
/ O Reg Interno RI0014 contém o Estado Civil do colaborador
Exec Se RI0014 Em [ "C" ; "S" ; "V" ]
ADIC = { RI0001 * 0,3 } / atribui 30% do salário à variável ADIC
fim
....
Execute
Este comando permite executar uma regra independente a partir de outra regra.
Sintaxe:
Execute @<idRegra>
Descrição:
@<idRegra> - nome de uma Regra independente com até 20 caracteres. O símbolo @ é parte da
sintaxe.
HUMANUS® - PROGRAMAÇÃO EM LDR®
30
O comando verifica se a regra <idRegra> chamada existe e transfere a execução para ela. Após a
conclusão de <idRegra> o fluxo dos comandos segue na linha seguinte à linha de chamada do
comando, na regra chamadora.
A Regra identificada por <idRegra> deve ser independente, isto é, deve ser do tipo Independente e,
portanto, não estar associada à qualquer Rubrica. A existência da Regra chamada não é verificada
em tempo de tradução, mas somente em tempo de execução.
Uma Regra Independente pode chamar outra independente e assim por diante.
Uma Regra não pode chamar a sí própria (recursão).
Nota: cuidado deve ser tomado para não provocar um cruzamento de chamada (tecnicamente
chamado de Abraço Mortal (deadlock)), isto é, fazer uma Regra A chamar uma outra Regra B e
esta, por sua vez, chamar novamente a Regra A. Elas podem, nesse caso, travar-se mutuamente.
Exemplo de comando EXECUTE:
/ Copyright(c) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando Execute
/**********************************************************
/ Regra XXXX criada em dd/mm/aaaa por Fulano
/ Objetivo: chama uma Regra para executar um calculo global
/ *********************************************************
/ Regra CHAMADORA
/ A Regra passa um valor no RG01 e recebe no RG02
...
RG01%= 1 /alimenta RG01 como um parametro
Execute @CalcSal /chama a Regra
SAL = RG02% /segue a execução após o término da regra chamada.
....
/ Copyright(c) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando Execute
/**********************************************************
HUMANUS® - PROGRAMAÇÃO EM LDR®
31
/ Regra CalcSal criada em dd/mm/aaaa por Fulano
/ Objetivo: calcula um valor dependendo do conteúdo de RG01
/ *********************************************************
/ Regra CHAMADA
/ A Regra recebe um valor no RG01 e devolve no RG02
/
se RG01%= 1 /testa o parâmetro
RG02%= { RI0001 * 0,1 }
senao
RG02% = RI0001
Fim
/retorna o controle para a regra chamadora
GravaStatus
Este comando grava um registro de status individual identificado por número. Este registro pode
ser recuperado pelo comando BuscaStatus.
Sintaxe:
GravaStatus ( <idNum> ; <idNum> ; <idData> ; <idString> )
Descrição:
<idNum> - dado Numérico que identifica o registro de status. Recomenda-se que esteja entre 1 a
99.
<idNum> - valor Numérico a ser gravado.
<idData> - dado do tipo Data a ser gravado. Pode ser, também, uma constante String
representando uma data válida.
<idString> - dado do tipo String a ser gravado.
Comentários:
A posição dos argumentos define o seu tipo, sendo a primeira Numérica, a segunda Data e a
terceira String. O Tradutor verifica se esta semântica é obedecida.
As posições que não interessam gravar devem ser deixadas em branco, isto é, sem indicação de
argumento. Neste caso, os campos deixados em branco são limpos. Veja Exemplo.
HUMANUS® - PROGRAMAÇÃO EM LDR®
32
Exemplo de comando GravaStatus:
/ Copyright(c) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando GravaStatus
/**********************************************************
/ Regra XXXX criada em 05/11/1999 por C.Carravetta
/ Objetivo: gravar registro de status número 3
/ **********************************************************
/ VNUM, VDATA e VSTR são variaveis declaradas
/os campos não informados serão limpos
/ Gravando os três campos
GravaStatus ( 3 ; VNUM ; VDATA ; VSTR )
/ Gravando apenas o primeiro
GravaStatus ( 3 ; VNUM ; ; )
/ Gravando apenas o segundo
GravaStatus ( 3 ; ; VDATA ; )
/ Limpando o registro
GravaStatus ( 3 ; ; ; )
Interrompe
Encerra incondicionalmente a execução do cálculo da Matrícula corrente e continua na próxima.
Sintaxe:
Interrompe
Descrição:
O comando Interrompe pode ser colocado em qualquer posição do fonte da regra. É especialmente
útil para encerrar a execução do cálculo dependendo do resultado de um comando condicional
(Se...Senao, Caso...Seja). Os resultados parcialmente gerados até o momento da interrupção são
descartados.
HUMANUS® - PROGRAMAÇÃO EM LDR®
33
Nota: O camando PARE apenas encerra o cálculo da Regra atual, continuando na próxima,
enquanto que INTERROMPE encerra todo o cálculo do Colaborador atual e passa a calcular o
proximo. Se um calculo individual estiver sendo feito e este for interrompido pelo comando, a
mensagem "Nenhum Colaborador selecionado para o cálculo" será exibida, como se ele não
tivesse sido realmente selecionado.
Mensagem
Permite que a regra envie uma mensagem de aviso ao usuário em tempo de cálculo, opcionalmente
interrompendo o cálculo, dependendo do modo.
Sintaxe:
Mensagem ( <"texto-Msg"> ; < Modo> )
Descrição:
<"texto-msg"> : texto a ser mandado para o resumo do cálculo. Deve ser uma cadeia de caracteres
entre aspas, com tamanho de até 32 caracteres. Este texto será inserido no resumo do cálculo,
seguido do número de Matrícula do Colaborador que originou a mensagem.
<modo>: informa à máquina de cálculo se deve interromper ou não o cálculo.
0 - não interrompe, apenas insere a mensagem no resumo.
1 - insere a mensagem no resumo, abre um diálogo de alerta ao operador e interrompe o
cálculo.
Pare
Encerra incondicionalmente a execução da regra.
Sintaxe:
Pare
Descrição:
O comando Pare pode ser colocado em qualquer posição do fonte da regra. É especialmente útil
para encerrar a execução dependendo do resultado de um comando condicional (Se...Senao,
Caso...Seja)
Declaração de Rótulo
Marca um ponto de referência no fonte da regra para onde pode ser desviada incondicionalmente a
execução da regra.
HUMANUS® - PROGRAMAÇÃO EM LDR®
34
Sintaxe:
:<Rotulo>:
Descrição:
O nome dado ao rótulo pelo usuário deve ser o mesmo referenciado pelo comando Desvie, se for o
caso. Os dois pontos antes e após o nome do rótulo são parte da sintaxe e devem ser digitados sem
espaços.
Veja o comando Desvie.
SalvaDados
Este comando grava um registro de status individual identificado por um identificador e pelos
dados de competência, código da folha de pagamento em execução e seu tipo. Este registro pode ser
recuperado pelo comando BuscaDados.
Sintaxe:
SalvaDados ( <idData> ; <idFolha> ; [idCarac>] ; <idData> ; <idNum> ; <idNum> ;
<idData> ; <idString> )
Descrição:
<idData> - data de competência.
<idFolha> - código da folha de pagamento a que se refere os dados.
<idCarac> - característica da folha: 0-Normal, 1-Complementar. É opcional e pode ser informada a
string nula "".
<idData> - data de vigência da folha.
<idStr> - identificador do registro. Dado tipo String.
<idNum> - valor Numérico a ser gravado.
<idData> - dado tipo Data a ser gravado.
<idString> - deve ser uma constante, variável, Registrador Interno ou Global com tipo String.
Comentários:
A posição dos argumentos define o seu tipo, sendo a primeira Numérica, a segunda Data e a
terceira String. O Tradutor verifica se esta semântica é obedecida.
As posições que não interessam gravar devem ser deixadas em branco, isto é, sem indicação de
argumento. Neste caso, os campos deixados em branco são limpos.
O comando SalvaDados funciona de forma semelhante ao comando GravaStatus.
HUMANUS® - PROGRAMAÇÃO EM LDR®
35
Se...Senao
Testa uma expressão e executa condicionalmente um bloco de comandos de acordo com o resultado
da expressão.
Sintaxe:
Se <expressãoSE> <comandosV> [ Senao <comandosF> ] Fim
Descrição:
O comando avalia a <expressãoSE>: se a expressão for verdadeira o bloco de comandos
<comandosV> será executado; se a expressão for falsa o bloco de comandos <comandosF> será
executado, se a cláusula Senao estiver especificada, pois é opcional. Depois o comando desvia o
fluxo de execução para o primeiro comando após a palavra reservada fim.
<expressãoSE> - tem a seguinte sintaxe: <condição1> [ EE | OU <condição2> ]
As condições <condição1> e <condição2> tem a seguinte forma: <operando1> <opRelacional>
<operando2>
onde <operando1> e <operando2> não podem ser funções.
Para comparar datas pode ser usada a função DifData e usar o número retornado pela função para
compor a expressão.
<comandosV>, <comandosF> podem ser quaisquer, inclusive outro comando Se...Senao.
Exemplo de comando de SE...SENAO:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de comando de execução condicional
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: calcular um prêmio sobre o salário nominal
/ *********************************************************
SALARIO = RI00001 / a variável SALARIO recebe o valor do Reg. Interno RI0001
PREMIO=0
/ acrescenta ao salário um premio fixo dependendo do seu valor
Se SALARIO > 1000,00
PREMIO= Soma ( SALARIO ; 200,00 )
HUMANUS® - PROGRAMAÇÃO EM LDR®
36
Senao
PREMIO= Soma (SALARIO ; 300,00)
fim
/Atribui o valor do pêmio ao campo Valor da rubrica 150
R150V = PREMIO
SetDecimais
Especifica o número de casas decimais para a rubrica especificada.
Sintaxe:
SetDecimais ( <idRub> ; <campo> ; <nroDecimais> )
Descrição:
<idRub> : Código da Rubrica, cujo número de decimais deve ser alterado. Deve ser uma
constante Numérica.
<campo> : campo da rubrica: 0 (zero) referência; 1 (um) valor.
<nroDecimais> : especifica o número de casas decimais. Deve estar entre 0 (zero) e 6 (seis.)
Esta operação ocorre apenas na memória, em tempo de cálculo.
Exemplo:
SetDecimais( 150 ; 0 ; 4 ) / fixa número de decimais em 4 casas, para campo de valor da rubrica
150.
SetGrava
Liga ou desliga a flag de gravação de rubrica na FichaFinanceira.
Sintaxe:
SetGrava ( <idRub> ; <modo> )
Descrição:
<idRub> : Código da Rubrica, cuja flag de Salva na Ficha Financeira deve ser setada (marcada)
ou resetada (desmarcada).
<modo> : 0 (zero) reseta a flag (desmarca); 1 seta (marca).
HUMANUS® - PROGRAMAÇÃO EM LDR®
37
Com a flag desmarcada a rubrica não terá seu conteúdo gravado na Ficha Financeira. Somente
voltará ser gravada se a flag for marcada (setada para 1). Este setemaneto tem efeito apenas durante
a seção de cálculo. Ao ser reinicializada a máquina de cálculo, esta flag tera o valor setado no
Cadastro de Rubricas para a rubrica identificada por <idrub>.
Esta operação ocorre apenas na memória, em tempo de cálculo, e não afeta a situação da flag no
Cadastro de Rubricas.
Exemplo do comando SetGrava:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo do comando SetGrava
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: calcular uma diferenca de salario e gerar se > 0
/ **********************************************************
/ a rubrica #149V contem o salário anterior
/ a rubrica #150 está marcada no cadastro para ser gravada
SALARIO = RI00001 / a variável SALARIO recebe o valor do Reg. Interno RI0001
#150V = { SALARIO - #149V } / subtrai do SALARIO atual o anterior
Se #150V <= 0
SetGrava( 150 ; 0 ) / desliga a flag de salvamento
fim
SetProcRFixa
Atualiza o Contador de Processamento da Rubrica de natureza Fixa a qual está associada a regra
que contém o comando.
Aplica-se somente a Rubricas Fixas com Numero de Vezes maior que zero.
Sintaxe:
SetProcRFixa ( <valor> )
Descrição:
HUMANUS® - PROGRAMAÇÃO EM LDR®
38
<valor> : valor a ser atribuído ao Contador de Processamento da Rubrica. Pode ser qualquer
dado Numérico.
Nota:
Este comando somente funciona dentro da regra associada a uma Rubrica Fixa. Ele obtém
internamente o Código da Rubrica sendo avaliada. Se usado em uma regra associada a uma
rubrica de Natureza diferente de Fixa, um erro ocorrerá em tempo de cálculo, pois durante a
tradução não é possível saber a qual rubrica a regra será associada. Esse comando não deve ser
usado em Regras Independentes.
HUMANUS® - PROGRAMAÇÃO EM LDR®
39
Funções da LDR
Arredonda
Aplica um método de arredondamento ao valor do argumento.
Sintaxe:
<ident> = Arredonda ( <modo> ; <idValor> ; [ <param> ] )
Descrição:
<ident> : deve ser um dado Numérico. Não pode ser constante.
<modo> : define o método de arredondamento, que pode ser:
1 - arredonda para o próximo inteiro
2 - trunca (remove) as casas decimais
3 - usa o arredondamento padrão (até 4 mantém, acima de 4 arredonda para o próximo
inteiro.
4 - arredondamento líquido. O fator de arredondamento deve ser especificado pelo
parâmetro <param>.
<idValor> : valor a arredondar. Deve ser uma Variável, Rubrica, Registrador Interno ou Global
com tipo Numérico.
<param> : fator de arredondamento líquido. Deve ser uma constante numérica.
Para os modos de 1 a 3 a função retorna o valor já arredondado. No modo 4, a função retorna
apenas o valor do arredondamento.
Tipo de dado retornado:
Numérico
Busca
Recupera (busca) valores de uma rubrica da Ficha Financeira.
Sintaxe:
<ident> = Busca ( <dtCompet> ; <folha> ; <caracFolha> ;<dtIniVig> ; <idRub> ; <campo> )
Descrição:
<ident> : deve ser um dado Numérico. Não pode ser constante.
<diInicio> : data da competência da rubrica. Dado tipo Data.
<folha> : Código da Folha que contém a rubrica a ser buscada. Dado tipo String.
HUMANUS® - PROGRAMAÇÃO EM LDR®
40
<carcaFolha> : característica da folha:
0 - Normal,
1 - Complementar
3 - Férias Normais
4 - Férias Coletivas
Este campo é opcional. Quando não usado deve ser informado um constante tipo String
Nula (""). Neste caso, o valor eventualmente recuperado pela função será independente da
característica da folha..
<dtIniVig> : Opcional. Data de início de vigência da rubrica dentro da competência. Dado tipo
DATA. Uma constante tipo String nula ("") deve ser informada, se não interessar a vigência. A
busca será baseada apenas na competência e tipo de folha.
<IdRub> : Código da Rubrica a ser buscada.Deve ser uma constante numérica.
<campo> : campo da rubrica a ser retornado: 0 - Referência, 1 - Valor.
Se não existir a rubrica especificada por <idRub> na Ficha Financeira, a função retorna zeros.
Tipo de dado retornado:
Numérico
BuscaAcm
Recupera (busca) valores acumulados de uma rubrica da Ficha Financeira , por um número
especificado de ocorrências.
Sintaxe:
<ident> = BuscaAcm ( <dtInício> ; <folha> ; <caracFolha> ;<idRub> ; <campo> ;<nroOcor>
)
Descrição:
<ident> : deve ser um dado Numérico. Não pode ser constante.
<diInicio> : data de início da busca. Dado tipo DATA.
<folha> : Código da Folha que contém a rubrica a ser buscada. Dado tipo String.
<carcaFolha> : característica da folha:
0 - Normal,
1 - Complementar
3 - Férias Normais
4 - Férias Coletivas
HUMANUS® - PROGRAMAÇÃO EM LDR®
41
Este campo é opcional. Quando não usado deve ser informado um constante tipo String
Nula (""). Neste caso, o valor eventualmente recuperado pela função será independente da
característica da folha.
<IdRub> : Código da Rubrica a ser buscada.Deve ser uma constante numérica.
<campo> : campo da rubrica a ser retornado: 0 - Referência, 1 - Valor.
<nroOcor> : número de ocorrências a ser buscada, a partir da data de início <dtInicio> A funcão
soma as ocorrências encontradas e retorna o valor acumulado.Deve ser uma constante numérica
inteira.
Se não existir a rubrica especificada por <idRub> na Ficha Financeira, a função retorna zeros.
Tipo de dado retornado:
Numérico
BuscaUlt[ima]
Recupera (busca) a última ocorrência de uma rubrica da Ficha Financeira.
Sintaxe:
<ident> = BuscaUlt ( <idRub> ; <0 | 1> [ ; <data>] )
Descrição:
<ident> : deve ser uma variável Numérica, um Idendifcador de Rubrica, um Registrador Interno
ou Global numérico.
<IdRub> : Código da Rubrica a ser buscada.Deve ser uma constante numérica.
<0 | 1> : campo da rubrica a ser retornado: 0 - Referência, 1 - Valor.
<data> : parâmetro opcional. Tipo Data. Define a data em relação à qual será feita a busca da
rubrica. Se não informada, assume o início de vigência da folha selecionada.
Se não existir a rubrica especificada por <idRub> na Ficha Financeira, a função retorna zeros.
Tipo de dado retornado:
Numérico
BuscaVT
Calcula o valor do Vale Transporte para o colaborador sendo processado, dado a identificação de
uma linha de transporte.
Sintaxe:
HUMANUS® - PROGRAMAÇÃO EM LDR®
42
<ident> = BuscaVT( <idTipoVale> ; <idVale> ;<DataInicio> ;<DataFim> ;<nroDias> )
Descrição:
<IdTipoVale> : Constante indicando o tipo de vale transporte. 0 = normal; 1 = complementar.
<idVale> : Código da Linha de vale transporte. Dado tipo String.
<DataInicio> : data de início do período de apuração. Dado tipo Data.
<Data de Fim> : data de fim do período de apuração. Dado tipo Data.
<nroDias> : especifica o número de dias a ser calculado. Se zero (0), a função usa o calendário
para determinar o número de dias. Veja registrador interno RI0074. Dado tipo numérico.
Tipo de dado retornado:
Numérico
CalcData
Retorna uma nova data, acrescentando ou diminuindo um valor de intervalo à data fornecida como
argumento, conforme um parâmetro dado.
Sintaxe:
<ident> = CalcData ( <idData> ; <intervalo> ; <param> )
Descrição:
<ident> : identificador tipo DATA.
<idData> : data base a ser calculada. Tipo DATA.
<intervalo> : deve ser uma constante numérica inteira.
<param> : deve ser uma constante String. Identifica a abrangência do <intervalo> , ou seja, a
nova data estará deslocada para frente ou para trás tantos: "d" - dias, "m" - meses ou "a" - anos.
Tipo de dado retornado:
DATA.
CalcMedia
Calcula a média de uma rubrica da Ficha Financeira , de acordo com com certos parâmetros.
Sintaxe:
<ident> = CalcMedia (<idRub> ; <idCampo> ; <"idMoeda"> ;<idModo> ;
<idData> ; <nroOcorr> ;<divisor> ;<idProporc> ;
HUMANUS® - PROGRAMAÇÃO EM LDR®
43
<idRascunho> [;<idLimCompet>] [;<fixaDivisor>] )
Descrição:
<ident> : deve ser dado Numérico. Não pode ser constante.
<IdRub> : Código da Rubrica a ser totalizada. Deve ser uma constante numérica.
<idCampo> : campo da rubrica a ser totalizado: 0 - Referência, 1 - Valor.
<idMoeda> : Código da Moeda a ser usado para atualização monetária. Este parâmetro é opcional.
Se não usado, deve ser informado "" (string vazia). Se usado, cada ocorrência de valor que compõe
a média é corrigido pelo Indicador Econômico da correspondente data.
<idModo> : determina o modo de operação da função:
0 - últimas <nroOcorr> ocorrências a partir da data de competência. (retrocede
<nroOcorr> a partir da competência).
1 - a partir da data especificada em <idData> até a competência atual.
2 - Férias vencidas: calcula a média dentro do período iniciado por <idData> (intervalo de
12 meses). Se o período estiver incompleto, calcula proporcionalmente, ajustando o divisor
ao número de meses do intervalo.
3 - Férias proporc.: faz a média desde <idData> até a competência anterior à atual. Se o
período especificado for maior que 12 meses, retorna zeros, pois não há proporcionalidade a
calcular.
4 - Férias: calcula a média de todos os períodos aquisitivos a partir do período passado em
<idData>. Apenas os períodos vencidos. Se não houver ao menos um período vencido,
retorna zeros.
<idData> : data de abrangência da média. Deve ser uma variável, Registradores Internos ou
Registrador Global tipo DATA. Somente é necessária se <idModo> for maior que zero. Se usado
modo 0, <idData> pode ser informada como "" (string vazia).
<nroOcorr> : determina o número de ocorrências e tratamento do divisor:
se <idModo> for igual a 0: especifica o número de ocorrências a calcular. Pode ser uma
variável ou constante numérica maior que zero. Se especificada uma variável e esta estiver
zerada em tempo de cálculo, um erro de execução ocorrerá e a mensagem "Tentativa de
divisão por zero!" será mostrada e o cálculo interrompido.
Se <idModo> for diferente de 0: especifica o tratamento para o <divisor>. Se <nroOcorr>
= 1, assume o dividor passado em <divisor> independentemente do número de ocorrências
encontrado;
Pode ser qualquer estrutura de dados numérica.
<divisor> : divisor a ser usado para o cálculo final da média. Pode ser uma variável ou uma
constante numérica maior que zero. Se especificada uma variável e esta estiver zerada em tempo
de cálculo, um erro de execução ocorrerá e a mensagem "Tentativa de divisão por zero!" será
mostrada e o cálculo interrompido. Pode ser qualquer estrutura de dados numérica.
HUMANUS® - PROGRAMAÇÃO EM LDR®
44
<idProporc> : especifica se o cálculo deve ser proporcional à data de admissão:
0 - não proporcionaliza
1 - proporcionaliza
<idRascunho> : gera ou não rascunho (memória de cálculo):
0 - não gera rascunho
1 - gera
<idLimCompet> : enquadramento da data de competência no intervalo de apuração das médias:
0 - não inclui mês de competência
1 - inclui
Este argumento é opcional, e a função o assume como Zero (default) se não for
especificado.
<fixaDivisor> : instrui a função sobre o argumento <divisor>:
0 - ajusta o divisor conforme o número de ocorrências e <idProporc>
1 - efetua a busca das ocorrências conforme os demais parâmetros, mas adota o divisor
fixado em <divisor>, independentemente de proporcionalização e do númeor de ocorrências
encontradas.
2 - efetua média das "n" maiores ocorrências, onde "n" é dado pelo argumento <divisor>
Este argumento é opcional, e a função o assume como Zero (default) se não for
especificado.
Informações gerais:
Se não existir a rubrica especificada por <idRub> na Ficha Financeira, a função retorna zeros.
Se especificado cálculo proporcional à data de admissão e o colaborador não tiver um mês de
trabalho, a função retorna zeros.
Em todos os modos, a função sempre verifica se o intervalo de apuração definido pelo modo
<idModo> e a data <idData> não ultrapassa a competencia atual. Se isto ocorrer, o intervalo é
ajustado até o limite da competência, conforme o parâmetro <idLimCompet>.
A competência do cálculo não necessita ser passada como argumento porque é um registro interno
da máquina de cálculo.
Tipo de dado retornado:
Numérico
HUMANUS® - PROGRAMAÇÃO EM LDR®
45
CampoDeUsuario
Recupera o valor atribuído a um Campo de Usuário (extensão de Cadastro de Pessoal criada pelo
usuário) associado ao Colaborador correntemente calculado.
Sintaxe:
<ident> = CampoDeUsuario ( <idNroCampo> )
Descrição:
<ident> : deve ser qualquer dado compatível com o tipo do campo de usuário desejado. Não pode
ser constante.
<idNroCampo> : deve ser uma constante numérica igual ou maior que zero.
Durante a conversão, o tradutor verifica se o campo de usuário <idNroCampo> existe, isto é, se
está definido em Extensão do Cadastro de Pessoal, no Módulo de Registros de Pessoal. Se não
estiver, um erro de tradução é gerado. Se estiver definido, o seu Tipo de Dado é retornado e
comparado com o tipo do <ident> à esquerda da atribuição. Estes tipos devem ser iguais, caso
contrário um erro de tradução será emitido por "tipos de dados incompatíveis".
Durante o cálculo, a função busca o valor do campo identificado. Se não houver dados para o
campo, os valores default serão retornados. Veja tabela abaixo:
tipo do campo valor default valor existente Data "" (string vazia) data no formato dd/mm/aaaa
Numérico 0 (zero) número real no formato #.##0.000000 String "" (string vazia) as 32 primeiras posições
Dica:
No caso de campo tipo DATA, conferir o retorno com a função TemData() para certificar-se de que
uma data válida foi retornada. Assim evita-se testes de comparação com uma data inválida, o que
certamente gerará erro.
Tipo de dado retornado:
O tipo de dado retornado depende do tipo do campo de usuário definido. Pode ser numérico, string
ou data.
Data
Converte uma constante tipo String representando uma data num dado tipo Data contendo uma
data válida.
Sintaxe:
<ident> = Data ( [<"dd/mm/aaaa">] )
HUMANUS® - PROGRAMAÇÃO EM LDR®
46
Descrição:
<ident> : deve ser um dado tipo DATA.
<"dd/mm/aaaa"> : opcional. Se informada deve ser uma constante do tipo String representando
uma data completa. A função critica a constante e se for uma data válida a converte para o formato
DATA. Se não, emite uma mensagem de erro de tradução (Um erro semântico, no caso). Se não
informado o argumento, a função retorna a data do Sistema Operacional da estação de trabalho.
Tipo de dado retornado:
DATA.
DataTransferencia
Retorna a última (mais recente) data de movimentação do Coloborador no Histórico de
Movimentações. Se não houver movimentos, retorna string nula ("").
Sintaxe:
<ident> = DataTransferencia ( < "tipoMovim"> )
Descrição:
<ident> : deve ser um dado tipo DATA.
<"tipoMovim"> : constante string que identifica um Código de Movimentação de Pessoal. Deve vir
entre aspas. A função não critica a existência deste código nos Tipos de Movimentação de
Pessoal.
Tipo de dado retornado:
O retorno desta função deve ser testado através da função TemData. Se houver uma ocorrência, o
retorno será uma DATA. Caso contrário, será uma String nula.
DataUltimaAltSalarial
Retorna a data da última alteração salarial registrada no Histórico Salarial.
Sintaxe:
<ident> = DataUltimoAltSalarial( )
Descrição:
<ident> : deve ser um dado tipo DATA.
Se não houver alteração salarial, retorna uma data vazia (string nula).
HUMANUS® - PROGRAMAÇÃO EM LDR®
47
Tipo de dado retornado:
Data.
DataUltimoAfastamento
Retorna a data do último afastamento para o Tipo de Afastamento passado comoa rgumento da
função.
Sintaxe:
<ident> = DataUltimoAfastamento( [ <TipoAfastam> ] )
Descrição:
<ident> : deve ser um dado tipo DATA.
<TipoAfastam> : (opcional) código correspondente ao Tipo do Afastamento. Deve ser dado tipo
STRING.
Se o <TipoAfastam> informado for "99" a função devolve a data de retorno do afastamento.
Tipo de dado retornado:
Data.
DataUltimoDissidio
Retorna a data do último dissídio coletivo do Sindicato ao qual o Colaborador correntemente sendo
calculado pertence.
Sintaxe:
<ident> = DataUltimoDissidio( )
Descrição:
<ident> : deve ser um dado tipo DATA.
Se não houver uma data informada no cadastro de sindicato, a função emite uma mensagem de erro
e interrompe o cálculo.
Da mesma forma, se o Colaborador não estiver vinculado a um sindicato ou for um Colaborador de
cadastro reduzido uma mensagem de erro será exibida e o cálculo interrompido.
Tipo de dado retornado:
Data.
HUMANUS® - PROGRAMAÇÃO EM LDR®
48
DiasAfastados
Calcula o número de dias de afastamento registrados no Histórico de Afastamentos, para o intervalo
de datas passado como parâmetro.
Sintaxe:
<ident> = DiasAfastados ( <DtInicio> ; <DtFim> ; <modo> )
Descrição:
<ident> : deve ser dado Numérico diferente de constante.
<dtInicio>, <dtFim>: data de início e de término do intervalo de busca. Deve ser dado tipo
DATA.
<Modo> - determina os Tipos de Afastamentos considerados:
0 - calcula os dias afastados para todo e qualquer tipo de afastamento;
1 - calcula os dias afastados apenas para aqueles afastamentos que afetam férias,
identificados no Cadastro de Tipos de Afastamentos.
Tipo de dado retornado:
Numérico
DiasAfastadosEspeciais
Calcula o número de dias de afastamento registrados no Histórico de Afastamentos, para o intervalo
de datas passado como parâmetro.
Sintaxe:
<ident> = DiasAfastadosEspeciais ( <DtInicio> ; <DtFim> ; <tipoAfastamento> )
Descrição:
<ident> : deve ser dado Numérico diferente de constante.
<dtInicio>, <dtFim>: data de início e de término do intervalo de busca. Deve ser dado tipo
DATA.
<TipoAfastamento> - código do tipo de afastamento. Deve ser dado tipo STRING.
Tipo de dado retornado:
Numérico
HUMANUS® - PROGRAMAÇÃO EM LDR®
49
DiaDaSemana
Retorna o dia da semana da data passada como argumento.
Sintaxe:
<Ident> = DiaDaSemana ( <idData> )
Descrição:
<ident> - deve ser dado tipo string.
<idData> - data da qual deve ser retornado o dia da semana. Deve ser um dado tipo DATA.
A função retorna os seguintes strings conforme o dia da semana ao qual corresponde a data passada:
DOM - Domingo
SEG - Segunda-feira
TER - Terça-feira
QUA - Quarta-feira
QUI - Quinta-feira
SEX - Sexta-feira
SAB - Sábado
Tipo de dado retornado:
String
DiasCalendario
Retorna o número de ocorrências (dias) do tipo de dia especificado pelo parâmetro.
Sintaxe:
<ident> = DiasCalendario ( <idDataInicio> ;<idDataFinal> ;<parametro> )
Descrição:
<ident> : deve ser uma dado Numérico. Não pode ser constante.
<idDataInicio>, <idDataFinal> : devem ser dados do tipo DATA. Estas datas estabelecem o
intervalo do calendário em que será efetuada a busca.
HUMANUS® - PROGRAMAÇÃO EM LDR®
50
<parametro> : especifica o tipo de dia cuja ocorrência no calendário deverá ser contada. Podem ser
os seguintes:
0 - dias normais trabalhados;
1 - dias de Descanso Semanal Remunerado (DSR);
2 - dias Feriados (FER)
3 - dias de Jornada Compensada (JCP).
A função varre o calendário, no intervalo definido pelas datas, em busca do tipo de ocorrência
representada pelo parâmetro. Se o calendário não existir, o número de dias contados entre as datas
de início e fim é retornado.
A diferença, em dias, entre a data de início e final não poderá ser superior a 60 dias, caso contrário a
função retorna uma mensagem de erro. A data de início deve ocorrer antes da data de fim do
intervalo.
A função utiliza o Calendário associado ao Grupo do Horário do Colaborador sendo calculado.
Tipo de dado retornado:
Numérico.
DiasLicMatAno
Calcula o número de dias de afastamento por Licença Maternidade havidos pela Colaboradora, até
a data limite passada como argumento.
Sintaxe:
<ident> = DiasLicMatAno ( <idData> )
Descrição:
<ident> : deve ser um dado Numérico diferente de constante.
<idData> : data limite para contagem do afastamento. Deve ser um dado tipo DATA.
A função efetua a contagem de dias de afastamento pela data de início do afastamento, se dentro do
ano da folha. Se o início do afastamento ocorreu no ano anterior, a contagem começa no primeiro
dia do ano da folha.
Os dias são contados até a data de fim do afastamento, se esta ocorrer antes do término de vigência
da folha. Caso contrário, a contagem vai apenas até a data de fim de vigência da folha ou de limite
<idData> passada para a função.
Nota:
A função não verifica o sexo cadastrado do Colaborador para efeitos de crítica.
HUMANUS® - PROGRAMAÇÃO EM LDR®
51
Tipo de dado retornado:
Numérico.
DifData
Função que retorna um número representando a diferença entre duas datas, conforme um parâmetro
dado.
Sintaxe:
<ident> = DifData ( <idData1> ; <idData2> ; <param> )
Descrição:
<ident> : deve ser dado tipo Numérico diferente de constante.
<idData1> : deve ser um dado tipo DATA.
<idData2> : deve ser um dado tipo DATA.
<param> : deve ser uma das constantes String a seguir para identificar o significado do número a
ser retornado: "d" - dias, "m" - meses ou "a" - anos.
Se a <idData1> for maior que <idData2> , isto é, se for posterior no tempo, um número negativo
será retornado. Se <idData1> for anterior a <idData2>, um número positivo é retornado.Todavia,
dependendo de <param>, as duas datas serão consideradas iguais (retorno igual a zero), se o
parâmetro for:
- "a" (ano) e o ano de <idData1> e <idData2> forem iguais.
- "m" (mes) e o mes e ano de <idData1> e <idData2> forem iguais
- "d" (dia) e dia, mes e ano das duas datas forem iguais.
Nota:
Esta função pode ser usada para comparar duas datas, testando o número retornado em <ident>
numa expressao no comando Se...Senão.
Tipo de dado retornado:
Numérico
Funções Aritméticas
Funções que executam uma operação aritmética sobre dois operandos.
Nota: estas funções estão obsoletas e se recomenda que sejam substituídas por expressões
aritméticas.
HUMANUS® - PROGRAMAÇÃO EM LDR®
52
Soma
Soma um número com outro e devolve o resultado.
Sintaxe:
<ident> = Soma ( <parcela1> ; <parcela2> )
Descrição:
<ident> : deve ser uma variável Numérica, um Idendifcador de Rubrica, um Registrador Interno
ou Global numérico.
<parcela1> e <parcela2> : parcelas da soma. Podem ser qualquer dado válido com tipo numérico
(*).
Equivale a expressão aritmética: { <parcela1> + <parcela2> }
Subtração
Subtrai um número de outro e retorna o resultado.
Sintaxe:
<ident> = Subtrai ( <minuendo> ; <subtraendo> )
Descrição:
<ident> : deve ser uma variável Numérica, um Idendifcador de Rubrica, um Registrador Interno
ou Global numérico.
<minuendo> : número a ser diminuído. Pode ser qualquer dado válido com tipo numérico (*).
<subtraendo> : número subtraído do <minuendo>. Pode ser qualquer dado válido com tipo
numérico (*).
Atenção para a ordem dos operandos. A subtração não é comutativa.
Equivale a expressão aritmética: { <subtraendo> - <minuendo> }
Divisão
Divide um número por outro e retorna o quociente.
Sintaxe:
<ident> = Divide ( <dividendo> ; <divisor> )
Descrição:
<ident> : deve ser uma variável Numérica, um Idendifcador de Rubrica, um Registrador Interno
ou Global numérico.
<dividendo> : número a ser dividido. Pode ser qualquer dado válido com tipo numérico(*).
HUMANUS® - PROGRAMAÇÃO EM LDR®
53
<divisor> : número que divide o <dividendo>. Pode ser qualquer dado válido(*) com tipo
numérico diferente de zero.
Atenção para a ordem dos operandos. A divisão não é comutativa.
Se o <divisor> for uma variável, rubrica ou registrador e estiver zerada no momento do cálculo,
um erro de execução por tentativa de divisão por zero ocorrerá e o cálculo será interrompido.
Equivale a expressão aritmética: { <dividendo> \ <divisor> }
Produto
Multiplica um número por outro e devolve o produto.
Sintaxe:
<ident> = Mult ( <multiplicando> ; <fator> )
Descrição:
<ident> : deve ser uma variável Numérica, um Idendifcador de Rubrica, um Registrador Interno
ou Global numérico.
<multiplicando> e <fator> : Podem ser qualquer dado válido com tipo numérico(*).
Equivale a expressão aritmética: { <multiplicando> * <fator> }
(*) Exceto Registradores Globais.
Tipo de dado retornado:
Numérico
Enquadra
Enquadra um valor numa Tabela de Faixas de Valores, obtém um índice e aplica sobre sobre uma
base especificada, retornando o resultado.
Sintaxe:
<ident> = Enquadra ( "<idTabela>" ; <dtVigencia ;<modoEnq> ;<valorEnq> ; <valorBase> )
Descrição:
<ident> :deve ser um dado Numérico. Não pode ser constante.
<idTabela> : deve ser uma constante String especificando o Código da Tabela de Faixas de
Valores. Deve ser envolta por aspas duplas (").
<dtVigencia> : data de vigência da tabela. Deve ser um dado tipo Data.
HUMANUS® - PROGRAMAÇÃO EM LDR®
54
<modoEnq> : determina a forma de identificação da tabela em relação à data de vigência:
0 (zero): a função toma a tabela cuja data de vigência é igual ou menor que a data
especificada em <dtVigencia> , isto é, busca a mais recente anterior.
1 (um): a função busca exclusivamente a tabela da <dtVigencia> . Se não encontrar um erro
ocorre e força a interrupção do cálculo.
<valorEnq> : valor para enquadramento. É o valor que será levado à tabela para ser identificada a
faixa de cálculo. Pode ser um dado do tipo Numérico.
<valorBase> : valor sobre o qual serão aplicados os fatores de Multiplicação e Divisão da faixa.
Pode ser um dado do tipo Numérico.
A função leva à tabela identificada, da data de vigência dada por <dtVigencia>, o <valorEnq> a
enquadrar. Identificando em que faixa este valor recai, aplica os fatores desta faixa sobre o
<valorBase>, conforme a fórmula abaixo:
((<valorBase> x FatMult ) / FatDiv ) + (VlrAgregar - VlrDeduzir)
O resultado desta fórmula é comparado com o valor de Teto. Se for menor ou igual, retorna o
resultado. Caso contrário retorna o teto.
Nota:
Para cálculos percentuais, os valores dos fatores de multiplicação e divisão da Tabela de Faixas de
Valores devem estar cadastrados num formato compatível.
Tipo de dado retornado:
Numérico
Exemplo de função ENQUADRA:
/ Copyright(C) by CR Sistemas Ltda
/**********************************************************
/ Exemplo de uso da função Enquadra
/**********************************************************
/ Regra XXXX criada em 23/04/1996 por C.Carravetta
/ Objetivo: calcular o IRRF sobre uma base
/ **********************************************************
BASE=#501V / atribui à variável BASE o valor da rubrica Base IRRF
/ RI0029 tem a data da Competência atual
HUMANUS® - PROGRAMAÇÃO EM LDR®
55
IR = Enquadra ( "IRRF" ; RI0029 ; BASE ; BASE )
IndEconômico
Retorna a cotação de uma moeda ou o valor de um índice ou fator cadastrado no Cadastro de
Indicadores Econômicos.
Sintaxe:
<ident> = IndEconômico ( <idIndicador> ; <idData> ; < 0 | 1> )
Descrição:
<ident> : deve ser um dado numérico.
<idIndicador> : Código do Indicador Econômico (moeda) a ser retornado. Deve ser uma contante
String.
<idData> : deve ser um dado tipo DATA.
<0 | 1 > : constante a ser retornada caso o Indicador não exista.
Tipo de dado retornado:
Numérico.
MontaData
Retorna uma nova data, passados Dia, Mes e Ano como argumentos.
Sintaxe:
<ident> = MontaData ( <idDia> ; <idMês> ; <idAno> )
Descrição:
<ident> : deve ser um dado tipo DATA.
<idDia> : deve ser um dado numérico, no intervalo de 1 a 31.
<idMês> : deve ser um dado numérico, no intervalo de 1 a 12.
<idAno> : deve ser um dado numérico, no intervalo de 1753 a 2999.
A função critica a data montada, gerando um erro se resultar inválida.
Tipo de dado retornado:
HUMANUS® - PROGRAMAÇÃO EM LDR®
56
DATA.
MotivoUltimaAltSalarial
Retorna o motivo do último registro do histórico salarial do colaborador.
Sintaxe:
MotivoUltimaAltSalarial ()
Tipo de dado retornado:
Texto (Código do Motivo).
NroPontosBenefício
Retorna o número de pontos associado ao Benefício passado como argumento da função.
Sintaxe:
<ident> = NroPontosBeneficio ( <CodBeneficio> )
Descrição:
<ident> : deve ser dado Numérico diferente de constante.
<codBeneficio>: código do Benefício. Deve ser dado tipo STRING.
Tipo de dado retornado:
Numérico
ParteData
Retorna um número identificando a parte da data, conforme um parâmetro dado.
Sintaxe:
HUMANUS® - PROGRAMAÇÃO EM LDR®
57
<ident> = ParteData ( <idData> ; <param> )
Descrição:
<idData> : deve ser um dado com tipo Data.
<param> : deve ser uma constante String. Identifica a parte da data que a função deve retornar:
"d" - dia, entre 1 e 31
"m" - mes, entre 1 e 12
"a" - ano no formato "nnnn"
Tipo de dado retornado:
Numérico.
TemData
Testa se o conteúdo de um dado tipo DATA possui uma data válida, retornando 0 em caso
afirmativo ou 1 caso contrário.
Sintaxe:
<ident> = TemData ( <idTpData> )
Descrição:
<ident> : deve ser um dado Numérico. Não pode ser constante.
<idTpData> : deve ser um dado do tipo DATA.
Tipo de dado retornado:
Numerico inteiro.
TemMovimento
Informa se uma rubrica teve um lançamento via movimento.
Sintaxe:
<ident> = TemMovimento ( <idRubrica> )
Descrição:
<ident> : deve ser um dado Numérico. Não pode ser uma Constante.
<IdRubrica> : Código da Rubrica para verificar se houve movimento. Deve ser uma constante
numérica.
HUMANUS® - PROGRAMAÇÃO EM LDR®
58
A função retorna:
0 - não há lançamentos para esta rubrica
1 - há lançamento via sistema - geração interna
2 - há lançamento via movimentos de entrada
Tipo de dado retornado:
Numérico.
Totaliza
Totaliza (soma) todas as ocorrências de uma rubrica da Ficha Financeira, de acordo com com
certos parâmetros.
Sintaxe:
<ident> = Totaliza ( <idRub> ; <idData> ; <regime> ; <campo> ; [ <idNroMltCtr> ;
<ModoMlt> ] )
Descrição:
<ident> : deve ser um dado Numérico. Não pode ser constante.
<idData> : data de abrangência da totalização. Deve ser um dado tipo DATA.
<IdRub> : Código da Rubrica a ser totalizada.Deve ser uma constante Numérica.
<regime> : especifica a que regime o <idData> se refere:
0 - totaliza pela Competência
1 - totaliza pela Data do Caixa
<campo> : constante numérica informando o campo da rubrica a ser totalizado: 0 - Referência, 1 -
Valor.
<idNroMltCtr> : dado numérico contendo o número identificador de multicontrato (contido no
registrador RI0022). Informa a função para totalizar as ocorrências dos diversos contratos do
colaborador. Este parâmetro é opcional. Para saber se o colaborador possui múltiplos contratos o
RI0021 deve ser testado.
<modoMlt> : constante numérica que especifica a forma como a totalização de multicontrato deve
ocorrer. Se 1 todos os contratos são totalizados, exceto o atual. Se 2 todos os contratos são
totalizados. Este parâmetro é obrigatório se <idNroMltCtr> for especificado.
Se não existir a rubrica especificada por <idRub> na Ficha Financeira, a função retorna zeros.
Tipo de dado retornado:
Numérico
HUMANUS® - PROGRAMAÇÃO EM LDR®
59
UltDiaMes
Retorna o último dia do mês de uma data passada como argumento.
Sintaxe:
<ident> = UltDiaMes ( <idData> )
Descrição:
<ident> : deve ser dado Numérico. Não pode ser constante.
<idData> : deve ser um dado tipo DATA.
Tipo de dado retornado:
Numérico.
ValorFolhaOrigem
Busca na memória o valor ou referência de uma rubrica da folha original de uma complementar.
Sintaxe:
<ident> = ValorFolhaOrigem ( <idRubrica> ; <idCampo> )
Descrição:
<ident> : deve ser dado Numérico. Não pode ser uma constante.
<IdRub> : Código da Rubrica buscada. Deve ser uma constante numérica.
<idCampo>: constante indicando o campo da rubrica a ser retornado: 0 - referência, 1 - valor.
Atenção:
Esta função se aplica apenas à folha complementar . Caso seja usada numa regra em folha normal,
ela retornará sempre 0 (zero).
Tipo de dado retornado:
Numérico.
HUMANUS® - PROGRAMAÇÃO EM LDR®
60
© 2011 by CR Sistemas Ltda.
1ª. Edição, agosto de 2011.
Material elaborado por Carlos Alberto Carravetta
Todos os direitos reservados. Este material não pode ser copiado, reproduzido ou distribuído,
por quaisquer meios, sem prévia autorização escrita de CR Sistemas Ltda.