Manual Itris Desarrollador Parte III

Inteligencia Aplicada
Documentación de INTEGRA
Manual del desarrollador
Parte III
(El motor de script PasScript)
martes, 24 de junio de yyyy
Versión 2.5.67
ITRIS
Beruti 4583 Piso 5º
Ciudad de Buenos Aires, Argentina
Tel/Fax +54 +11 4779-9200
www.itris.com.ar
e-mail: info@itris.com.ar
Beruti 4583 Piso 5º, Ciudad de Buenos Aires, Argentina Tel/Fax +54 +11 4779-9200 info@itris.com.ar
Notas Aclaratorias.......................................................................................................................3
Documentación de INTEGRA.....................................................................................................4
Anexo I – PasScript.....................................................................................................................5
Símbolos..................................................................................................................................5
Palabras Reservadas..............................................................................................................6
Comentarios............................................................................................................................7
Expresiones.............................................................................................................................8
Operadores..............................................................................................................................9
Funciones..............................................................................................................................10
Declaraciones........................................................................................................................11
Asignaciones.........................................................................................................................12
Procedimiento y llamadas a funciones..................................................................................13
Sentencias.............................................................................................................................14
Sentencia IF.......................................................................................................................14
Sentencia Case..................................................................................................................16
Sentencia Repeat..............................................................................................................17
Sentencia While.................................................................................................................18
Sentencia For.....................................................................................................................18
Bloques..................................................................................................................................21
Alcance..................................................................................................................................22
Tipos de Datos.......................................................................................................................24
Constantes.............................................................................................................................25
Procedimientos......................................................................................................................27
Funciones..............................................................................................................................28
Parámetros Valor y Variable..................................................................................................30
Funciones frecuentes............................................................................................................32
Tipos de datos frecuentes.....................................................................................................35
Funciones habilitadas para Script.........................................................................................36
Notas Aclaratorias
Word, Excel, Access, Outlook, MS Office, Windows 95, Windows 98, Windows NT, Windows
2000, Windows XP, SQL Server y Microsoft son marcas registradas de Microsoft Corporation.
Oracle es una marca registrada de Oracle Corporation.
ITRIS e INTEGRA son marcas en tramite de Compañía General de Software.
Otros productos y compañías mencionadas en este manual son marcas registradas de sus
respectivos dueños.
La información contenida en este manual esta sujeta a cambios sin previo aviso. Los datos
utilizados en los ejemplos son ficticios. Está prohibida la reproducción total o parcial del
contenido de este manual por cualquier medio.
2002 Compañía General de Software S.R.L. Todos los derechos reservados.
Documentación de INTEGRA
¿Como leer esta documentación?
La documentación se encuentra dividida en las siguientes secciones.

• Descripción de circuitos: Esta refleja circuitos o tareas. Estas tareas pueden
involucrar varios procesos. El objetivo es describir los procesos y los pasos de cada
proceso para llevar a cabo un objetivo determinado. Ejemplo: como agregar una
nueva empresa, o como poner en marcha el sistema.
• Descripción de procesos: En esta sección se refleja cada proceso detalle. Ejemplo:
administración de usuarios, o administración de grupos.
• Generalidades: En esta sección se describen los procesos generales, que afectan el
uso diario del sistema. Ejemplo: selección de la empresa de trabajo, o acceso a la
empresa seleccionada.
Por eso, si se desea un detalle particular acerca de un proceso en particular, la

documentación orientada a procesos será la mejor referencia.
Por otra parte, si se desea documentación referida a circuitos generales o tareas globales, la
documentación orientada a circuitos será la más apropiada.
Con letra cursiva encontrara notas aclaratorias acerca del ítem de referencia.
Con letra negrita encontrara temas destacados acerca del ítem de referencia.
Anexo I – PasScript
En la siguiente sección se detalla el lenguaje de scripting PasScript.
El PasScript es un subconjunto del lenguaje Pascal orientado a objetos. Es muy similar al

lenguaje pascal y es flexible, poderoso y sencillo.
Símbolos
Los símbolos especiales son caracteres no-alfanuméricos, o pares de caracteres, que tienen
significados fijos. Los siguientes caracteres simples son símbolos especiales:
# $ y ' () * +, -./:; < = > @ [ ] ^ {}
Los siguientes pares de caracteres también son símbolos especiales.
(* (.*).)../ /:= < = > = < >
Símbolos equivalentes
Símbolo especial Símbolo equivalente
[ (.
] .)
{ (*
] *)
El corchete izquierdo [ es equivalente al par del caracteres paréntesis izquierdo y punto (.

El corchete derecho ] es equivalente al par del caracteres punto y paréntesis derecho .)
La llave izquierda { es equivalente al par del caracteres paréntesis izquierdo y asterisco (*
La llave derecha } es equivalente al par del caracteres asterisco y paréntesis derecho *)
Nota
%, ?, \, !, "(comillas), _ (underscore), | (pipa), y el ~ (tilde) no son caracteres especiales.
Palabras Reservadas
Las siguientes palabras reservadas no pueden ser redefinidas o ser utilizadas como
identificadores:
and array as asm begin

case class const constructor destructor
dispinterface div do downto else
end except exports file finalization
finally for function goto if
implementation in inherited initialization inline
interface is label library mod
nil not object of or
out packed procedure program property
raise record repeat resourcestring set
shl shr string then threadvar
to try type unit until
uses var while with xor
Además de las palabras mencionadas arriba, PRIVATE, PROTECTED , PUBLIC,

PUBLISHED y AUTOMATED funcionan como palabras reservadas dentro de declaraciones
de tipo de objeto, pero se tratan de otra manera. Las palabras AT y ON también tienen
significados especiales.
Comentarios
Los comentarios son ignorados por el compilador.
Existen varias maneras de construir comentarios:
{ Un texto entre llaves constituye un comentario.}

(*Un texto entre paréntesis izquierdo-asterisco y asterisco-paréntesis derecho también
constituyen un comentario.*)
/ / Cualquier texto entre una doble-raya vertical constituye un comentario.
Los comentarios no pueden ser anidados. Por ejemplo, {{}} no funcionará, solamente (*{}*).
Esto es útil para comentar secciones del código que también contienen comentarios.
Expresiones
Una expresión es una construcción que devuelve un valor. Por ejemplo,
X {variable}
@X {dirección de una variable}
15 {constante entera}
InterestRate {variable}
Calc(X, Y) {llamada de función}
X*Y {producto de X y de Y}
Z / (1 - Z) {cociente de Z y (1 - Z)}
X = 1.5 {Boolean}
C en Range1 {Boolean}
Not Done {negación de un Boolean}
['a','b','c'] {Conjunto}
Char(48) {valor typecast}
Las expresiones más simples son variables y constantes (descritas en Tipos de Datos,
variables, y constantes). Las expresiones más complejas se construyen a partir de
expresiones simples, usando operadores, llamadas a funciones, conjuntos de constructores,
índices y casteos.
Operadores
Los operadores se comportan como funciones predefinidas que son parte del lenguaje
Delphi. Por ejemplo, la expresión (X + Y) se construye de las variables X e Y – llamadas
operandos -- con el operador +; cuando X e Y representan números enteros o reales, (X + Y)
devuelve su suma. Los operadores incluyen @, not, ^, *, /, div, mod, and, shl, shr, as, +, -,
o, xor, =, >, <, <>, <=, >=, in, e is.
Los operadores @, not, y ^ son unarios (tomando un operando). El resto de los operadores
son binarios (tomando dos operandos), excepto que + y – funcionen tanto como un operador
unario o binario. Un operador unario precede siempre a su operando (por ejemplo, - B), a
excepción de ^, que sigue a su operando (por ejemplo, P^). Un operador binario se ubica
entre sus operandos (por ejemplo, A = 7).
Algunos operadores se comportan diferentes dependiendo del tipo de datos que recibe. Por
ejemplo, not significa negación en un operando de número entero y negación lógica en un
operando Boolean. Tales operadores aparecen abajo bajo categorías múltiples.
Excepto para ^, is, e in, todos los operadores pueden tomar operandos del tipo VARIANT.
Funciones
Debido a que las funciones devuelven un valor, las llamadas a funciones son expresiones.
Por ejemplo, si se ha definido una función llamada Calc que toma dos enteros y devuelve un
entero, entonces la función Calc(24, 47) es una expresión entera. Si I y J son variables
enteras, entonces I + Calc(J, 8) es también una expresión entera.
En los ejemplos de funciones se incluyen:
Sum(A, 63)
Maximum(147, J)
Sin(X + Y)
Eof(F)
Volume(Radius, Altura)
GetValue
TSomeObject.SomeMethod(I, J);
Declaraciones
Los nombres de variables, constantes, tipos, campos, propiedades, procedimientos,

