Tivoli Service Desk 6.0 Developer's Toolkit - Guia de Programação do Script

Capítulo 2: Tipos de Dados

Retornar ao Índice


Introdução

Este capítulo apresenta os tipos de dados utilizados com mais freqüência no Developer's Toolkit. Além das discussões dos tipos de dados em si, você poderá encontrar informações sobre constantes, variáveis e expressões.

Tipos de Dados Simples

Os Tipos de dados definem as propriedades dos dados contidos em uma variável ou constante. As propriedades possíveis incluem:

Tipos de dados do Developer's Toolkit

O Developer's Toolkit possui seis tipos de dados simples.

Outros Tipos de Dados

Tipos de identificador

Identificador é uma variável que contém o endereço de outra variável. O endereço é a localização de uma variável. Um identificador permite que um programa acesse um recurso específico.

Os tipos de identificadores possuem usos específicos e não são derivados de quaisquer outros tipos. Os desenvolvedores utilizam os identificadores para identificar uma entidade lógica na qual as operações são executadas. Segue abaixo, uma lista de tipos de identificadores:

Tipos de parâmetros externos

Os tipos de parâmetros externos são versões anotadas de tipos simples que ajudam o Interpretador do Developer's Toolkit a converter os valores do Developer's Toolkit para o tipo C ou Pascal apropriados, antes de chamar um DLL externo:

Tipos agregados

Os três tipos agregados não podem permanecer sozinhos, mas podem ser utilizados em conjunto com qualquer outro tipo, afim de criar os tipos definidos pelo usuário:

Constantes

Constantes são itens nomeados que permanecem inalterados, ou constantes, durante toda a execução do programa. Todas as declarações de constante são realizadas na seção CONSTANTS de uma base de informações.

Como declarar uma constante

Para declarar uma constante em uma base de informações é necessário:

As declarações de constante, como todas as instruções do Developer's Toolkit, sempre são encerradas com ponto e vírgula (;).

Alguns exemplos de declarações de constante utilizando tipos de dados diferentes são mostradas a seguir:

CONSTANTS
   (* string constants *) 
   fileName IS 'MYFILE.DAT'; 
   pathName IS 'EADVISOR\ADVISOR\DATA'; 
   driveName IS 'E:'; 
  (* integer constants *) 
  MAX_EMPLOYEES IS 500; 
  ERROR_CODE IS -1; 
  (* real constants *) 
  PI_VALUE IS 3.14159; 
  MAX_SALARY IS 999999.99; 
  LO_VALUE IS -5134.1348; 
  (* Boolean constants *) 
  SAVE_TO_DISK IS TRUE; 
  OVERWRITE_FILE IS FALSE; 
  (* date constants *) 
  CHRISTMAS IS {12,25,1996}: DATE; 
  BIRTH_DAY IS {2,13,1956}: DATE; 
  (* time constants *) 
  START_OF_DAY IS {8,30,0}: TIME; 
  END_OF_DAY IS {18,0,0}: TIME; 

Nota: Usuários internacionais devem estar atentos ao fato de que a ordem de "partes" da data em uma inicialização do Developer's Toolkit é (mês, dia, ano) e não se alteram de local para local.

Variáveis

Variáveis são itens nomeados que contêm tipos de dados que podem ser modificados durante a execução do programa. As variáveis são declaradas na seção VARIABLES de uma base de informações.

Como declarar uma variável

Para declarar uma variável em uma base de informações é necessário:

Conforme mostrado no exemplo a seguir, você pode declarar múltiplas variáveis do mesmo tipo separando seus nomes com vírgulas:

VARIABLES 
  first_name, last_name        : STRING; 
  i,j                          : INTEGER; 
  salary                       : REAL; 
  married                      : BOOLEAN; 
  entryDate                    : DATE; 
  startTime                    : TIME; 

Como atribuir valores às variáveis

Os valores são atribuídos às variáveis com o operador de atribuição (:=).

O fragmento de código a seguir mostra algumas atribuições de variável para as variáveis que foram definidas no exemplo anterior:

first_name        := 'Amy'; 
last_name         := 'Alec'; 
i                 := 7; 
j                 := 32; 
salary            := 37500.00; 
married           := FALSE; 
entryDate         := {1,31,1991}: DATE; 
startTime         := {10,30,0}: TIME; 

