INTRODUÇÃO A PROGRAMAÇÃO EM LDR(r) -...

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


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


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.


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

ms-its:CRGlossa.chm::/html/tradutor.htm

ms-its:CRRem76.chm::/html/calculodialogo.htm


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


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.


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.


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.


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.


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.

ms-its:CRRem76.chm::/html/rubricacadastro.htm


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

http://regradefinicao.htm/


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

http://cmdsetdecimais.htm/

ms-its:CRGlossa.chm::/html/funcao.htm

ms-its:CRGlossa.chm::/html/maqcalculo.htm


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

http://regracadastro.htm/

http://ldrtiposdados.htm/


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


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


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:


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


ms-its:CRGlossa.chm::/html/tipodado.htm

ms-its:CRGlossa.chm::/html/rubricas.htm

ms-its:CRGlossa.chm::/html/rubincidente.htm

ms-its:CRGlossa.chm::/html/regra.htm


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


ms-its:CRGlossa.chm::/html/rubcmpref.htm

ms-its:CRGlossa.chm::/html/rubcmpvalor.htm


20

Exemplo de comando BuscaMovimento:


/**********************************************************

/ Exemplo de comando CalcBeneficio

/**********************************************************


/ 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


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.


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.


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:


/**********************************************************

/ Exemplo de comando BuscaStatus

/**********************************************************


/ 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


CalcBeneficio

Avalia os valores, para o Benefício especificado, do Colaborador sendo calculado e seus

dependentes.

Sintaxe:

CalcBeneficio ( <"códBeneficio"> ; <parteColaborador> ; <parteEmpresa> )


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:


/**********************************************************

/ Exemplo de comando CalcBeneficio

/**********************************************************


/ 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


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


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

ms-its:CRGlossa.chm::/html/operrelacional.htm

ms-its:CRGlossa.chm::/html/constante.htm



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:


/**********************************************************

/ Exemplo de comando CASO...SEJA

/**********************************************************


/ Objetivo: calcular um adicional de 30% , 20% ou 10% sobre o salário nominal

/ dependendo do valor deste

/ *********************************************************


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> [:]


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:


/**********************************************************

/ Exemplo de comando de desvio incondicional

/**********************************************************


/ Objetivo: aplicar algum tratamento apenas aos salários menores que 1000,00

/ **********************************************************


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

ms-its:CRGlossa.chm::/html/fonteregra.htm

ms-its:CRGlossa.chm::/html/tradutor.htm


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


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:


/**********************************************************

/ Exemplo de comando Exec Se

/**********************************************************


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

ms-its:CRGlossa.chm::/html/variavel.htm


ms-its:CRGlossa.chm::/html/reginternos.htm




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.

....


/**********************************************************

/ Exemplo de comando Execute

/**********************************************************

ms-its:CRRem76.chm::/html/rubricacadastro.htm


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.


32

Exemplo de comando GravaStatus:


/**********************************************************

/ Exemplo de comando GravaStatus

/**********************************************************


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



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.



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.


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:


/**********************************************************

/ Exemplo de comando de execução condicional

/**********************************************************


/ Objetivo: calcular um prêmio sobre o salário nominal

/ *********************************************************


PREMIO=0

/ acrescenta ao salário um premio fixo dependendo do seu valor

Se SALARIO > 1000,00

PREMIO= Soma ( SALARIO ; 200,00 )

ms-its:CRGlossa.chm::/html/condicao.htm



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






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:


/**********************************************************

/ Exemplo do comando SetGrava

/**********************************************************


/ 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


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

ms-its:CRGlossa.chm::/html/regra.htm


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.


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:


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




ms-its:CRGlossa.chm::/html/regglobal.htm



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.


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:


<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



ms-its:CRGlossa.chm::/html/rubcmvalor.htm



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.


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



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.


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



Numérico

BuscaVT

Calcula o valor do Vale Transporte para o colaborador sendo processado, dado a identificação de

uma linha de transporte.

Sintaxe:












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.


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.


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> ;



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.







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


Numérico


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.


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">] )





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.


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:


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


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:


Se não houver alteração salarial, retorna uma data vazia (string nula).

ms-its:CRGlossa.chm::/html/errotraducao.htm


47


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:


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


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:


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.


Data.


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.


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:


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


Numérico


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


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.


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.


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.


51


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.


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.

ms-its:CRGlossa.chm::/html/expressao.htm


52

Soma

Soma um número com outro e devolve o resultado.

Sintaxe:

<ident> = Soma ( <parcela1> ; <parcela2> )

Descrição:



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



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



<dividendo> : número a ser dividido. Pode ser qualquer dado válido com tipo numérico(*).














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:



<multiplicando> e <fator> : Podem ser qualquer dado válido com tipo numérico(*).

Equivale a expressão aritmética: { <multiplicando> * <fator> }

(*) Exceto Registradores Globais.


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.






ms-its:CRRem76.chm::/html/tabfaxvalores.htm


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.


Numérico

Exemplo de função ENQUADRA:


/**********************************************************

/ Exemplo de uso da função Enquadra

/**********************************************************


/ 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


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.


Numérico.

MontaData

Retorna uma nova data, passados Dia, Mes e Ano como argumentos.

Sintaxe:

<ident> = MontaData ( <idDia> ; <idMês> ; <idAno> )

Descrição:


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


ms-its:CRCad76.chm::/html/cadindicecon.htm

ms-its:CRCad76.chm::/html/cadindicecon.htm


56

DATA.

MotivoUltimaAltSalarial

Retorna o motivo do último registro do histórico salarial do colaborador.

Sintaxe:

MotivoUltimaAltSalarial ()


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:


<codBeneficio>: código do Benefício. Deve ser dado tipo STRING.


Numérico

ParteData

Retorna um número identificando a parte da data, conforme um parâmetro dado.

Sintaxe:


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"


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:


<idTpData> : deve ser um dado do tipo DATA.


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.


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


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:


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



Numérico

ms-its:CRGlossa.chm::/Html/lancamsistema.htm





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.


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


Numérico.






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.

INTRODUÇÃO A PROGRAMAÇÃO EM LDR(r) -...

Documents

Transcript of INTRODUÇÃO A PROGRAMAÇÃO EM LDR(r) -...