funciones, programas, units, librerías, y paquetes son llamados identificadores. (Constantes
numéricas como 26057 no son identificadores). Los identificadores deben ser declarados
antes de ser usados; las únicas excepciones son algunos tipos predefinidos, rutinas, y
constantes que el compilador entiende automáticamente; la variable Result cuando ocurre
dentro de un bloque de función, y la variable Self cuando ocurre dentro de una
implementación de método.
Una declaración define un identificador y, cuando sea apropiado, asigna la memoria para él.
Por ejemplo,
var Size: Extended;
declara una variable llamada Size que contiene un valor Extended (real), mientras que
function DoThis(X, Y: string): Integer;
declara una función llamada DoThis que toma dos strings como argumentos y devuelve un
entero. Cada declaración termina con un punto y coma. Cuando se declaran varias variables,
constantes, tipos, o etiquetas al mismo tiempo, se necesita solamente escribir la palabra
reservada apropiada una vez:
var
Size: Extended;
Quantity: Integer;
Description: string;
La sintaxis y ubicación de una declaración dependen de la clase de identificador que se está

definiendo. En general, las declaraciones se realizan solamente al comienzo de un bloque o
al comienzo de una interfaz.
Asignaciones
Una declaración de asignación tiene la forma
variable := expresión
donde la variable es cualquier variable de referencia -- incluyendo un variable o componente

de una variable estructurada -- y la expresión es cualquier expresión asignable (dentro de un
bloque de la función, la variable se puede sustituir por el nombre de la función que es
definida). El símbolo := a veces se llama operador de asignación.
Una declaración de asignación reemplaza el valor actual de una variable por el valor de la
expresión. Por ejemplo,
I := 3;
asigna el valor 3 a la variable I. La variable de referencia en el lado izquierdo de la asignación

puede aparecer en la expresión a la derecha. Por ejemplo,
I := I + 1;
incrementa el valor de I. Otras declaraciones de asignación incluyen
X := Y + Z;
Done := (I >= 1) and (I < 100);
Hue1 := [Blue, Succ(C)];
I := Sqr(J) - I * K;
Shortint(MyChar) := 122;
TByteRec(W).Hi := 0;
MyString[I] := 'A';
SomeArray[I + 1] := P^;
TMyObject.SomeProperty := True;
Procedimiento y llamadas a funciones
Una llamada a un procedimiento consiste en el nombre de un procedimiento (con o sin los

calificadores), seguido por una lista del parámetro (si está requerido). Los ejemplos incluyen
PrintHeading;
Transpose(A, N, M);
Find(Smith, William);
Writeln('Hello world!');
DoSomething();
TMyObject.SomeMethod(X,Y);
Las llamadas a funciones, como las llamadas a procedimientos, se pueden tratar como
declaraciones a su derecha:
MyFunction(X);
Cuando se utiliza una llamada a una función de esta manera, el valor que devuelve se
desecha.
Sentencias
Sentencia IF
Hay dos formas de sentencias if: if...then y if...then...else. La sintaxis de la sentencia

if...then es
if expression then statement
donde expression devuelve un valor Boolean. Si expression es verdadero, luego se ejecuta

statement; de otra manera no se ejecuta. Por ejemplo,
if J <> 0 then Result := I/J;
La sintaxis de la sentencia if...then...else es
if expression then statement1 else statement2
donde expression devuelve un valor Boolean. Si expression es verdadero, luego se ejecuta

statement1; de otra manera se ejecuta statement2. Por ejemplo,
if J = 0 then
Exit
else
Result := I/J;
Las cláusulas then y else contienen cada una una sentencia, puede ser una sentencia
estructurada. Por ejemplo,
if J <> 0 then
begin
Result := I/J;
Count := Count + 1;
end
else if Count = Last then
Done := True
else
Exit;
Notar que nunca hay punto y coma entre la cláusula then y la palabra else. Se puede poner
un punto y coma después de una sentencia entera del if para separarla de la sentencia
siguiente, pero las cláusulas then y else no requieren nada más que un espacio entre ellas.
Poner un punto y coma inmediatamente antes de else (en una sentencia if) es un error de
programación común.
Un dificultad especial se presenta en la conexión con sentencias if anidadas. El problema se

presenta porque algunas sentencias if tienen cláusulas else mientras que otras no las tienen,
pero la sintaxis para los dos tipos de sentencias es la misma. En una serie de condicionales
anidados donde hay menos cláusulas else que sentencias if, pueden no ser claro que las
cláusulas else están limitadas por cuales ifs. Considere una sentencia de la forma
if expression1 then if expression2 then statement1 else statement2;
There would appear to be two ways to parse this:
if expression1 then [ if expression2 then statement1 else statement2];

if expression1 then [ if expression2 then statement1] else statement2;
El compilador analiza siempre de la primera forma. Es decir, en código verdadero, la

sentencia
if ... { expression1 } then

... { statement1 }
else
... { statement2 } ;
es equivalente a

begin
... { statement1 }
else
... { statement2 }
end;
La regla es que los condicionales anidados son analizados al comienzo del condicional mas
interior, con cada else limitado por el if disponible a su izquierda más cercano. Para forzar al
compilador a leer nuestro ejemplo de la segunda manera, se deberá escribir esto
explícitamente como

begin
... { statement1 }
end
else
... { statement2 } ;
Sentencia Case
La sentencia case puede proporcionar un alternativa legible para condicionales if anidados.

Una sentencia case tiene la forma
case selectorExpression of
caseList1: statement1;
...
caseListn: statementn;
end
donde selectorExpression es cualquier expresión de tipo ordinal (tipos string son inválido) y
cada caseList es uno de los siguientes:
• Un numeral, la constante declarada, u otra expresión que el compilador pueda evaluar

