Manual de referencia de PascalScript

Éste es el manual de referencia de PascalScript, el lenguaje utilizado en el generador de informes y en el proceso de importación de datos.

Sintaxis de PascalScript

Program -> [PROGRAM Ident ';']
[UsesClause]
Block '.'

UsesClause -> USES (String/,)... ';'

Block -> [DeclSection]...
CompoundStmt

DeclSection -> ConstSection
-> VarSection
-> ProcedureDeclSection

ConstSection -> CONST (ConstantDecl)...

ConstantDecl -> Ident '=' Expression ';'

VarSection -> VAR (VarList ';')...

VarList -> Ident/','... ':' TypeIdent
[InitValue]

TypeIdent -> Ident
-> Array

Array -> ARRAY '[' ArrayDim/','... ']' OF
Ident

ArrayDim -> Expression..Expression
-> Expression

InitValue -> '=' Expression

Expression -> SimpleExpression [RelOp SimpleExpression]...

SimpleExpression -> ['-'] Term [AddOp Term]...

Term -> Factor [MulOp Factor]...

Factor -> Designator
-> UnsignedNumber
-> String
-> '(' Expression ')'
-> NOT Factor
-> '[' SetConstructor ']'

SetConstructor -> SetNode/','...

SetNode -> Expression ['..' Expression]

RelOp -> '>'
-> '<'
-> '<='
-> '>='
-> '<>'
-> '='
-> IN
-> IS

AddOp -> '+'
-> '-'
-> OR
-> XOR

MulOp -> '*'
-> '/'
-> DIV
-> MOD
-> AND
-> SHL
-> SHR

Designator -> ['@'] Ident ['.' Ident | '[' ExprList ']' | '(' ExprList ')']...

ExprList -> Expression/','...

Statement -> [SimpleStatement | StructStmt]

StmtList -> Statement/';'...

SimpleStatement -> Designator
-> Designator ':=' Expression
-> BREAK | CONTINUE | EXIT

StructStmt -> CompoundStmt
-> ConditionalStmt
-> LoopStmt
-> TryStmt
-> WithStmt

CompoundStmt -> BEGIN StmtList END

ConditionalStmt -> IfStmt
-> CaseStmt

IfStmt -> IF Expression THEN Statement [ELSE Statement]

CaseStmt -> CASE Expression OF CaseSelector/';'... [ELSE Statement][';'] END

CaseSelector -> SetConstructor ':' Statement

LoopStmt -> RepeatStmt
-> WhileStmt
-> ForStmt

RepeatStmt -> REPEAT StmtList UNTIL Expression

WhileStmt -> WHILE Expression DO Statement

ForStmt -> FOR Ident ':=' Expression ToDownto Expression DO Statement

ToDownto -> (TO | DOWNTO)

TryStmt -> TRY StmtList (FINALLY | EXCEPT) StmtList END

WithStmt -> WITH (Designator/,..) DO Statement

ProcedureDeclSection -> ProcedureDecl
-> FunctionDecl

ProcedureDecl -> ProcedureHeading ';' Block ';'

ProcedureHeading -> PROCEDURE Ident [FormalParameters]

FunctionDecl -> FunctionHeading ';' Block ';'

FunctionHeading -> FUNCTION Ident [FormalParameters] ':' Ident

FormalParameters -> '(' FormalParam/';'... ')'

FormalParm -> [VAR | CONST] VarList

Estructura del Script

La estructura es la misma que la del lenguaje Object Pascal :

#language PascalScript // esto es opcional
program MyProgram; // esto es opcional

uses 'unit1.pas', 'unit2.pas';

// la sección uses – debe estar antes de
cualquier otra sección

var // sección var
i, j: Integer;

const // sección const
pi = 3.14159;

procedure p1; // procedimientos y funciones
var
i: Integer;

procedure p2; // procedimiento anidado
begin
end;

begin
end;

begin // procedimiento principal que será ejecutado.
end.

Tipos de datos

Internamente siempre se opera con el tipo Variant. Sin embargo se pueden utilizar los siguientes tipos predeterminados en los scripts:

Byte | Igual que el tipo Integer 
Word |
Integer |
Longint |
Cardinal |
TColor |
Boolean
Real | Igual que Extended
Single |
Double |
Extended |
TDate |
TTime |
TDateTime |
Char |
String |
Variant |
Pointer |
Array |

No todos los tipos son compatibles en asignación. Como en Object Pascal no se puede asignar Extended a String o a un Integer. Solo un tipo -Variant- puede ser asignado a todos los demás tipos y puede obtener el valor de cualquier otro tipo.

Clases

No se puede definir una clase dentro del Script, pero se pueden utilizar clases externas predefinidas. Por ejemplo :

var
f: TForm;
b: TButton;

procedure ButtonClick(Sender: TButton);
begin
ShowMessage(Sender.Name);
f.ModalResult := mrOk;
end;

// no es necesario utilizar todos los parámetros en los manejadores de eventos
// porque aquí no se realiza la comprobación de tipos

procedure ButtonMouseMove(Sender: TButton);
begin
b.Caption := 'sacado';
end;

begin
f := TForm.Create(nil);
f.Caption := 'Test it!';
f.BorderStyle := bsDialog;
f.Position := poScreenCenter;
b := TButton.Create(f);
b.Name := 'Button1';
b.Parent := f;
b.SetBounds(10, 10, 75, 25);
b.Caption := 'Test';
b.OnClick := @ButtonClick; { o lo que es lo mismo b.OnClick := 'ButtonClick' }
b.OnMouseMove := @ButtonMouseMove;
f.ShowModal;
f.Free;
end.