Conversões dos Tipos de Dados

Pode existir momentos em que você precisará converter tipos de dados. A conversão de dados ocorre quando há uma alteração na maneira em que as informações são apresentadas. Por exemplo, você pode alterar de representação binária para representação decimal ou hexadecimal, ou de inteiros para cadeias.

Conversão de tipos de dados simples

O Developer's Toolkit utiliza chaves {} para indicar que valor deve ser convertido.

Neste exemplo, o valor dentro das chaves é convertido em um inteiro:

i := {s}: INTEGER; 

Quando o Developer's Toolkit encontra esta linha, ele:

A conversão de um valor não destrói o valor original.

Como calcular com a conversão de um tipo de dado

A seguir, há um exemplo mais complicado de uma conversão de dados, mostrando como o Developer's Toolkit calcula o número de dias entre duas determinadas datas:

d1                := {1,1,1990}: DATE; 
d2                := $Today; 
daysBetween        = {d2}: INTEGER - {d1}: INTEGER; 

Para realizar isso, o Developer's Toolkit utiliza os valores de dados armazenados em {d1} e {d2}, converte-os aos valores Juliano, e subtrai estes valores.

Este exemplo presume que {d1} e {d2} são variáveis de datas e que a variável daysBetween é um inteiro.

Erros de atribuição

O Developer's Toolkit é uma linguagem de tipos bem definidos, o que significa se você atribuir uma variável de um tipo para uma variável de outro tipo, ocorrerá um erro.

Por exemplo, se você assumir que entryDate é uma variável de data e que startTime é uma variável de hora, a atribuição a seguir irá gerar um erro no tempo de execução:

entryDate := startTime; 

Conversões automáticas de tipo

O Developer's Toolkit converte inteiros em reais automaticamente. Por exemplo, assumindo que a variável i seja um inteiro, a instrução

i := 37.0; 

faz com que o valor 37 seja atribuído à variável i sem nenhuma conversão explícita de tipo.
Da mesma forma, se r for um número real, a instrução,

r := i; 

atribui p valor 37.0 à variável r.

Expressões mescladas são tratadas como números reais até que seja feita a atribuição, a fim de que a exatidão seja preservada.

Além disso, quando necessário, o Developer's Toolkit converte automaticamente todos os tipos de dados em cadeias. Por exemplo, a instrução:

s := i; 

atribui o valor de cadeia 37 à variável s.

Expressões de Cadeia com Tipos de Dados Simples

Funções da expressão de cadeia

Uma cadeia no Developer's Toolkit é uma seqüência de caracteres colocados entre aspas simples. O Developer's Toolkit fornece operadores de manipulação de cadeia e instruções que permitem executar operações para:

Operadores e instruções

Operadores de cadeia e instruções estão resumidos na seguinte lista.

Expressões Reais e Inteiros

Expressões aritméticas e operadores

O Developer's Toolkit suporta expressões aritméticas e operadores, conforme resumidos na seguinte tabela.

Operador Descrição
+ Adiciona duas expressões numéricas (i:=3+5)
- Subtrai uma expressão numérica de outra (r:=3.7-2.0)
* Multiplica duas expressões numéricas (i:=3.0*6)
/ Divide duas expressões numéricas (r:=3.0/4.0)
MOD Calcula o restante quando um inteiro é dividido pelo outro (6 MOD 4=2)

Operadores adicionais

Além dos operadores, o Developer's Toolkit suporta as seguintes funções:

Trigonométrico Logarítmico Exponencial
Sin Log Exp
Cos Ln Power
Tan Sqrt n/a
ACos n/a n/a
ASin n/a n/a
ATan n/a n/a
CosH n/a n/a
SinH n/a n/a
TanH n/a n/a


Expressões Booleanas

Operadores Lógicos

Os operadores lógicos AND, OR e NOT podem ser utilizados para criar expressões Booleanas complexas, como:

b := (i > 0) AND (j = 0); 

O Developer's Toolkit executa avaliação Booleana de curto-circuito. Esta forma de avaliação garante que as expressões Booleanas serão avaliadas somente até onde for necessário para determinar seus valores.