sin ejecutar su programa. Debe ser de un tipo ordinal compatible con
selectorExpression.
Así 7, True, 4 + 5 * 3, ' A ', e Integer('A ') pueden ser todos utilizados como caseLists, pero las
variables y la mayoría de las llamadas de función no pueden.
Un subrango que tiene la forma First..Last, donde First y Last satisfacen el criterio
mencionado arriba y First es menos que o igual a Last.
Una lista que tiene la forma item1,..., itemn, donde cada item satisface uno de los criterios
mencionados arriba.
Cada valor representado por un caseList debe ser único en la sentencia case; los subrangos
y las listas no se pueden solapar. Una sentencia case puede tener una cláusula else final:
case selectorExpression of
caseList1: statement1;
...
caseListn: statementn;
else
statements;
end
donde statements es una secuencia de sentencias delimitadas por punto y coma. Cuando se
ejecuta una sentencia case, al menos una statement1...statementn es ejecutada. Cualquier
caseList tiene un valor igual al del selectorExpression, determinando la sentencia que se
utilizará. Si ninguno de los caseLists tienen el mismo valor que el selectorExpression,
entonces las sentencias en la cláusula else (si hay una) se ejecutan.
La sentencia case
case I of
1..5: Caption := 'Low';
6..9: Caption := 'High';

0, 10..99: Caption := 'Out of range';
else
Caption := '';
end;
es equivalente al condicional anidado
if I in [1..5] then
Caption := 'Low'
else if I in [6..10] then
Caption := 'High'
else if (I = 0) or (I in [10..99]) then
Caption := 'Out of range'
else
Caption := '';
Otros ejemplos de sentencias case:
case MyColor of
Red: X := 1;
Green: X := 2;
Blue: X := 3;
Yellow, Orange, Black: X := 0;
end;
case Selection of
Done: Form1.Close;
Compute: CalculateTotal(UnitCost, Quantity);
else
Beep;
end;
Sentencia Repeat
La sintaxis de una sentencia repeat es
repeat statement1; ...; statementn; until expression
donde la expresión devuelve un valor Boolean. (El último punto y coma antes de until es
opcional). La sentencia repeat ejecuta su secuencia de sentencias constitutivas
continuamente, evaluando expression después de cada iteración. Cuando expression
devuelve verdadero, la sentencia repeat termina. La secuencia se ejecuta siempre por lo
menos una vez porque expresión no se evalúa hasta después de la primera iteración.
Ejemplos de sentencias repeat
repeat
K := I mod J;
I := J;
J := K;
until J = 0;
repeat
Write('Enter a value (0..9): ');
Readln(I);
until (I >= 0) and (I <= 9);
Sentencia While
Una sentencia while es similar a una sentencia repeat, excepto que la condición del control
es evaluada antes de la primera ejecución de la secuencia de sentencias. Por lo tanto, si la
condición es falsa, la secuencia de sentencias nunca se ejecuta.
La sintaxis de una sentencia while es
while expression do statement
donde expression devuelve un valor Boolean y la sentencia puede ser una sentencia
compuesta. La sentencia while ejecuta su statement constitutiva repetidamente, evaluando
expression antes de cada iteración. Mientras expression devuelve verdadero, la ejecución
continúa.
Ejemplos de sentencias while
while Data[I] <> X do I := I + 1;

while I > 0 do
begin
if Odd(I) then Z := Z * X;
I := I div 2;
X := Sqr(X);
end;
while not Eof(InputFile) do
begin
Readln(InputFile, Line);
Process(Line);
end;
Sentencia For
Una sentencia for, a diferencia de una sentencia repeat o while, requiere que se especifique
explícitamente el número de iteraciones que se desee realizar. La sintaxis de sentencia for
for counter := initialValue to finalValue do statement
for counter := initialValue downto finalValue do statement
donde
• counter es una variable local (declarada en del bloque que contiene la sentencia for)
de tipo ordinal, sin ningunos calificadores.
• initialValue y finalValue son expresiones que son compatibles de asignación con
counter.
Statement es una sentencia simple o estructurada que no cambia el valor de counter.
La sentencia for asigna el valor del initialValue a counter, después ejecuta statement
repetidamente, incrementando o decrementando counter después de cada iteración. (La
sintaxis for..to incrementa counter, mientras que la sintaxis for..downto decrementa
counter). Cuando counter devuelve el mismo valor que finalValue, statement se ejecuta una
vez más y la sentencia for termina. Es decir, statement se ejecuta una vez por cada valor en
el rango de initialValue a finalValue. Si initialValue es igual a finalValue, statement se ejecuta
exactamente una vez. Si initialValue es mayor a finalValue en una sentencia for..to, o es
menor a finalValue en una sentencia for..downto, statement nunca se ejecuta. Después de
que la sentencia for termina, el valor de counter es indefinido.
Con el propósito de controlar la ejecución de un loop, las expresiones initialValue y finalValue
son evaluadas solamente una vez, antes de que el loop comience. Por lo tanto la sentencia
for..to es casi, pero no absolutamente, equivalente a esta construcción while:
begin
counter := initialValue;
while counter <= finalValue do
begin
statement;
counter := Succ(counter);
end;
end
La diferencia entre esta construcción y sentencia for..to es que el loop del while reevalúa
finalValue antes de cada iteración. Esto puede dar lugar a un funcionamiento
perceptiblemente más lento si finalValue es una expresión compleja, y también significa que
los cambios al valor finalValue dentro statement pueden afectar la ejecución del loop.
Ejemplos de sentencias for:
for I := 2 to 63 do
if Data[I] > Max then
Max := Data[I];
for I := ListBox1.Items.Count - 1 downto 0 do
ListBox1.Items[I] := UpperCase(ListBox1.Items[I]);
for I := 1 to 10 do
for J := 1 to 10 do
begin
X := 0;
for K := 1 to 10 do
X := X + Mat1[I, K] * Mat2[K, J];
Mat[I, J] := X;
end;
for C := Red to Blue do Check(C);
Bloques
Un bloque consiste en una serie de declaraciones seguido por una declaración compuesta.
Todas las declaraciones deben realizarse al comienzo del bloque. La forma de un bloque es
declarations
begin
statements
end
La sección declarations puede incluir, en cualquier orden, las declaraciones de variables,

constantes, tipos, procedimientos, funciones, y etiquetas. En un bloque del programa, la
sección declarations puede también incluir una o más cláusulas de exportaciones.
Por ejemplo, en una declaración de función como
function UpperCase(const S: string): string;