Se puede acceder a cualquier propiedad (simple, indexada o por defecto) o método. Todas las propiedades publicadas (published) de los objetos son accesibles desde el Script por defecto. Las propiedades y métodos públicos (public) necesitan el código de implementación -por ese motivo solo se puede acceder a ellos parcialmente (por ejemplo no se puede acceder a los métodos TForm.Print o TForm.Canvas porque no están implementados). También se pueden crear clases nuevas.

Funciones

Estas son las funciones predefinidas que pueden usarse en el Script :

function IntToStr(i: Integer): String
function FloatToStr(e: Extended): String
function DateToStr(e: Extended): String
function TimeToStr(e: Extended): String
function DateTimeToStr(e: Extended): String
function VarToStr(v: Variant): String
function StrToInt(s: String): Integer
function StrToFloat(s: String): Extended
function StrToDate(s: String): Extended
function StrToTime(s: String): Extended
function StrToDateTime(s: String): Extended
function Format(Fmt: String; Args: array):String
function FormatFloat(Fmt: String; Value: Extended): String
function FormatDateTime(Fmt: String; DateTime: TDateTime): String
function FormatMaskText(EditMask: string; Value: string): string
function EncodeDate(Year, Month, Day: Word): TDateTime
procedure DecodeDate(Date: TDateTime; var Year, Month, Day: Word)
function EncodeTime(Hour, Min, Sec, MSec: Word): TDateTime
procedure DecodeTime(Time: TDateTime; var Hour, Min, Sec, MSec: Word)
function Date: TDateTime
function Time: TDateTime
function Now: TDateTime
function DayOfWeek(aDate: DateTime): Integer
function IsLeapYear(Year: Word): Boolean
function DaysInMonth(nYear, nMonth: Integer): Integer
function Length(s: String): Integer
function Copy(s: String; from, count: Integer): String
function Pos(substr, s: String): Integer
procedure Delete(var s: String; from, count: Integer): String
procedure Insert(s: String; var s2: String; pos: Integer): String
function Uppercase(s: String): String
function Lowercase(s: String): String
function Trim(s: String): String
function NameCase(s: String): String
function CompareText(s, s1: String): Integer
function Chr(i: Integer): Char
function Ord(ch: Char): Integer
procedure SetLength(var S: String; L: Integer)
function Round(e: Extended): Integer
function Trunc(e: Extended): Integer
function Int(e: Extended): Integer
function Frac(X: Extended): Extended
function Sqrt(e: Extended): Extended
function Abs(e: Extended): Extended
function Sin(e: Extended): Extended
function Cos(e: Extended): Extended
function ArcTan(X: Extended): Extended
function Tan(X: Extended): Extended
function Exp(X: Extended): Extended
function Ln(X: Extended): Extended
function Pi: Extended
procedure Inc(var i: Integer; incr: Integer = 1)
procedure Dec(var i: Integer; decr: Integer = 1)
procedure RaiseException(Param: String)
procedure ShowMessage(Msg: Variant)
procedure Randomize
function Random: Extended
function ValidInt(cInt: String): Boolean
function ValidFloat(cFlt: String): Boolean
function ValidDate(cDate: String): Boolean
function CreateOleObject(ClassName: String): Variant
function VarArrayCreate(Bounds: Array; Typ: Integer): Variant

Algunas funciones tienen parámetros por defecto. Se utilizan del mismo modo que en Delphi :

Inc(a);
Inc(b, 2);

Eventos

Se pueden usar eventos. El siguiente ejemplo muestra como conectar un manejador de eventos al evento TButton.OnClick :

var
b: TButton;
Form1: Tform;

procedure ButtonClick(Sender: TButton);
begin
ShowMessage(Sender.Name);
end;

begin
b := TButton.Create(Form1);
b.Parent := Form1;
b.OnClick := @ButtonClick; // lo mismo que b.OnClick := 'ButtonClick'
b.OnClick := nil; // limpia el evento
end.

Hay algunos eventos predefinidos disponibles en la unidad FS_iEvents:

TfsNotifyEvent
TfsMouseEvent
TfsMouseMoveEvent
TfsKeyEvent
TfsKeyPressEvent
TfsCloseEvent
TfsCloseQueryEvent
TfsCanResizeEvent

Conjuntos y enumeraciones

Las enumeraciones están soportadas. Se puede escribir en el Script :

Form1.BorderStyle := bsDialog;

Los conjuntos no están soportados, sin embargo se pueden utilizar constantes de la siguiente forma :

Font.Style := fsBold; // Font.Style :=  [fsBold] en Delphi
Font.Style := fsBold + fsItalic; // Font.Style := [fsBold, fsItalic]
Font.Style := 0; // Font.Style := []

Arrays

Se soportan todos los tipos de array : estático (mono o multi-dimensional), dinámico y arrays de Variant. Éste es un ejemplo de uso de todos los tipos :

var
ar1: array[0..2] of Integer;
ar2: array of Integer;
ar3: Variant;
SetLength(ar2, 3);
ar3 := VarArrayCreate([0, 2], varInteger);
ar1[0] := 1;
ar2[0] := 1;
ar3[0] := 1;

Imprimir

logowinstation 80 16 © 1998-2017 Winstation, S.L.