No exemplo acima, se i for 0, a variável b assumirá o valor FALSE antes que j seja avaliado. Como regra:

Operadores Relacionais

O Developer's Toolkit fornece os seguintes operadores relacionais para serem utilizados em expressões booleanas.

Operador Descrição
< Menor que
<= Menor ou igual a
> Maior que
>= Maior ou igual a
= Igual
<> Diferente de

Nota: Os operadores relacionais listados acima ignoram maiúsculas e minúsculas na comparação de duas cadeias. Isso significa que as seguinte expressão é TRUE:

'F:\MYFILE' = 'f:\myfile' 

Operadores com distinção entre maiúsculas e minúsculas

Os operadores a seguir são fornecidos para o uso de comparações de cadeias com distinção entre maiúsculas e minúsculas.

Operador Descrição
<< Menor que
<<== Menor ou igual a
>> Maior que
>>== Maior ou igual a
== Igual a
<<>> Diferente de

Consulte a nota na página para obter um exemplo.

Expressões da Data

Embora considerado como um tipo de dados simples, o valor de datas utiliza uma estrutura invisível que permite obter os valores de mês, dia e ano. Utilize notação pontilhada, conforme mostrado no exemplo a seguir.

dayValue := $Today.day; 
monthValue := $Today.month; 
yearValue := $Today.year; 
(* $Today is the system date*) 

Conforme mostrado, qualquer expressão da data pode ser seguido por um ponto e por uma das palavras-chave (dia, mês ou ano) que acessam o valor da data correspondente. No exemplo anterior, dayValue, monthValue e yearValue são variáveis de inteiro.

Como alterar variáveis da data

É possível alterar o valor de mês, dia ou ano de uma variável de data, conforme pode ver aqui:

d := $Today; 
d.year := d.year + 1; 

No exemplo anterior, uma variável de data, d, é atribuída ao valor de data do sistema atual. O ano para d é, então, incrementado por um.

O Developer's Toolkit protege os usuários contra datas inválidas. No exemplo a seguir, a variável de data utiliza um valor "2/1/1999" (não "1/32/1999"):

d := {1,31,1999}: DATE; 
d.day := d.day + 1; 

Como calcular diferenças entre datas

O Developer's Toolkit fornece uma função DateDif para calcular a diferença entre duas datas em meses, dias ou anos.

DateDif requer três argumentos:

Por exemplo:

    age := DateDif($Today,birthDate,$Years);


Expressões da Hora

O Developer's Toolkit fornece vários recursos que permitem manipular expressões da hora. Como as datas, as horas contêm vários valores: hora, minuto e segundo.

Você pode usar notação pontilhada (também utilizada em datas) para acessar as partes diferentes de um valor de hora:

currentHour   := $Now.hour; 
currentMinute := $Now.minute; 
currentSecond := $Now.second; 
(* $Now is the system time*)

Como alterar variáveis de hora

Você também pode alterar uma parte específica de uma variável de hora:

t      := $Now; 
t.hour := t.hour + 3; 

A variável de hora, t, contém o valor de três horas a partir de agora. Os valores de horas possuem um formato interno de 24 horas que permitem meia-noite. O resultado do seguinte exemplo é t contendo o valor {1,0,0}:TIME ou A.M.:

t := {23,0,0}: TIME; 
t.hour := t.hour + 2; 

Como calcular diferenças entre horas

O Developer's Toolkit fornece uma função TimeDif que calcula a diferença entre duas horas. O exemplo a seguir, calcula a diferença entre a hora atual e o startTime anterior em horas, minutos e segundos:

hoursDiff := TimeDif($Now,startTime,$Hours); 
minutesDiff := TimeDif($Now,startTime,$Minutes); 
secondsDiff := TimeDif($Now,startTime,$Seconds); 

Matrizes

Matriz é uma lista de valores de dados do mesmo tipo de dados. É também um tipo de dado estruturado. Os tipos de dados estruturados permitem que operações específicas sejam executadas nos dados.

Qualquer elemento simples (valor de dados) em uma matriz pode ser mencionado por uma expressão composta pelo nome da matriz e seguida por uma expressão de índice. Os elementos em uma matriz são seqüenciais, começando com um (1). Para acessar um elemento específico, é utilizado o valor ou o índice.