var
Ch: Char;
L: Integer;
Source, Dest: PChar;
begin
...
end;
la primera línea de la declaración es el título de la función y todas las líneas siguientes hacen
el bloque. Ch, L, Source, y Dest son variables locales; sus declaraciones se aplican
solamente al bloque de la función UpperCase y eliminan -- en este bloque solamente --
cualquier declaración de los mismos identificadores que pueda ocurrir en el bloque del
programa o en el interfaz o la sección implementación de unit.
Alcance
Un identificador, como una variable o nombre de función, pueden ser utilizados solamente
dentro del alcance de su declaración. La localización de una declaración determina su
alcance. Un identificador declarado dentro de la declaración de un programa, función, o
procedimiento tiene un alcance limitado al bloque en el cual fue declarado. Un identificador
declarado en la sección interfaz de una unit tiene un alcance que incluye cualquier otra unit o
programa que utilicen la unit donde ocurre la declaración. Los identificadores con un alcance
más estrecho -- especialmente identificadores declarados en funciones y procedimientos -- a
veces se llaman locales, mientras que los identificadores con un alcance más amplio se
llaman globales
Las reglas que determinan alcance de un identificador se resumen abajo.
Si el identificador es declarado en ... su el alcance extiende...
la definición de un tipo de registro (es decir, el desde el punto de su declaración hasta el final
de la definición del identificador es el nombre de un campo en el tipo de registro)
la definición de una clase (es decir, el identificador desde el punto de su declaración hasta el
final de la definición del el nombre de una propiedad o método de clase, y también incluye los
descendientes de la clase y los bloques de todos los métodos en la clase y sus
descendientes.
Maxi: PasScript soporta clases ¿?
Conflictos
Cuando un bloque incluye a otro, el anterior se llama bloque externo y el último bloque
interno. Si un identificador declarado en un bloque externo es redeclarado en un bloque
interno, la declaración interna toma precedencia sobre la externa y determina el significado
del identificador para la duración del bloque interno. Por ejemplo, si se declara una variable
llamada MaxValue en la sección interfaz de una unit, y luego se declara otra variable con el
mismo nombre en una declaración de una función dentro de esa unit, cualquier ocurrencia de
MaxValue en el bloque de la función es gobernada por la segunda, declaración local. De
forma semejante, una función declarada dentro de otra función crea un nuevo alcance interno
en el cual los identificadores utilizados por la función externa pueden ser redeclarados
localmente.
El uso de múltiples units complica la definición del alcance. Cada unit enumerada en la
cláusula de uso impone un nuevo alcance que incluye las units restantes usadas y el
programa o la unit que contiene la cláusula de uso. La primer unit en una cláusula de uso
representa el alcance exterior y cada unit siguiente representa un nuevo alcance dentro del
anterior. Si dos o más units declaran el mismo identificador en sus secciones de interfaz, una
referencia incompetente al identificador selecciona la declaración en el alcance mas interno --
es decir, en la unit donde ocurre la referencia, o, si esa unit no declara el identificador, en la

última unit en la cláusula de uso que declara el identificador.
Las units System y SysInit son utilizadas automáticamente por cada programa o unit. Las
declaraciones en el System, junto con los tipos predefinidos, rutinas, y constantes que el
compilador entiende automáticamente, tienen siempre el alcance exterior.
Se puede eliminar estas reglas del alcance y puentear un declaración interno usando un
identificador calificado o con una sentencia.
Tipos de Datos
Existen varias formas de categorizar los tipos de datos de Delphi:
Algunos tipos se predefinen (o built-in); el compilador los reconoce automáticamente, sin la

necesidad de un declaración. Casi todos los tipos documentados en esta referencia se
predefinen. Otros tipos son creados por una declaración; éstos incluyen tipos definidos por el
usuario y los tipos definidos en las librerías del producto.
Los tipos pueden ser clasificado como fundamentales o genéricos. El rango y formato de un
tipo fundamental es el mismo en todas las implementaciones del lenguaje Delphi, sin
importar la CPU y el sistema operativo. El rango y formato de un tipo genérico es una
plataforma específica y podrían variar a través de diferentes implementaciones. La mayoría
de los tipos predefinidos son fundamentales, pero varios tipos entero, carácter, secuencia, y
puntero son genéricos. Es una buena idea utilizar tipos genéricos cuando es posible, puesto
que proporcionan funcionamiento y portabilidad óptimos. Sin embargo, los cambios en el
formato de almacenamiento a partir de la implementación de un tipo genérico al siguiente
podrían causar problemas de compatibilidad.
Los tipos se pueden clasificar como simple, string, estructurado, puntero, procedural, o
variant. Además, el tipo identificadores se puede mirar como perteneciente a un tipo especial
porque pueden ser pasados como parámetros a ciertas funciones (tales como High, Low, y
SizeOf).
Abajo se muestra la taxonomía de tipos de datos de Delphi
simple
ordinal
integer
character
Boolean
enumerated
subrange
real
string
estructurado
conjunto
array
record
file
class
class reference
interface
puntero
procedural
variant
Constantes
Una constante verdadera es un identificador declarado cuyo valor no puede cambiar. Por
ejemplo,
const MaxValue = 237;
declara una constante llamada a MaxValue que devuelve el número entero 237. La sintaxis
para declarar una constante verdadera es
const identificador = constantExpression
donde identificador es cualquier identificador válido y constantExpression es una expresión

que el compilador puede evaluar sin ejecutar su programa.
Si constantExpression devuelve un valor ordinal, se podrá especificar el tipo de la constante

declarada usando un valor typecast. Por ejemplo
const MyNumber = Int64(17);
declara una constante llamada MyNumber, de tipo Int64, que devuelve el número entero 17.
Si no, el tipo de la constante declarada es el tipo de constantExpression.
Si constantExpression es una cadena de caracteres, la constante declarada es compatible

con cualquier tipo cadena. Si la cadena de caracteres es de longitud 1, es también
compatible con cualquier tipo caracter.
• Si constantExpression es un real, su tipo es Extendido. Si es un número entero, su
tipo es dado por la siguiente tabla.
Tipos para constantes enteras
Rango de constantes(hexadecimal) Rango de constantes(decimal) Tipo

-$8000000000000000..-$80000001 -2^63..-2147483649 Int64
-$80000000..-$8001 -2147483648..-32769 Integer
-$8000..-$81 -32768..-129 Smallint
-$80..-1 -128..-1 Shortint
0..$7F 0..127 0..127
$80..$FF 128..255 Byte
$0100..$7FFF 256..32767 0..32767
$8000..$FFFF 32768..65535 Word
$10000..$7FFFFFFF 65536..2147483647 0..2147483647
$80000000..$FFFFFFFF 2147483648..4294967295 Cardinal
$100000000..$7FFFFFFFFFFFFFFF 4294967296..2^63-1 Int64
Algunos ejemplos de declaraciones de constantes:

const
Min = 0;
Max = 100;
Center = (Max - Min) div 2;
Beta = Chr(225);
NumChars = Ord('Z') - Ord('A') + 1;
Message = 'Out of memory';
ErrStr = ' Error: ' + Message + '. ';
ErrPos = 80 - Length(ErrStr) div 2;
Ln10 = 2.302585092994045684;
Ln10R = 1 / Ln10;
Numeric = ['0'..'9'];
Alpha = ['A'..'Z', 'a'..'z'];
AlphaNum = Alpha + Numeric;
Procedimientos
Una declaración de procedimiento tiene la forma
procedure Nombre del procedimiento(Lista de parámetros);

Declaraciones locales;
begin
Sentencias
end;
donde el Nombre del procedimiento es cualquier identificador válido, las Sentencias son una
secuencia de sentencias que se ejecutan cuando se llama al procedimiento, y (Lista de
parámetros) y Declaraciones locales; son opcionales.
Ejemplo de declaraciones de procedimiento:
procedure NumString(N: Integer; var S: string);

var
V: Integer;
begin
V := Abs(N);
S := '';
repeat
S := Chr(V mod 10 + Ord('0')) + S;
V := V div 10;
until V = 0;
if N < 0 then S := '-' + S;
end;
Dado esta declaración, se puede llamar el procedimiento NumString de esta forma:
NumString(17, MyString);
Esta llamada al procedimiento asigna el valor "17" a MyString (que debe ser una variable
string).
Dentro de un bloque de sentencias de un procedimiento, se puede utilizar variables y otros

identificadores declarados en la parte del procedimiento Declaraciones locales. Se puede
también utilizar los nombres de los parámetros de la lista de parámetros (como N y S en el
ejemplo anterior); la lista de parámetros define un conjunto de variables locales, así que no
se debe redeclarar los nombres de los parámetros en la sección Declaraciones locales.
Finalmente, se puede utilizar cualquier identificador dentro del alcance del procedimiento.
Funciones
Una declaración de función es como un declaración de procedimiento excepto porque se

debe especificar el tipo de resultado y un valor de resultado. Las declaraciones de función
tienen la forma
function e Nombre de la función(Lista de parámetros): Tipo de resultado;

Declaraciones locales;
begin
Sentencias
end;
donde Nombre de la función es cualquier identificador válido, Tipo de resultado es un tipo

identificador, las sentencias son una secuencia de las sentencias que se ejecutan cuando se
llama a la función, y (Lista de parámetros) y Declaraciones locales; son opcionales.
El bloque de sentencias de la función es gobernado por las mismas reglas que se aplican a
los procedimientos. Dentro del bloque de sentencias, se pueden utilizar variables y otros
identificadores declarados en la parte de la función Declaraciones locales, los nombres de
parámetros de la lista del parámetros, y cualquier identificador dentro del alcance del
procedimiento. Además, el nombre en sí mismo de la función actúa como variable especial
que contiene el valor de resultado de la función, al igual que la variable predefinida Result.
Result se declarará implícitamente en cada función.
function WF: Integer;

begin
WF := 17;
end;
define una función constante llamada WF que no toma parámetros y devuelve siempre el
valor entero 17. Esta declaración es equivalente a
function WF: Integer;

begin
Result := 17;
end;
Aquí una declaración más complicada de la función:
function Max(A: array of Real; N: Integer): Real;

var
X: Real;
I: Integer;
begin
X := A[0];
for I := 1 to N - 1 do
if X < A[I] then X := A[I];
Max := X;
end;
Se puede asignar un valor a Result o al nombre de la función en varias ocasiones dentro de

un bloque de sentencia, mientras se asignen solamente valores que concuerden con el tipo
de resultado declarado. Cuando la ejecución de la función termina, cualquier valor que haya
sido asignado último a Result o al nombre de la función se convierte en el valor de resultado
de la función. Para ejemplo,
function Power(X: Real; Y: Integer): Real;

var
I: Integer;
begin
Result := 1.0;
I := Y;
while I > 0 do
begin
if Odd(I) then Result := Result * X;
I := I div 2;
X := Sqr(X);
end;
end;
Result y el nombre de la función representan siempre el mismo valor. Por lo tanto
function MyFunction: Integer;

begin
MyFunction := 5;
Result := Result * 2;
MyFunction := Result + 1;
end;
devuelve el valor 11. Pero Result no es totalmente intercambiable con el nombre de la

función. Cuando el nombre de la función aparece en el lado izquierdo de una sentencia de
asignación, el compilador asume que se está utilizando (como Result) para seguir el valor de
devolución; cuando el nombre de la función aparece en cualquier otro lugar en el bloque de
la sentencia, el compilador lo interpreta como llamada recurrente a la función en sí misma.
Result, por otra parte, se puede utilizar como variable en operaciones, typecasts, conjunto de
constructores, índices, y llamadas a otras rutinas.
Si la función termina sin asignar un valor a Result o al nombre de la función, entonces el

valor que devuelve la función es indefinido.
Parámetros Valor y Variable
La mayoría de los parámetros son parámetros valor (por defecto) o parámetros variable
(var). Los parámetros valor son pasados por valor, mientras que los parámetros variables
son pasados por referencia. Para ver lo que esto significa considerar las siguientes las
funciones.
function DoubleByValue(X: Integer): Integer; // X es un parámetros valor

begin
X := X * 2;
Result := X;
end;
function DoubleByRef(var X: Integer): Integer; // X es un parámetros variable

begin
X := X * 2;
Result := X;
end;
Éstas funciones devuelven el mismo resultado, pero solamente la segunda -- DoubleByRef --

puede cambiar el valor de una variable pasada a ella. Suponga que llamamos las funciones
como sigue:
var
I, J, V, W: Integer;
begin
I := 4;
V := 4;
J := DoubleByValue(I); // J = 8, I = 4
W := DoubleByRef(V); // W = 8, V = 8
end;
Después de ejecutar este código, la variable I, que fue pasada a DoubleByValue, tiene el
mismo valor que le asignamos inicialmente. Pero la variable V, que fue pasado a
DoubleByRef, tiene un valor diferente.
Un parámetro valor actúa como una variable local que es inicializada con el valor pasado en
la llamada al procedimiento o función. Si se pasa una variable como parámetro valor, el
procedimiento o función crea una copia de ella; los cambios realizados a la copia no tienen
ningún efecto sobre la variable original y se pierden cuando la ejecución del programa
regresa al llamador.
Un parámetro variable, por otra parte, actúa como un puntero más que como una copia. Los
cambios realizados al parámetro dentro del cuerpo de una función o de un procedimiento
persisten después de que la ejecución del programa regresa al llamador y el nombre del
parámetro ha salido del alcance.
Funciones frecuentes
La siguiente tabla muestra los procedimientos y funciones mas frecuentemente usados:
Otras rutinas estándares
Procedimiento o función Descripción

ArcTan Calcula el arco tangente de un número dado.
Assigned Devuelve si un puntero esta asignado.
Beep Genera una señal sonora estándar.
Break Provoca que un ciclo for, while, o repeat corte su ejecución.
ByteToCharIndex Devuelve la posición del caracter que contiene un byte
especificado en una secuencia.
Chr Devuelve el caracter para un valor entero especificado.
Close Cierra un archivo.
CompareMem Realiza una comparación binaria de dos imágenes de memoria.
CompareStr Compara strings distinguiendo mayúsculas y minúsculas.
CompareText Compara strings sin distinguir mayúsculas y minúsculas.
Continue Devuelve el control a la próxima iteración de sentencias for, while,
o repeat.
Copy Devuelve un substring de un string o un segmento de un array
dinámico.
Cos Calcula el coseno de un ángulo.
CurrToStr Convierte una variable currency a string.
Date Devuelve la fecha actual.
DateTimeToStr Convierte una variable de tipo TDateTime a string.
DateToStr Convierte una variable de tipo TDateTime a string.
Dec Decrementa una variable ordinal o una variable tipo puntero.
Exit Salida del proceso actual.
Exp Calcula el exponencial de X.
FloatToStr Convierte un valor de punto flotante a string
FloatToStrF Convierte un valor de punto flotante a string, usando un formato
especificado.
FmtStr Monta un string ajustado al formato de una serie de arrays.
Format Monta un string ajustado al formato y una serie de arrays.
FormatDateTime Da formato a un valor de fecha-y-hora.
FormatFloat Da formato a un valor de punto flotante.
High Devuelve el valor más alto de un tipo, array o string.
Inc Incrementa una variable ordinal o una variable tipo puntero.
Insert Inserta un substring en un punto especificado de un string.
Int Devuelve la parte entera de un número real.
IntToStr Convierte un entero a string.
Length Devuelve la longitud de un string o array.
Low Devuelve el valor más bajo de un tipo, array o string.
LowerCase Convierte un string ASCII a minúsculas.

MaxIntValue Devuelve el valor con signo más grande en un array de enteros.
MaxValue Devuelve el valor con signo más grande en un array.
MinIntValue Devuelve el valor con signo más pequeño en un array de enteros.
MinValue Devuelve el valor con signo más pequeño en un array.
Now Devuelve la fecha y hora actual.
Ord Devuelve el valor entero ordinal de una expresión tipo ordinal.
Pos Devuelve el índice al primer caracter de un substring en un string.
Pred Devuelve el predecesor de un valor ordinal.
Ptr Convierte un valor a puntero.
Random Genera números al azar dentro de un rango especificado.
Round Devuelve el valor de un real redondeado al número entero más
cercano.
SetLength Configura la longitud dinámica de una variable string variable o
array.
SetString Configura el contenido y la longitud de un string dado.
ShowException Muestra un mensaje de excepción con su dirección.
ShowMessage Exhibe una caja de mensaje con un string sin formato y un botón
OK.
ShowMessageFmt Exhibe una caja de mensaje con un string con formato y un botón
OK.
Sin Devuelve el seno de un ángulo en radianes.
SizeOf Devuelve el número de bytes ocupados por una variable o tipo.
Sqr Devuelve la raíz de un número.
Sqrt Devuelve la raíz cuadrada de un número.
Str Convierte un número entero o real a string.
StrToCurr Convierte un string al valor actual.
StrToDate Convierte un string a un formato fecha (TDateTime).
StrToDateTime Convierte un string a TDateTime.
StrToFloat Convierte un string a punto flotante.
StrToInt Convierte un string a entero.
StrToTime Convierte un string a un formato hora (TDateTime).
StrUpper Devuelve un string ASCII en mayúsculas.
Succ Devuelve el sucesor de un valor ordinal.
Sum Devuelve la suma de los elementos de un array.
Time Devuelve la hora actual.
TimeToStr Convierte una variable de tipo TDateTime a string.
Trunc Trunca un número real a un número entero.
UniqueString Asegura que un string tiene solamente una referencia.
UpCase Convierte un caracter a mayúsculas.
UpperCase Devuelve un string en mayúsculas.
VarArrayCreate Crea un array de variant.
VarArrayDimCount Devuelve el número de dimensiones de un array de variant.
VarArrayHighBound Devuelve el límite alto de la dimensión de un array de variant.
VarArrayLock Atrapa un array de variant y devuelve un puntero a los datos.
VarArrayLowBound Devuelve el límite bajo de la dimensión de un array de variant.
VarArrayOf Crea y llena un array de variant unidimensional.

VarArrayRedim Redimenciona un array de variant.
VarArrayRef Devuelve una referencia al array de variant pasado.
VarArrayUnlock Abre un array de variant.
VarAsType Convierte un variant al tipo especificado.
VarCast Convierte un variant a un tipo especificado, almacenando el
resultado en una variable.
VarClear Limpia un variant.
VarCopy Copia un variant.
VarToStr Convierte un variant a string.
VarType Devuelve el tipo de código de un variant especificado.
Tipos de datos frecuentes
Tipo Descripción
TUpdateKind Conjunto. Representa los valores posibles de tipos de actualización.
ukModify: The update to the record is a modification to the record's

contents.
ukInsert: The update is the insertion of a new record.
ukDelete: The update is the deletion of a record.
1) Agregar un comprobante
En el aceptar del maestro llega ukInsert.
En el aceptar del detalle llega ukInsert
2) Modificar un detalle de un comprobante

En el aceptar del maestro llega ukModify.
En el aceptar del detalle llega ukModify
3) Agregar un detalle a un comprobante existente

En el aceptar del detalle llega ukInsert
4) Borrar un detalle a un comprobante existente

En el aceptar del detalle llega ukDelete
TCustomConnection Clase. Conecta datasets a una fuente de datos.

TdataSet Clase. Representa información en forma de filas y columnas. DataSet
define las propiedades y métodos basicos para trabajar con datos.
Atributos
Metodos
ItsDuplicate: tipo, que indica, donde se lo puede usar (scope)
Funciones habilitadas para Script
ItsFLChanged (DataSet: TDataSet; FieldName: string): boolean;

Comprueba si se realizaron cambios en un determinado dataset. Recibe 2 parámetros , el
dataset y el nombre del campo. Retorna True si hubo cambios o de lo contrario False
ItsFLEmpty (DataSet: TDataSet; FieldName: string): boolean;

Comprueba si un campo esta vacío o no. Recibe 2 parámetros, el dataset y el nombre del
campo. Retorna True si esta vacío (Para campos string asume '' como vacio) o de lo
contrario False
ItsFLCurValue (DataSet: TDataSet; FieldName: string): Variant;

Devuelve el valor actual del campo. Nunca devuelve nulo, para fechas nulas devuelve
31/12/1899, para enteros o flotantes nulos devuelve 0, para strings nulos devuelve '' devuelve
el valor actual del campo forzado a double. Recibe 2 parámetros, el dataset y el nombre del
campo. Retorna el contenido del campo (con las restricciones mencionadas anteriormente) .
ItsFLAsFloat (DataSet: TDataSet; FieldName: string): double;