No exemplo a seguir, cada índice está colocado entre colchetes:

VARIABLES
  name[10]: ARRAY OF String; 
ACTIONS 
  name[1] := 'Tom'; 
  name[2] := 'Dick'; 
  name[3] := 'Harry'; 

Neste exemplo, name é uma matriz de cadeias. A variável name pode reter até dez valores de cadeia em elementos numerados de 1 a 10.

Como acessar matrizes

As matrizes geralmente são acessadas com variáveis. O seguinte exemplo mostra como a variável de inteiro i é utilizada para acessar um determinado elemento de matriz gravando todos os dez valores da matriz name em um arquivo:

FOR i := 1 TO 10 DO 
  FWriteLN(outputFile,name[i]); 
END; 

A tentativa de acessar um elemento de matriz fora dos limites definidos da matriz fará com que apareça uma mensagem de erro de tempo de execução. Os erros serão gerados por estas instruções:

name[-1] := 'Dick'; 
name[45] := 'Harry';

Cadeias como matrizes

Os valores de cadeia podem ser tratados como matrizes de caracteres. Ao final do seguinte exemplo de código, a variável s possui o valor G:\EADVISOR\ADVISOR\DATA.

VARIABLES
  s : STRING; 
ACTIONS 
  s := 'F:\EADVISOR\ADVISOR\DATA';
  s[1] := 'G'; 

Como redimensionar matrizes

As matrizes do Developer's Toolkit são dinamicamente redimensionáveis. Ou seja, você pode alterar o tamanho de uma matriz no tempo de execução. A instrução SetArrayLength do kit de ferramentas do Developer's Toolkit é utilizada para alterar o tamanho de qualquer matriz. Por exemplo,

SetArrayLength(name,100);

adicionaria 90 novos elementos na matriz de dez slots declaradas anteriormente. Nenhuma das informações nos primeiros dez slots serão afetadas. Você também pode diminuir o tamanho de uma matriz, conforme mostrado neste exemplo:

SetArrayLength(name,5); 

Neste caso, quaisquer valores em slots de 6 a 10 seriam perdidos.

Listas

Semelhante a uma matriz, uma lista do Developer's Toolkit é um tipo de dados estruturados que pode conter vários valores do mesmo tipo. As listas podem ser indexadas com um inteiro colocado entre colchetes.

Vantagens da lista

No Developer's Toolkit, não são necessários endereços, alocação de memória ou desalocação de memória para criar estruturas completas de listas-ligadas. As listas podem ser dimensionadas de forma mais fácil que as matrizes. Além disso, você pode inserir um novo valor no meio da lista, que um processo difícil em uma matriz.

Como utilizar listas

O exemplo a seguir mostra como declarar e utilizar listas:

VARIABLES 
  name: List of String; 
ACTIONS 
  ListInsert(name,'Tom'); 
  ListInsert(name,'Dick'); 
  ListInsert(name,'Harry'); 

Na conclusão deste exemplo de código, o nome é uma lista contendo três valores: 'Tom', 'Dick' e 'Harry'.

Ponteiros da lista

Cada lista mantém um ponteiro que indica o elemento atual em uma lista. É chamado ponteiro da lista. Quando um novo elemento é inserido em uma lista, o ponteiro da lista indica o elemento recentemente inserido. No fim do exemplo anterior, o ponteiro atual apontava para 'Harry'.

O próximo exemplo mostra como inserir um novo elemento no meio de uma lista precedente.

ListSetPos(name,1); 
ListInsert(name,'Ellen'); 

Name agora contém quatro valores: 'Tom,' 'Ellen,' 'Dick' e 'Harry'.

Nota: 'Ellen' está na segunda posição porque $ListInsert está padronizado em $After. O ponteiro da lista aponta para 'Ellen.' ListSetPos move o ponteiro da lista para um determinado elemento.

Outras funções da lista

O Developer's Toolkit fornece uma quantidade de outras funções que permitem manipular as listas.