Devuelve el valor actual del campo forzado a double.. Recibe 2 parámetros, el dataset y el
nombre del campo. Retorna el contenido del campo en flotante.
ItsFLAsInteger(DataSet: TDataSet; FieldName: string): integer;

Devuelve el valor del campo forzado a integer
ItsFLAsString(DataSet: TDataSet; FieldName: string): string;

Devuelve el valor del campo forzado a string
ItsFLAsBoolean(DataSet: TDataSet; FieldName: string): boolean;

Devuelve el valor forzado a boolean, considerando tipos especiales como booleanos
ItsFLAsDateTime(DataSet: TDataSet; FieldName: string): TDateTime;

Devuelve el valor forzado a fecha y hora
ItsFLAsSQLStr(DataSet: TDataSet; FieldName: string): string;

Devuelve el valor actual del campo como un string con formato SQL
ItsFLOldValue(DataSet: TDataSet; FieldName: string): Variant;

Devuelve el valor anterior del campo. Toma el mismo criterio que ItsFLCurValue
ItsFLWCurValue(DataSet: TDataSet; FieldName: string; Value: Variant);

Graba el valor de un campo.
Para campos string, si se envía Null graba ''.
Para campos booleanos, si se envía null graba false
ItsDSGetMaster(DataSet: TDataSet): TDataSet;

Devuelve el dataset maestro del actual (solo si es un detalle)
ItsDSGetDetail(DataSet: TDataSet; DetailName: string): TDataSet;

Devuelve un dataset detalle anidado
ItsDSDetailCount(DataSet: TDataSet): integer;

Devuelve la cantidad de datasets anidados (solo funciona para ClientDataSet)
ItsDSGetDetailIdx(DataSet: TDataSet; Index: integer): TDataSet;

Devuelve un detalle por el índice absoluto (solo funciona para ClientDataSet)
ItsDSAppend(aDataSet: TDataSet);
Agrega un registro nuevo al dataset.
ItsDSDelete(aDataSet: TDataSet);
Borra el registro activo del dataset.
ItsDSDeleteAll(aDataSet: TDataSet);
Borra todos los registros del dataset.
ItsDSPost(aDataSet: TDataSet);
Graba el dataset.
ItsDSFirst(aDataSet: TDataSet);
Devuelve el primer registro del dataset
ItsDSNext(aDataSet: TDataSet);
Devuelve el registro siguiente al que se está parado en el dataset
ItsDSPrior(aDataSet: TDataSet);
Devuelve el registro anterior al que se está parado en el dataset
ItsDSLast(aDataSet: TDataSet);
Devuelve el último registro del dataset
ItsDSEof(aDataSet: TDataSet): boolean;

Devuelve True o False dependiendo si es o no el final del dataset
ItsDSRecordCount(aDataSet: TDataSet): integer;

Devuelve la cantidad de registros del dataset
ItsDSClose(aDataSet: TDataSet);
Cierra y libera un dataset
ItsDSLocate(aDataSet: TDataSet; KeyFields: string;

KeyValues: Variant): Boolean;
Hace un DataSet.Locate, o un intDSLocate, según el tipo de dataset
ItsCopyRecord(SourceDataset, DestDataset: TDataSet; CopyEmptyValues: boolean = true);

Copia de un registro a otro todos los campos, y sus detalles
ItsCopyRecords(SourceDataset, DestDataset : TDataSet);

Copia la información de un dataset a otro, llamando por cada registro a
CopyRecord.
ItsDuplicateRecord(SourceDataset, DestDataset);
Duplica el registro activo del dataset.
ItsMAPISendMail(const RecepientEMail: string;

const Subject: string; const Body: string; AttachFileName: string;
const AutoSend: boolean): Boolean;
Permite enviar un email.Se debe tener una cuenta de Outlook configurada en la pc.
ItsSendMail( const RecepientEMail: string; const Subject: string;

const Body: string; AttachFileName: string): boolean;
Permite enviar un mail. Se deben tener configurados los datos de la cuenta en la
configuración del servidor de integra (se hace con la consola, Servidor - Configurar Servidor y
completar los parámetros de CORREO)
ItsLeftPadCh(S: String; C: Char; Cant: Integer): String;

Rellena con caracteres a la izquierda
ItsCronoStart
Inicializa un cronómetro (lo agrega a la pila)
ItsCronoEnd: TDateTime
Devuelve el tiempo transcurrido desde el último tiempo CronoStart (saca el ultimo de la pila)
ItsCronoEndFmt: string;
Idéntico a ItsCronoEnd, pero formateado a string con formato Xh Xm Xs Xms
ItsStrToInt(Value: string): integer;

Convierte un string a un entero. Si está vacío, devuelve 0.
ItsStrToFloat(Value: string): extended;

Convierte un string a un float. Si está vacío, devuelve 0.
ItsExtract(Can: Integer; var S1, S2: String): String;

Le extrae a S1 la cantidad de caracteres Can de S2, devolviendo lo que se quitó y afectando
a las 2 variables dado que están pasadas como referencia.
ItsCut(var S: string; Index, Count: Integer): string;

Igual al copy de pascal, pero corta en lugar de copiar
ItsStringReplace(const S, OldPattern, NewPattern: string): string;

Devuelve un string con las repeticiones de un substring reemplazado por otro substring
ItsFStr(N: Extended; Size, Precision: Integer): String;

Formatea un flotante a string
ItsPad(S: String; Size: Integer): String;

Rellena de caracteres a la derecha
ItsGetDay(aDate: TDateTime = -1): integer;

Devuelve el día de la fecha pasada por parámetro. Si está vacía, utiliza la actual
ItsGetMonth(aDate: TDateTime = -1): integer;

Devuelve el mes de la fecha pasada por parámetro. Si esta vacía, utiliza la actual
ItsGetYear(aDate: TDateTime = -1): integer;

Devuelve el año de la fecha pasada por parámetro. Si está vacía, utiliza la actual
ItsLastDay(aDate: TDateTime = -1): integer;

Devuelve el último día de un mes. Si está vacía, utiliza la actual
ItsIncDateTime(aDateTime: TDateTime; YearsNo, MonthsNo, DaysNo,

HoursNo, MinutesNo, SecondsNo: integer): TDateTime;
Incrementa o decrementa una fecha y hora en un determinado numero de años, meses,
Días, horas, minutos o segundos. Los valores son enteros absolutos, y NO necesitan
responder a las fracciones de cada unidad de tiempo (ej: las horas no tienen que
ser menores a 24, ni los minutos a 60)
ItsStrToDateTime(Value: string): TDateTime;

Convierte un string a un DateTime. Si está vacío, devuelve 0.
ItsIIf(Condicion: boolean; ResThen, ResElse: variant): variant;

Devuelve ResThen o ResElse, según Condición
ItsVarAsString(Value: Variant): string;

Devuelve un Variant como un String
ItsVarAsBool(Value: Variant): integer;

Devuelve un Variant como un Boolean
ItsVarAsInteger(Value: Variant): integer;
Devuelve un Variant como un Integer
ItsVarAsFloat(Value: Variant): double;

Devuelve un Variant como un Float
ItsVarAsDateTime(Value: Variant): TDateTime;

Devuelve un Variant como un DateTime
ItsVarArrayAsString(Value: Variant; Separator: Char): string;

Recibe un vector de Variant y devuelve un string de los elementos del vector separados por
Separator.
ItsVarEmpty(Value: variant): boolean;

Devuelve un boolean indicando si la variable está vacía o es nula.
ItsRound(N: Extended; D: Byte): Extended;

Redondea un numero a una cantidad de decimales determinada
ItsAbs(Value: Extended): Extended;

Devuelve el valor absolute de Value
ItsDeleteFile(FileName: string): boolean;

Borra el archivo pasado por parámetro
ItsSaveFile(FileName: string; S: string);

Agrega una línea en el archivo pasado por parámetro
ItsCompleteFileName(const Value: string; DefExtension: string): string;

Completa el nombre de un archivo.
Si la ruta esta vacía, asume la de la aplicación.
Si el nombre esta vacío, asume el nombre del ejecutable.
Si no tiene extensión, asume la pasada por parámetro
ItsRollBack(const aMessage: string);

Crea una excepción, indicando código de cancelación
ItsInfo(MessageText: String);
Muestra un mensaje de información
ItsErr(MessageText: String);
Muestra un mensaje de error
ItsConfirm(MessageText: String; Default: boolean): boolean;

Muestra un mensaje de confirmación
ItsInputQuery(const ACaption, APrompt: string; var Value: string): Boolean;
Muestra un mensaje para ingresar un texto
ItsExecuteFile(const FileName: string; const Params: string = '';

Maximized: boolean = false): boolean;
Abre un archivo con lo que este asociado de windows. Si es un ejecutable, lo
ejecuta con los parámetros pasados
ItsExecuteFileWait(const FileName: string; const Params: string = ''): boolean;

Ejecuta un archivo y espera el resultado
ItsSetUserInteraction(aValue: boolean)
Le asigna a la variable UserInteraction el valor aValue
ItsCNCreateExcel(aFileName: string): TcustomConnection

Crea una conexión Excel.
ItsDSOpenExcel(aConnection: TCustomConnection; SheetName: string): TADODataSet;

Devuelve la tabla correspondiente al SheetName de la planilla excel.
ItsCNGetTableNames(aConnection: TCustomConnection): string;

Devuelve el nombre de las tablas de la conexión separados por pipelines
ItsArqCopyFields(CNDest: TCustomConnection; ClassName: string;

dsSource, dsDest: TDataSet; FieldsSource, FieldsDest: string; LogFile: string): boolean;
Copia los campos que están en destino desde el origen y normaliza los nulos
ItsArqValidateRecord(CNDest: TCustomConnection; ClassName: string;

dsDest: TDataSet; LogFile: string; aRecNoSource: integer = 0) : Boolean;
Cliente asincronico
Parametrización
El tiempo está en segundos.
Se ejecuta uno por vez, aunque por tiempo se superponga con el próximo.
Tipo de script
Ejemplos:
Ejemplo “Envio de mail con mapi”