Função Descrição
ListDelete Remove um elemento da lista. (ListDelete(name,2) remove 'Ellen' do exemplo anterior).
ListLength Retorna o número de elementos na lista.
ListNext Move o ponteiro para o próximo elemento na lista.
ListPrev Move o ponteiro para o elemento anterior na lista.
ListPos Retorna o índice do elemento atual.
ListFind Varre a lista para um determinado valor e retorna TRUE se este valor for encontrado. O ponteiro da lista é mudado para o valor de comparação. Por exemplo, ListFind(name,'Dick') retorna TRUE e move o ponteiro atual para 'Dick.'
ListSort Ordena a lista em ordem crescente.
ListPush Adiciona um novo elemento na parte frontal da lista.
ListPop Remove o primeiro elemento na lista e o retorna.

Devido o fato das listas poderem ser indexadas como as matrizes, a instrução,

s:= name[1];

atribui o valor 'Tom' à variável s.

Loops FOR

O Developer's Toolkit fornece um elemento de loop especial para as listas. A instrução FOR é utilizada para repetir valores na lista. As instruções aninhadas no bloco FOR...END são executadas uma vez para cada elemento na lista. O ponteiro da lista sempre aponta para o primeiro número na lista. O item atual na lista é incrementado por um em cada passagem do loop.

O exemplo a seguir ilustra o uso da instrução FOR:

FOR name DO 
  FWriteLN(outputFile,name[$Current]); 
END; 

Constantes especiais da lista

O exemplo anterior também ilustra o uso de uma constante especial chamada $Current. Esta constante pode ser utilizada para acessar os elementos atuais de uma lista. Outras constantes de lista incluem:

Estas constantes são utilizadas para acessar o primeiro e o último elemento da lista, respectivamente. Por exemplo, as linhas,

FWriteLN(outputFile,name[$First]); 
FWriteLN(outputFile,name[$Last]); 

gravaria "Tom" e "Harry" no arquivo de saída.

Chunking da lista

Muitas instruções do Developer's Toolkit suportam "chunking" automático da lista. Em chunking da lista, as instruções aceitam um único item de um determinado tipo ou uma lista de itens.

Se você passar uma lista, a instrução se aplicará a todos os elementos na lista. Isso também é mencionado como uma instrução com um loop FOR implícito.

WinWriteLN é um exemplo de tal instrução:

WinWriteLN(myWindow,name); 

Esta instrução faz com que cada valor da variável name seja gravado na janela referida como myWindow. Muitas das instruções Window e instruções SQL suporta chunking da lista.

Registros

De forma diferente das listas e matrizes que podem conter vários valores do mesmo tipo, um registro pode conter vários valores de tipos diferentes.

Como declarar uma variável de registro

A declaração de uma variável de tipo de registro envolve um processo de duas etapas:

Nota: Ao declarar uma variável de tipo de registro, você está estendendo a linguagem do Developer's Toolkit com seu próprio tipo de dados.

Exemplo de código de variáveis

Examine o exemplo de código a seguir:

TYPES 
EmployeeRecord IS RECORD 
      first_name, last_name: String; 
      age : Integer; 
      salary : Real; 
      married : Boolean; 
      hireDate : Date; 
      startTime, stopTime : Time; 
END; 
VARIABLES 
  employee: EmployeeRecord; 

O exemplo anterior declara um novo tipo de registro chamado EmployeeRecord. Este registro contém oito campos, cada um dos quais com um tipo de dados simples.

Como consultar campos de variáveis

Tal como com datas e horas, você pode utilizar uma notação (pontilhada) de <campo de>.<variável> para consultar qualquer campo em um registro.
Por exemplo, as linhas a seguir podem ser utilizadas para inicializar a variável employee declarada anteriormente:

employee.first_name := 'Calbert'; 
employee.last_name  := 'Chaney'; 
employee.age        := 21; 
employee.salary     := 2500000.0; 
employee.married    := FALSE; 
employee.hireDate   := {2,15,1993}: DATE; 
employee.startTime  := {8,30,0}: TIME; 
employee.stopTime   := {17,30,0}: TIME; 

Como atribuir variáveis compatíveis

As variáveis do mesmo tipo de registro são de atribuição compatível. Se você declarou uma variável, employee2, do tipo EmployeeRecord, a inclusão da seguinte instrução resultaria em todos os campos da variável employee sendo copiados na variável employee2:

employee2 := employee; 

Você também pode criar listas e matrizes de registros:

employeeList: List Of EmployeeRecord; 

Uma declaração de registro pode conter matrizes, listas e outros registros. Por exemplo, a declaração EmployeeRecord poderia ser alterada da seguinte maneira:

EmployeeRecord IS RECORD 
      first_name, last_name: String;
      age : Integer; 
      salary : Real; 
      married : Boolean; 
      hireDate : Date; 
      startTime, stopTime : Time; 
      manages : List of String;
END; 

O valor manages pode ser utilizado para manter o controle dos nomes dos empregados gerenciados por um determinado empregado.

Instruções de entrada e de saída

O Developer's Toolkit fornece várias instruções que executam entrada e saída do registro de banco de dados.

Por exemplo, a instrução a seguir poderia ser utilizada para carregar uma linha da tabela EMPLOYEES na variável employee declarada anteriormente:

SQLSelectInto('SELECT * FROM EMPLOYEES WHERE
    EMPLOYEE_ID=105',employee); 

Developer's Toolkit:

De forma semelhante, o Developer's Toolkit permite mapear os campos em um registro para um formulário. Quando um usuário pressiona a tecla ENTER após a conclusão de um formulário, as informações na tela são salvas nos campos correspondentes no registro o qual pode ser examinado e manipulado.

Tipos de dados definidos pelo usuário

Além de registros, você pode criar outros tipos definidos pelo usuário. Um tipo definido pelo usuário é um tipo de dados definido em um programa e, geralmente, consiste em uma combinação de tipos de dados. Os tipos definidos pelo usuário geralmente são utilizados para criar estruturas de dados.

A qualquer combinação de listas, matrizes, registros e tipos de dados simples que você utilize em uma declaração de variável podem ser dadas um nome reutilizável em uma declaração de tipo de dados. Por exemplo, você pode definir um novo tipo de dados, conforme mostrado no seguinte exemplo:

TYPES 
StringList = LIST OF STRING; 

Uma vez declarado, você pode utilizar StringList para declarar variáveis, em vez de LIST OF STRING.

Compatibilidade de atribuição

As regras a seguir se referem a compatibilidade de atribuição de tipo de dados estruturados e definidos pelo usuário.

Ao verificar se há compatibilidade de atribuição entre duas variáveis ou expressões, o Developer's Toolkit somente verifica se os nomes do tipo correspondem. Ele não verifica se as declarações do registro são idênticas.

Como inicializar variáveis

Inicialização de uma variável declarada significa que um valor inicial foi atribuído a ele. O Developer's Toolkit permite inicializar variáveis quando elas são declaradas, conforme mostrado no seguinte exemplo:

VARIABLES 
 i {1}                                : INTEGER; 
 s {'F:\MYFILE'}                      : STRING; 
 d {2,11,1956}                        : DATE; 
 l {'Tom','Dick','Harry'}             : LIST OF STRING;
 r {'Steve','Wantz',32,189000.00,TRUE,
   {3,30,1986}                        : DATE, 
   {6,30,0}                           : TIME,
   {4,30,0}                           : TIME,
   {'Tom','Dick','Harry'} : LIST OF STRING :
    EmployeeRecord; 

Convenções de variáveis

Em geral, um nome de variável é acompanhado por:

Você também pode inicializar variáveis de tipos estruturados como listas, matrizes e registros da mesma forma.

Observe que o valor de inicialização está associado à variável e não ao tipo. Dessa forma, na linha,

VARIABLES 
  i, j {27}: INTEGER; 

somente a variável j é inicializada; a variável i não é. Cada variável deve ser inicializada separadamente.

O valor $Unknown

Todas as variáveis não-inicializadas no Developer's Toolkit iniciam com um valor $Unknown. É diferente do C e do Pascal, em que as variáveis começam com valores aleatórios.

A inicialização de todas as variáveis em zero, um, ou em uma cadeia vazia, protegerá contra erros comuns. Por exemplo, se no seguinte:

newSalary := oldSalary*1.05; 

a variável oldSalary não fosse inicializada em algo diferente de $Unknown, ocorreria um erro no tempo de execução porque 1.05 seria multiplicado por $Unknown.


Tivoli Service Desk 6.0 Developer's Toolkit - Guia de Programação do Script

Retornar ao Índice

Copyright