Envia un mail usando las funciones mapi del cliente, con dos archivos adjuntos,
previsualizando sin envio automatico:
ItsMapiSendMail(‘xxx@hotmail.com’, ‘Sujeto’, ‘Cuerpo del mail’, ‘C:\FACTURA1.PDF

C:\FACTURA2.PDF’, False);
Ejemplo “Envio de mail con smtp”

Envia un mail por el SMTP configurado en el servidor, con dos archivos adjuntos:
ItsSendMail(‘xxx@hotmail.com’, ‘Sujeto’, ‘Cuerpo del mail’, ‘C:\FACTURA1.PDF

C:\FACTURA2.PDF’);
Ejemplo “Impresión automática”

Imprime el reporte de una factura sin previsualizar a la impresora por defecto:
ItsClassPrintReport(‘ERP_IMP_COM_VEN’, ‘ID_REPORTE’, ‘ID’, ‘FACA000000000001’,

False, False)
Ejemplo “Generación automática de reportes a distintos formatos”

Genera el reporte de la factura a PDF y lo deja en un archivo:
Archivo := ItsClassSendReportToFile(‘ERP_IMP_COM_VEN’, ‘ID_REPORTE’, ‘ID’,

‘FACA000000000001’, itrpPdf, Titulo)
Ejemplo “Generación automática de cubos a archivo”

Genera el IVA ventas de un periodo a un cubo con el nombre PRUEBA.CUB:
begin
frmIvaVen:= ItsFrmCreate('ERP_IVA_VEN', TRUE);
ItsFrmAddFilter(frmIvaVen, 'PERIODO', okEqual, '2006/10' );
ItsFrmOpen(frmIvaVen);
Archivo := ItsCreateFileCube(frmIvaVen, 'C:\Prueba');
frmIvaVen .Free;
end;
Ejemplo “Ingreso de información en forma programática”

Graba un comprobante de ventas con su detalle:
begin
frmComVen := ItsFrmCreate('ERP_COM_VEN_FAC', False);
ItsFrmOpen(frmComVen);
dsComVen := ItsFrmGetDataSet(frmComVen);
dsDetCom := ItsDsGetDetail(dsComVen, 'ERP_DET_COM');
ItsFrmAppend(frmComVen);
{Asignaciones del maestro}
ItsDsAppend(dsDetCom);
{Asignaciones de cada detalle}
ItsDsPost(dsDetCom);
ItsFrmAccept(frmComVen);
frmComVen.Free;
end;
Ejemplo “Atrapar excepciones”

Atrapar la division por cero y asignar cero:
begin
try
A := 1 / 0;
except
A := 0;
end;
end;
Ejemplo “Grabar archivo”

Generar un log de actividad:
begin
ItsSaveFile(‘C:\AUDITORIA.LOG’, DateToStr(Now) + ‘ Usuario: ‘+ActUserName);
end;
Ejemplo “Abrir archivo XML”

Abrir un archivo XML utilizando un objeto ADO.
oRec := CreateOleobject('ADODB.Recordset');
oRec.Open ('C:\Desa\Tools\ItsUpdateErp\ERP_VERSION.XML');
while not oRec.Eof do begin
S := oRec.Fields('VERSION').Value;
WriteLn(S);
oRec.MoveNext;
end;
oRec.Close;
Ejemplo “Abrir una conexion Excel”
cnOrigen := ItsCNCreateExcel(‘Archivo.xls’);
try
cnOrigen.open;
except
ItsRollBack('Error al crear la conexión');
end;
Cuando se crea una conexión se debe verificar si ésta se puede abrir o no, eso se lo hace
como se muestra en el ejemplo manejando una excepción si la abertura fue errónea y
realizando RollBack.

Manual Itris Desarrollador Parte III

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manual Itris Desarrollador Parte III

Transféré par

Droits d'auteur :

Formats disponibles

Inteligencia Aplicada

martes, 24 de junio de yyyy

Oracle es una marca registrada de Oracle Corporation.

ITRIS e INTEGRA son marcas en tramite de Compañía General de Software.

2002 Compañía General de Software S.R.L. Todos los derechos reservados.

La documentación se encuentra dividida en las siguientes secciones.

Por eso, si se desea un detalle particular acerca de un proceso en particular, la

El PasScript es un subconjunto del lenguaje Pascal orientado a objetos. Es muy similar al

# $ y ' () * +, -./:; < = > @ [ ] ^ {}

Los siguientes pares de caracteres también son símbolos especiales.

(* (.*).)../ /:= < = > = < >

El corchete izquierdo [ es equivalente al par del caracteres paréntesis izquierdo y punto (.

and array as asm begin

Además de las palabras mencionadas arriba, PRIVATE, PROTECTED , PUBLIC,

Los comentarios son ignorados por el compilador.

Existen varias maneras de construir comentarios:

{ Un texto entre llaves constituye un comentario.}

Una expresión es una construcción que devuelve un valor. Por ejemplo,

Los nombres de variables, constantes, tipos, campos, propiedades, procedimientos,

var Size: Extended;

function DoThis(X, Y: string): Integer;

La sintaxis y ubicación de una declaración dependen de la clase de identificador que se está

Una declaración de asignación tiene la forma

donde la variable es cualquier variable de referencia -- incluyendo un variable o componente

asigna el valor 3 a la variable I. La variable de referencia en el lado izquierdo de la asignación

incrementa el valor de I. Otras declaraciones de asignación incluyen

Procedimiento y llamadas a funciones

Una llamada a un procedimiento consiste en el nombre de un procedimiento (con o sin los

Hay dos formas de sentencias if: if...then y if...then...else. La sintaxis de la sentencia

donde expression devuelve un valor Boolean. Si expression es verdadero, luego se ejecuta

if J <> 0 then Result := I/J;

La sintaxis de la sentencia if...then...else es

if expression then statement1 else statement2

donde expression devuelve un valor Boolean. Si expression es verdadero, luego se ejecuta

Un dificultad especial se presenta en la conexión con sentencias if anidadas. El problema se

if expression1 then if expression2 then statement1 else statement2;

There would appear to be two ways to parse this:

if expression1 then [ if expression2 then statement1 else statement2];

El compilador analiza siempre de la primera forma. Es decir, en código verdadero, la

if ... { expression1 } then

if ... { expression1 } then

if ... { expression1 } then

La sentencia case puede proporcionar un alternativa legible para condicionales if anidados.

• Un numeral, la constante declarada, u otra expresión que el compilador pueda evaluar

6..9: Caption := 'High';

es equivalente al condicional anidado

Otros ejemplos de sentencias case:

repeat statement1; ...; statementn; until expression

Ejemplos de sentencias repeat

La sintaxis de una sentencia while es

while expression do statement

Ejemplos de sentencias while

while Data[I] <> X do I := I + 1;

for counter := initialValue to finalValue do statement

for counter := initialValue downto finalValue do statement

Ejemplos de sentencias for:

La sección declarations puede incluir, en cualquier orden, las declaraciones de variables,

Por ejemplo, en una declaración de función como

function UpperCase(const S: string): string;

Las reglas que determinan alcance de un identificador se resumen abajo.

Si el identificador es declarado en ... su el alcance extiende...

es decir, en la unit donde ocurre la referencia, o, si esa unit no declara el identificador, en la

Existen varias formas de categorizar los tipos de datos de Delphi: