Lenguaje Delphi

De Wikilibros, la coleccin de libros de texto de contenido libre.

Contenido
1 Lenguaje Delphi
1.1 Historia
1.2 Breve tutorial de instalacin y uso de herramientas de Compilacin
1.3 Programa Hola Mundo
1.4 Diccionario de palabras reservadas, operadores y smbolos del lenguaje
1.5 Smbolos especiales
1.6 Comentarios y directrices de compilacin
1.7 Tipos de datos fundamentales y su representacin
1.8 Operaciones de entrada y salida bsica
1.9 Tipos de datos complejos y su representacin
1.10 Declaracin e inicializacin de variables
1.11 Tabla de Operadores con asociatividad y precedencia
1.12 Estructuras de decisin e iteracin
1.13 Declaracin, definicin y uso de mtodos y funciones
1.14 Implementacin y uso de la Programacin Orientada a Objetos
1.15 Esquema de administracin y separacin de la memoria
1.16 Implementacin de Corrutinas
1.17 Manejo de Excepciones
1.18 Gramtica en EBNF del lenguaje
1.19 Caractersticas especficas del Lenguaje
1.20 Fuentes Bibliogrficas

Lenguaje Delphi
Delphi es un entorno de desarrollo de software diseado para la programacin de propsito general con
nfasis en la programacin visual. En Delphi se utiliza como lenguaje de programacin una versin
moderna de Pascal llamada Object Pascal.

Historia
Es producido comercialmente por la empresa estadounidense Aberform, adquirida en Mayo de 2008 por
Embarcadero Technologies, una empresa del grupo Thoma Cressey Bravo, en una suma que ronda los
30 millones de dlares. En sus diferentes variantes, permite producir archivos ejecutables para
Windows, Linux y la plataforma .NET.

CodeGear ha sido escindida de la empresa Borland, donde Delphi se cre originalmente, tras un proceso
que pretenda en principio la venta del departamento de herramientas para desarrollo.

Un uso habitual de Delphi (aunque no el nico) es el desarrollo de aplicaciones visuales y de bases de

datos cliente-servidor y multicapas. Debido a que es una herramienta de propsito mltiple, se usa
tambin para proyectos de casi cualquier tipo, incluyendo aplicaciones de consola, aplicaciones de web,
servicios COM y DCOM, y servicios del sistema operativo.

Delphi inicialmente slo produca ejecutables binarios para Windows: Delphi 1 para Win16 y con
Delphi 2 se introdujo Win32. En el ao 2013 lanzaron la version XE5 la cual permite crear ejecutables
binarios para Windows 32 y 64 bits, Mac OSX, IOS para IPhone y IPad y celulares inteligentes o
tabletas Android.

Breve tutorial de instalacin y uso de herramientas de Compilacin

Las herramientas usadas para la Compilacin de Delphi segn el sistema operativo son:
Para Windows:
Borland Delphi 7, RAD Studio 2007
Para Linux y Unix:
Kylix 3.0.
Pero en esta documentacin nos centraremos en la instalacin y uso de las herramientas del Borland
Delphi 7. Algo que diferencia a Delphi de muchos otros competidores es el hecho de tratarse de un
compilador altamente optimizado, que genera cdigo directamente ejecutable, no pseudo cdigo que
debe ser interpretado posteriormente en tiempo de ejecucin. Esto tiene bsicamente dos consecuencias:
el ejecutable es ms rpido, al no tener que ser interpretado en tiempo de ejecucin y el tamao total
final de la aplicacin suele ser inferior; ya que no es necesaria la distribucin adicional del programa que
interpreta y ejecuta el cdigo al que se suele denominar Runtime.

Programa Hola Mundo

Ahora como todo tutorial iniciaremos con una pequea aplicacin de una ventana con un botn que
desplegar un mensaje con el rtulo de Hola mundo. Para eso, nos vamos al primer men de la parte
superior y damos clic a la opcin file, acto seguido damos clic a new y luego a application.

Se genera un proyecto con un formulario vaco, es ah donde comienza la tarea de comenzar a arrastrar
los dems elementos visuales al formulario vaco como: etiquetas, cajas de textos, lista de textos,
memos, botones, etc. En el programa slo necesitaremos arrastrar un botn. Cada elemento tiene su
Object Inspector, es una herramienta que nos permite modificar los atributos de los objetos como el de la
figura al lado izquierdo de nuestro programa. Nos vamos al atributo caption y modificamos escribiendo
el rtulo que deseamos para el botn. Ahora para poder comenzar a programar lo que debe hacer el
botn, recuerde que se programa por eventos as que seleccionamos el botn, luego nos vamos a su
Object Inspector y le damos a la pestaa Events y elegimos el evento onClick y en el espacio en
blanco le damos doble clic. Se nos desplegar una ventana de editor de texto con el siguiente cdigo.

procedure TForm1.Button1Click(Sender: TObject);

begin

end;
end.

Ahora el espacio entre begin y end; es ah por donde se inicia a programar lo que deseamos que el
botn haga en el evento onClick; que, bsicamente es el evento cuando el botn le den clic. Ahora le
ponemos la siguiente instruccin.

procedure TForm1.Button1Click(Sender: TObject);

begin
showMessage('Hola Mundo');
end;
end.

Ahora unas aspectos a tomar en cuenta: cada instruccin termina con un punto y coma, cuando se desea
imprimir o mostrar un mensaje debe hacerlo entre comillas simples (), y para ejecutarlo hay varias
maneras, puede de un slo con darle clic a F9, se ejecutar siempre y cuando no halle ningn error, y si
lo hubiera en la parte inferior del editor de cdigo aparece la lista de errores. La otra forma es ir al
primer men y buscar Run y luego darle clic en el men que se desplega Run. La instruccin
showMessage(); desplega un mensaje con el argumento que reciba puede ser un mensaje string o del
tipo Pchar(Combinacion de nmeros y letras). Ejecucin del programa.

Diccionario de palabras reservadas, operadores y smbolos del lenguaje

Esto es una lista de palabras reservadas y estas no pueden redefinirse o ser usadas como identificadores:

and array as asm begin Case

class structor 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
thread varto try type unit Until
uses var while with Xor
En adicin a las palabras de arriba, private, protected, public, published, y automated actan como
palabras reservadas dentro las declaraciones de tipos de objetos, pero en otra forma son tratadas como
directrices. Tambin las palabras at y on tienen significados especiales.

Smbolos especiales

Los smbolos especiales son caracteres no alfabticos, o pares de estos caracteres, que tienen
significados fijos. Los siguientes caracteres son smbolos especiales:

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

Los siguientes pares de caracteres tambin son smbolos:

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

Se puede ver claramente que !, , %, \,?,_, |, y ~ no son caracteres especiales.

Comentarios y directrices de compilacin

Los comentarios son ignorados por el compilador, excepto cuando su funcin es de separadores
delimitando tokens adyacentes o directrices de compilacin. Existen muchas directrices de compilacin:

{ El texto entre llaves constituye un comentario. }

(* El texto entre parntesis mas asteriscos constituye un comentario. *)
// Todo texto despus de un doble slash constituye un comentario al final de la lnea.

Un comentario que contenga un signo de $ es una directriz de compilacin. Por ejemplo,

{$WARNINGS OFF}

indica al compilador que no genere avisos.

Tipos de datos fundamentales y su representacin

Integer

Nmeros enteros comprendidos entre 32768 y 32767; 16 bits (ocupan 2 bytes cada uno en la memoria)

Byte

Nmeros enteros positivos comprendidos entre 0 y 255; 8 bits (ocupa 1 byte cada uno en la memoria)

Word

Nmeros positivos comprendidos entre 0 y 65535; 16 bits (ocupan 2 bytes cada uno en la memoria)
 LongInt

Nmeros enteros comprendidos entre 2147483647 y 2147483647 32 bits (ocupan 4 bytes cada uno en
la memoria)

ShortInt

Nmeros negativos y positivos enteros comprendidos entre 128 y 127; 8 bits (ocupa 1 byte cada uno en
la memoria)

Real

Nmeros de coma flotante de 11 a 12 decimales significativos (delante y detrs de la coma); ocupan 6

bytes cada uno en la memoria

Single

Nmeros de coma flotante de 7 a 8 decimales significativos; solo es posible si est activada la opcin de
compilador {$N+}; ocupan 4 bytes cada uno en la memoria

Double

Nmeros de coma flotante de 15 a 16 cifras delante y detrs de la coma; solo es posible si est activada
la opcin de compilador {$N+}; ocupan 8 bytes cada uno en la memoria

String

Secuencia de smbolos con una longitud mxima de 255 caracteres ASCII.

Char

Caracteres ASCII simples

Pchar

Puntero a una cadena terminada en carcter nulo

Pointer

Punteros que pueden apuntar a cualquier estructura de datos; sin enlace con un tipo concreto
(denominados punteros sin tipo)

Boolean

Tipo de Datos Booleano, cuyas variables pueden tomar los valores True (verdadero) o False (falso)

Operaciones de entrada y salida bsica

Las operaciones de entrada y salida en Delphi son variadas dependiendo de la aplicacin que se est
programando. Si es una aplicacin de consola, los comandos de entrada y salida son los siguientes:

Read();

El argumento es un identificador de las variables previamente declaradas.

Write(Mensaje,)

Este comando nos imprime una salida y puede recibir muchos argumentos, entre ellos mensajes String y
si queremos imprimir un nmero que est almacenado en una variable simplemente se pone el nombre
de la variable como parmetro.

Si es una aplicacin con formularios y ventanas, eso depende de cuales sean los elementos de entrada y
cuales los de salida, a continuacin una breve descripcin de objetos (Ms comunes) y sus mtodos de
entrada y salida.

Pero hay que aclarar que los mtodos de entrada y salidas de Label y
Elemento Entrada Salida Edit(Caja de Texto) reciben o envan String o cadena de caracteres
.Caption := as que para problemas que requieran de entradas numricas o
salidas numricas se usan los siguientes mtodos de conversin.
Label .Caption

Mtodo Convierte de Convierte a

IntToStr(variable:Integer) Integer String
StrToInt(variable:String) String Integer
FloatToStr(variable:Float) Real String
StrToFloat(Variable:String) String Real

Tipos de datos complejos y su representacin

En Delphi existen los datos complejos entre los cuales tenemos los registros y los arreglos tipo tabla y
los arreglos tipo vector.

Arreglos tipo Vector.

Para declarar un arreglo del tipo Vector o lista se usa el siguiente formato.
< nombre del Arreglo>: array [1..n] of <Tipo del Arreglo>;
Ejemplos:
Edades: array [1..10] of Integer;
Nombres: array [1..30] of String;
Nombres: array [1 30] of String[20];
Esta declaracin se hace en la parte var del programa principal, en el caso de una aplicacin de
formulario en el var del programa del TForm.form1, porque un arreglo son elementos que se
comparten entre todos los eventos de los objetos

Arreglos tipo Tabla (bidimensionales).

El formato para declarar un arreglo bidimensional no vara mucho con el unidimensional.

< Nombre del Arreglo>: array[1..n, 1..m] of <Tipo>;
Y aplica la misma normativa, es mejor declararlos en el var del TForm.form1. Indicando que es una
variable global.

Declaracin e inicializacin de variables

Para la declaracin de variables nos valemos de las siguientes sintaxis:

var
< Nombre de variable> : <Tipo de variable>
< Nombre de variable 1>, <Nombre de variable 2>, <Nombre de variable n> : <Tipo de variable>

Para inicializar las variables recin creadas:

<Nombre de Variable> := <Valor>

Tabla de Operadores con asociatividad y precedencia

Operadores Asociatividad Orden de

Operadores
Precedencia
+ Por la Izquierda
1 Las operaciones entre parntesis
- Por la Izquierda
2 Races o Potencias
* Por la Izquierda
3 Multiplicaciones o Divisiones
/ Por la Izquierda
4 Sumas o Restas
div Por la Izquierda
Si hay 2 o ms operadores del mismo Orden
mod Por la Izquierda 5 entonces se usa la asociatividad por la izquierda

Estructuras de decisin e iteracin

Antes de iniciar con las estructuras de decisin e iteracin, se debe conocer los operadores de las
condiciones que son la base de las dos siguientes estructuras a ver.

Hay que tener claro que la diferencia entre = y := es, que el primero compara dos variables y el
segundo es una asignacin de valores.
 A continuacin se presenta una tabla con los operadores para cuando
Operador Significado hay ms de una condicin a evaluar.
> Mayor que
< Menor que Operador Significado
>= Mayor o Igual que AND y lgico
<= Menor o Igual que OR o lgico
= Igual NOT negacin
<> Distinto de

Decisin
Uso del If

If Condicin(es) then
Begin
Bloque de Instrucciones;
End
Else
Begin
Bloque de Instrucciones;
End

Uso del Case

Case <Variable> of
Constante1: Begin
Instrucciones;
End;
Constante2: Begin
Instrucciones;
End;
Constante3: Begin
Instrucciones;
End;
Else
Begin
Instrucciones;
End;

<Variable>, generalmente si es un Integer, cada Constante sera 1, 2, 3, hasta donde sea necesario, y
si es un Char, cada constante a evaluar sera a, b, c,etc.

Iteracin
Ciclo For

For <variable> := valor inicial To valor final Do

Begin
Instrucciones;
End

Ciclo While
While (Condicin) Do
Begin
Instrucciones;
*Instruccin de salida del Ciclo;
End

Ciclo Repeat Until

Repeat
Instrucciones;
*Instruccin de salida del Ciclo;
Until (Condicin);

Dependiendo de la condicin, la instruccin puede variar pero esta instruccin es vital para
evitar ciclos infinitos.

Declaracin, definicin y uso de mtodos y funciones

Delphi por supuesto tiene lo que es el uso de funciones y Procedimientos, ahora definiremos por
separado cada uno de estos mdulos.
Procedimientos:
Es un modulo de un programa que realiza tareas especficas y que no puede regresar valores a la parte
principal del programa u otro procedimiento que lo est invocando.

Declaracin y Definicin de los Procedimientos.

Procedure <Nombre del Procedimiento>

Var
{Lista de variables locales}
Begin
{Bloque de instrucciones }
End;

Este esquema de la definicin y declaracin se hace en la seccin de VAR del programa principal.
Uso.
Simplemente en el programa principal se copia el nombre del procedimiento previamente definido en el
lugar donde se le requiera.

Funciones:
Una funcin es un mdulo de un programa separado del cuerpo principal, que realiza una tarea
especfica y que puede regresar un valor a la parte principal del programa u otra funcin o
procedimiento que la invoque.
Declaracin y Definicin de las Funciones.

Function<Nombre de la Funcin> (Parmetros): <Tipo de Dato a retornar>;

Var
{Lista de variables locales}
Begin
 {Bloque de instrucciones }
<Nombre de la Funcin> := Instruccin; Aqu ocurre el famoso return de las funciones
End;

Este esquema de la definicin y declaracin se hace en la seccin de VAR del programa principal.
Uso.
Simplemente en el programa principal se hace el llamado a funcin.

Implementacin y uso de la Programacin Orientada a Objetos

Generalmente la POO se asocia rpidamente con lenguajes como C++, pero Object Pascal, de ah su
nombre, cuenta con todos los componentes bsicos de un lenguaje orientado a objetos con la
encapsulacin, la herencia y el polimorfismo.

Comenzando con el concepto de encapsulacin de datos que trata bsicamente de encerrar un conjunto
de datos dentro de un objeto que slo los mtodos del propio podr manipular. Para eso se hace uso de
la palabra reservada Type.

type
{<Nombre del Objeto> = Object}
Persona = Object
{Atributos}
nombre:String[25];
private apellido:String[25];
{Procedimientos y Funciones}
procedure init(name:String;apell:String);
procedure nombreCompleto;
procedure setApellido(apell:String);
function getNombre:String;

{fin del type}

end;

Ahora slo falta definir las funciones y procedimientos del Object Persona, Observe que un atributo
tiene la palabra reservada de Private, esta palabra hace que el atributo slo pueda ser accesado o
modificado por medio de mtodos del propio Objeto. El primer atributo se asume que es un atributo
pblico; es decir, que puede ser modificado y/o accesado sin necesidad de mtodos. A continuacin se
definen los procedimientos y funciones del objeto.

var
procedure Persona.init;
begin
nombre:=name;
setApellido(apell);
end;

procedure Persona.nombreCompleto;
begin
writeln(Nombre,' ',getApellido);
end;

procedure setApellido;
begin
apellido := apel;
end;
function Persona.getApellido:String;
begin
getApellido:= apellido;
end;

La definicin de las funciones y procedimientos se hace en la seccin var del main y la diferencia
est en que el nombre de la funcin o del procedimiento siempre es precedido por el Nombre del objeto
ms punto.
Ejemplo:
Persona.setApellido
Persona.nombreCompleto

Otro aspecto a destacar es que tanto las funciones como los procedimientos, en el momento de
definirlos no es necesario copiar la lista de parmetros que necesiten y en el caso de las funciones no es
necesario escribe : <tipo que retornan> porque ya estn encapsulados en el type.

Ahora para las herencias sencillamente donde se crea es esqueleto en el Type se hace lo siguiente:

Type
Padre = Object
{esqueleto de la clase Padre};
end;
Hijo = Object (Padre)
{esqueleto de la clase Hijo};
end;
Var
{definiciones de los procedimientos y funciones de Padre};
{definiciones de los procedimientos y funciones de Hijo};

Una recomendacin es que los mtodos comunes entre el padre y el hijo se deben declarar y definir en
el padre, porque esos mtodos se heredan de manera implcita en el hijo, dejando solamente la tarea de
declarar y definir los mtodos nicos del hijo.

Por ltimo falta mencionar la declaracin del polimorfismo, bsicamente es una herencia mltiple de
un padre a varios hijos, ac se usa la palabra reservada virtual. Este hace que los mtodos
(procedimientos y funciones) comunes entre el padre y el hijo puedan sobrescribirse. Bsicamente
permite que si hay un padre que hereda a varios hijos un mtodo en comn pero que cada mtodo segn
el hijo funciona de manera diferente, puedan ser definidos en cada hijo usando siempre el mismo
nombre.

Esquema de administracin y separacin de la memoria

Implementacin de Corrutinas

Manejo de Excepciones

El manejo de excepciones en Delphi no vara mucho de los dems lenguajes de hoy en da y su siguiente
estructura es la siguiente.

TRY
{Bloque de instrucciones}
EXCEPT
ON Exception DO
BEGIN
{Bloque de Instrucciones}
END;
END; Fin del Try

Este bloque captura errores de manera genrica, pero tambin se puede disear bloques de excepciones
con indicaciones ms especficas.

Por ejemplo del Bloque anterior se pueden puede cambiar de la siguiente manera para que slo intente
el Try-Except con errores especficos.

TRY
{Bloque de instrucciones}
EXCEPT
ON TipoException1 DO
BEGIN
{Bloque de Instrucciones}
END;
ON TipoException2 DO
BEGIN
{Bloque de Instrucciones}
END;
ON TipoException3 DO
BEGIN
{Bloque de Instrucciones}
END;

END; Fin del Try

En Tipo de Excepciones tenemos las siguientes:

EAbort: Finaliza la secuencia de eventos sin mostrar el mensaje de error.

EAccessViolation: Comprueba errores de acceso a memoria invlidos.
EBitsError: Previene intentos para acceder a arrays de elementos booleanos.
EComponentError: Nos informa de un intento invlido de registrar o renombrar un componente.
EConvertError: Muestra un error al convertir objetos o cadenas de texto string.
EDatabaseError: Especifica un error de acceso a bases de datos.
EDBEditError: Error al introducir datos incompatibles con una mscara de texto.
EDivByZero: Errores de divisin por cero.
EExternalException: Significa que no reconoce el tipo de excepcin (viene de fuera).
EIntOutError: Representa un error de entrada/salida a archivos.
EIntOverflow: Especifica que se ha provocado un desbordamiento de un tipo de dato.
EInvalidCast: Comprueba un error de conversin de tipos.
EInvalidGraphic: Indica un intento de trabajar con grficos que tienen un formato desconocido.
EInvalidOperation: Ocurre cuando se ha intentado realizar una operacin invlida sobre un
componente.
 EInvalidPointer: Se produce en operaciones con punteros invlidos.
EMenuError: Controla todos los errores relacionados con componentes de men.
EOleCtrlError: Detecta problemas con controles ActiveX.
EOleError: Especifica errores de automatizacin de objetos OLE.
EPrinterError: Errores al imprimir.
EPropertyError: Ocurre cuando se intenta asignar un valor errneo a una propiedad del
omponente.
ERangeError: Indica si se intenta asignar un nmero entero demasiado grande a una propiedad.
ERegistryExcepcion: Controla los errores en el registro.
EZeroDivide: Controla los errores de divisin para valores reales.

Gramtica en EBNF del lenguaje

start= program | unit | library | package .

identifier_list= ID_NAME { ',' ID_NAME } .
unit_qualified_identifier= ID_NAME { '.' ID_NAME } .
type_name= TYPE_NAME | STRING | FILE .
unit_qualified_type_name= type_name [ '.' type_name ] .
function_result_type= type_name .
constant_expression= F .
string_expression= ( STRING_NAME | STRING_LITTERAL )
{ '+' ( STRING_NAME | STRING_LITTERAL ) } .
variable_access= ( ACCESS_NAME | STRING ) { end_access_ } .
end_access_= { array_access_ | record_access_ | '^' | function_parameters_ } .
array_access_= '[' constant_expression { ',' constant_expression } ']' .
record_access_= '.' variable_access .
function_parameters_= '(' [ constant_expression { ',' constant_expression } ] ')' .
set_factor= '[' [ set_element { ',' set_element } ] ']' .
set_element= constant_expression [ '..' constant_expression ] .
constant_expression= simple_expression__ [ ('=' | '<>' | '<' | '<=' | '>' | '>=' | IN )
simple_expression__ ] .
simple_expression__= [ '+' | '-' ] term__ { ('+' | '-' | OR | XOR ) term__ } .
term__= factor__ { ('*' | '/' | DIV | MOD | AND | SHR | SHL ) factor__ } .
factor__= NUMBER | STRING_LITTERAL | NIL
| variable_access
| NOT factor__ | '@' factor__ | set_factor
| '^' NAME
| '(' constant_expression ')'.
typed_constant= simple_expression_ [ ('=' | '<>' | '<' | '<=' | '>' | '>=' | IN )
simple_expression_ ] .
simple_expression_= [ '+' | '-' ] term_ { ('+' | '-' | OR | XOR ) term_ } .
term_= factor_ { ('*' | '/' | DIV | MOD | AND | SHR | SHL ) factor_ } .
factor_= NUMBER | STRING_LITTERAL | NIL
// -- id or field "(f1: v1; f2: v2)"
| variable_access [ ':' typed_constant
{ ';' variable_access ':' typed_constant } ]
| NOT factor_ | '@' factor_
| '^' NAME
| '(' [ typed_constant_] ')'
| set_factor .
// -- array "(1, 2, 3)" or "fn(p1, p2")
typed_constant_= typed_constant { ',' typed_constant } .
formal_parameters= '(' formal_parameter { ';' formal_parameter } ')' .
formal_parameter= [ parameter | var_parameter
| const_parameter | out_parameter | in_parameter ] .
parameter_name_list= PARAMETER_NAME { ',' PARAMETER_NAME } .
array_or_name_type= ARRAY OF ( CONST | unit_qualified_type_name )
| unit_qualified_type_name .
parameter= parameter_name_list ':' array_or_name_type
['=' constant_expression ] .
var_parameter= VAR parameter_name_list [ ':' array_or_name_type ] .
const_parameter= CONST parameter_name_list
[ ':' array_or_name_type ['=' constant_expression ] ] .
out_parameter= OUT parameter_name_list [ ':' array_or_name_type ] .
 in_parameter= IN parameter .
dos_directives= NEAR | FAR | EXPORT | ASSEMBLER .
calling_directives= CDECL | PASCAL | REGISTER | SAFECALL | STDCALL .
overload_directive= OVERLOAD .
method_directives= ABSTRACT | VIRTUAL | DYNAMIC
| OVERRIDE | REINTRODUCE | MESSAGE constant_expression .
const_type_var_declarations= constant_definitions | resource_defintions
| type_definitions | variable_declarations .
type= keyed_types | type_0 .
// -- called by i_type
enumeration_type= '(' identifier_list ')' .
expression_t= simple_expression_t
[ ( ('=' | '<>' | '<' | '<=' | '>' | '>=' | IN ) simple_expression_t
| '..' end_range_type ) ] .
simple_expression_t= [ '+' | '-' ] term_t { ('+' | '-' | OR | XOR ) term_t } .
term_t= factor_t { ('*' | '/' | DIV | MOD | AND | SHR | SHL ) factor_t } .
factor_t= NUMBER | STRING_LITTERAL | NIL
| variable_access
| NOT factor_t | '@' factor_t
| '^' NAME
| '(' expression_t ')'
| set_factor .
end_range_type= simple_expression_t .
type_0= ( NUMBER | STRING_LITTERAL | NIL | NOT | '+' | '-' | '@' | '(' | '[' | NAME )
$i_type .
keyed_types= string_type | structured_type | pointer_type | procedural_type .
// -- handle STRING as array[index_type]
string_type= STRING [ '[' constant_expression ']' ] .
structured_type= [ PACKED ] ( array_type | record_type | set_type | file_type ) .
array_type= ARRAY [ '[' index_type { ',' index_type } ']' ] OF type .
index_type= constant_expression [ '..' constant_expression ] .
record_type= RECORD field_list END .
field_list= { common_field ';' } [ variant_fields ] .
common_field= identifier_list ':' type .
variant_fields= CASE tag OF cases { cases } .
tag= VARIANT_TAG_NAME [ ':' unit_qualified_type_name ] .
cases= constant_expression { ',' constant_expression }
':' one_case .
one_case= '(' [ common_field { ';' [ ( common_field | variant_fields ) ] }
| variant_fields ]
')' [ ';' ] .
set_type= SET OF type .
file_type= FILE [ OF type ] .
pointer_type= '^' POINTED_NAME .
procedural_type= ( PROCEDURE [ formal_parameters ]
| FUNCTION [ formal_parameters ] ':' function_result_type )
$<dir( [ OF OBJECT ] | i_procedural_type_directives ) $>dir .
procedural_type_directives= calling_directives .
i_procedural_type_directives= ( ';'
| CDECL | PASCAL | REGISTER | SAFECALL | STDCALL ) $i_directives .
constant_definitions= CONST constant_definition { constant_definition } .
constant_definition= CONST_NAME [ ':' type ] '=' typed_constant ';' .
resource_defintions= RESOURCESTRING resource_definition { resource_definition } .
resource_definition= RESOURCE_NAME '=' string_expression ';' .
type_definitions= TYPE type_definition { type_definition } .
type_definition= TYPE_NAME '=' [ TYPE ] ( class_type | interface_type | type ) ';' .
// -- used in INTERFACE also
property= PROPERTY $>priv PROPERTY_NAME [ property_type ] property_specifiers .
property_type= [ property_indexes ] ':' unit_qualified_type_name .
property_indexes= '[' property_index { ';' property_index } ']' .
property_index= [ CONST ] INDEX_NAME { ',' INDEX_NAME }
':' unit_qualified_type_name .
property_specifiers= $<prop [ INDEX constant_expression ] $>prop
// -- "READ FTabSize.Y"
$<prop [ READ variable_access | READONLY ]
[ WRITE WRITE_NAME | WRITEONLY ] $>prop
// -- some params called "dispid"
$<prop [ DISPID constant_expression ] [ ';' ] $>prop
$<prop { storage_specifier [';' ] } $>prop
[ IMPLEMENTS unit_qualified_identifier { ',' unit_qualified_identifier } ';' ] .
storage_specifier= storage_stored | storage_default | storage_no_default .
storage_stored= STORED [ constant_expression ] .
storage_default= DEFAULT [ constant_expression ] .
storage_no_default= NODEFAULT .
// -- the ; is in the type_definitions
 class_type= CLASS [ class_reference | class_definition ] .
class_reference= OF unit_qualified_type_name .
// -- class_definition : can be foward with inheritance
class_definition= [ inheritance ] [ class_body ] .
inheritance= '(' unit_qualified_type_name { ',' unit_qualified_type_name } ')' .
class_body= fields_and_procs_section { fields_and_procs_section } END .
fields_and_procs_section= $<priv protection fields_and_procs $>priv .
protection= [ PRIVATE | PROTECTED | PUBLIC | PUBLISHED ] .
fields_and_procs= { class_field } { class_methods | property $<priv } .
class_field= identifier_list $>priv ':' type ';' $<priv .
class_methods= constructor | destructor |
[ CLASS ] ( class_procedure | class_function ) .
method_directives_= $<dir
{ (method_directives | overload_directive | calling_directives)
[ ';'] } $>dir .
// -- if interfaces : "FUNCTION i_xxx.yyy = zzz;"
rename_method= '.' NAME '=' NAME ';' .
constructor= CONSTRUCTOR $>priv PR_NAME [ formal_parameters ] ';'
method_directives_ $<priv .
destructor= DESTRUCTOR $>priv PR_NAME [ formal_parameters ] ';'
method_directives_ $<priv .
class_procedure= PROCEDURE $>priv PR_NAME
( rename_method | [ formal_parameters ] ';'
method_directives_ ) $<priv .
class_function= FUNCTION $>priv FN_NAME
( rename_method | [ formal_parameters ] ':' function_result_type ';'
method_directives_ ) $<priv .
interface_type= ( INTERFACE | DISPINTERFACE ) [ interface_definition ] .
interface_definition= [ interface_heritage] [interface_g_u_i_d ]
interface_member_list END .
interface_heritage= '(' identifier_list ')' .
interface_g_u_i_d= '[' string_expression ']' .
interface_member_list= { class_procedure_ | class_function_ | property } .
interface_directives_= $<dir
{ (method_directives | overload_directive | calling_directives | dispid )
[ ';'] } $>dir .
dispid= DISPID constant_expression .
// -- redefinition "PROCEDURE x.y= z;" (axctrls)
class_procedure_= ( PROCEDURE | CONSTRUCTOR | DESTRUCTOR )
PR_NAME [ formal_parameters ] ';' interface_directives_ .
class_function_= FUNCTION FN_NAME [ formal_parameters ] ':' function_result_type ';'
interface_directives_ .
variable_declarations= (THREADVAR | VAR) variable_declaration { variable_declaration } .
// -- has separated in 2 because of initialization
// -- absolute can be after a list, but not with initialization
variable_declaration= ID_NAME
( ':' type [ '=' typed_constant | absolute ] ';'
| { ',' ID_NAME } ':' type [ absolute ] ';' ) .
absolute= ABSOLUTE OTHER_VAR_NAME .
// -- code
expression= simple_expression [ ('=' | '<>' | '<' | '<=' | '>' | '>=' | IN | IS )
simple_expression ] .
simple_expression= [ '+' | '-' ] term { ('+' | '-' | OR | XOR ) term } .
term= factor { ('*' | '/' | DIV | MOD | AND | SHR | SHL ) factor } .
// -- called by $i_access_or_expression
// -- can be empty if fn call "fn()"
parenthized_expression= '(' [ expression { ',' expression } ] ')' .
factor= NUMBER | STRING_LITTERAL | NIL
| NOT factor | '@' factor | INHERITED [ factor ]
| '^' NAME
| set_factor
// -- x= (Sender AS tButton).Caption
// -- the AS is only for the level 0
| ( NAME | STRING ) { parenthized_expression | end_access }
| parenthized_expression { end_access } .
end_access= { array_access | record_access | '^' | as_access } .
array_access= '[' expression { ',' expression } ']' .
record_access= '.' expression .
as_access= AS NAME .
// -- instructions
asm= ASM { asm_statement } END .
// -- for pasting in i_asm
asm_statement_= { NAME | NUMBER | STRING_LITTERAL
| '[' | ']' | '.' | ','
| ':'
 | '+' | '-' | '*' | '/'
| NOT | AND | OR | XOR | SHR | SHL | DIV } .
label_= '@' [ '@'] ( ALL_NAME | NUMBER ) .
asm_statement= ( NAME | NUMBER | STRING_LITTERAL
| '[' | ']' | '.' | ','
| '@'
| ':'
| '+' | '-' | '*' | '/'
| NOT | AND | OR | XOR | SHR | SHL | DIV ) $i_asm .
composed_instruction= F .
// -- allows empty ";" instruction
instruction_list= [ instruction ] { ';' [ instruction ] } .
instruction= { assignment_or_call | structured_instruction } .
// -- this covers "x[3].z:= u;" or "my_proc(3+ zz)";
// -- acces or (pchar+ 1)^ := ...
assignment_or_call= expression [ end_assignment ] .
// -- "(Sender As tButton).Caption:= xxx"
end_assignment= ':=' expression .
structured_instruction= composed_instruction | test | repetition | with
| try | inherited_call | raise_statement | asm .
test= if | case .
if= IF expression THEN instruction [ ELSE instruction ] .
// -- D5: ';' after last instr or before ELSE optional !
case= CASE expression OF case_element
{ ';' [ ELSE $NOREAD | END $NOREAD | case_element ] }
[ ELSE instruction_list ] END .
case_element= case_label ':' instruction .
// -- a general constant constant_expression, but no set [],
// -- unless in a function call
case_label= constant_expression
{ ( ',' constant_expression | '..' constant_expression ) } .
repetition= while | repeat | for .
while= WHILE expression DO instruction .
repeat= REPEAT instruction_list UNTIL expression .
for= FOR unit_qualified_identifier ':=' expression [ TO | DOWNTO ]
expression DO instruction .
// -- "with xxx AS"
with= WITH expression { ',' expression } DO instruction .
try= TRY instruction_list
( EXCEPT except_block | FINALLY instruction_list ) END .
except_block= on [ ELSE instruction_list ] | instruction_list .
// -- can have "ON ezero DO ELSE xxx ;" or "ON xxx DO ;"
on= handle_instruction { ';' [ handle_instruction ] } .
exception_identifier= unit_qualified_identifier [ ':' unit_qualified_identifier ] .
handle_instruction= ON exception_identifier DO [ instruction ';' ] .
// -- "Inherited Items[Index]:= "
inherited_call= INHERITED [ instruction ] .
// inline_statement= INLINE '(' INTEGERCONST {'/' INTEGERCONST } ')' .
raise_statement= $<at RAISE [ variable_access ] [ AT constant_expression ] $>at .
composed_instruction= BEGIN instruction_list END .
// -- bloc
// -- VIRTUAL etc only in CLASS
routine_header= class_methods_header | constructor_header | destructor_header
| procedure_header | function_header .
// -- methods have no directives in implementation
class_methods_header= CLASS (class_procedure_method | class_function_method ) .
class_procedure_method= PROCEDURE CLASS_NAME '.' PR_NAME [ formal_parameters ] ';' .
// -- repeating the result is optional
class_function_method= FUNCTION CLASS_NAME [ '.' FN_NAME ]
[ formal_parameters ] [ ':' function_result_type ] ';' .
constructor_header= CONSTRUCTOR CLASS_NAME '.' PR_NAME [ formal_parameters ] ';' .
destructor_header= DESTRUCTOR CLASS_NAME '.' PR_NAME [ formal_parameters ] ';' .
// -- always ; before directives (for procedural cdecl is without ? )
code_procedure_directives= $<dir { (dos_directives
| calling_directives | overload_directive)
[ ';'] } $>dir .
procedure_header= PROCEDURE
CLASS_OR_PR_NAME [ '.' PR_NAME ] [ formal_parameters ] ';'
code_procedure_directives .
// -- for the functions, STDCALL does not require ; "fn xxx: yyy STDCALL;"
function_header= FUNCTION CLASS_OR_FN_NAME [ '.' FN_NAME ]
[ formal_parameters ] [ ':' function_result_type ]
[ ';' ] code_procedure_directives [ ';' ] .
bloc= F .
main_declarations= const_type_var_declarations | procedure_declarations_and_body .
 procedure_declarations_and_body= { procedure_declaration } .
procedure_declaration= routine_header
$<dir ( FORWARD $>dir | EXTERNAL $>dir end_external | $>dir bloc ) ';' .
// "procedure xxx; external;"
// "procedure xxx; external 'xxx';"
// "procedure xxx; external xxx;"
// "procedure xxx; external xxx NAME 'MessageBoxA';"
// "procedure xxx; external xxx 'MessageBoxA' INDEX 31;"
end_external= [ constant_expression $<index [ index ] $>index ] '.' .
index= INDEX constant_expression .
bloc= { main_declarations } ( composed_instruction | asm ) .
main_uses= USES uses_in { ',' uses_in } ';' .
uses_in= UNIT_NAME [ IN constant_expression ] .
// -- program / units / library / packages
program= PROGRAM NAME ';' [ main_uses ] bloc '.' .
unit= UNIT UNIT_NAME ';' unit_interface unit_implementation unit_end '.' .
uses= USES identifier_list ';' .
unit_interface= INTERFACE [ uses ] { const_type_var_declarations | routine_header } .
unit_implementation= IMPLEMENTATION [ uses ] { main_declarations } .
unit_end= ( BEGIN instruction_list | initialization ) END .
initialization= [ INITIALIZATION instruction_list [ FINALIZATION instruction_list ]] .
library= LIBRARY LIBRARY_NAME main_uses bloc '.' .
package= PACKAGE PACKAGE_NAME ';'
$<pack [ requires_clause ] [ contains_clause ] $>pack END '.' .
requires_clause= REQUIRES REQUIRES_NAME {',' REQUIRES_NAME } ';' .
contains_clause= CONTAINS contains_statement {',' contains_statement } ';' .
contains_statement= CONTAINS_NAME [ IN constant_expression ] .

Caractersticas especficas del Lenguaje

Delphi est basado en una versin de Pascal denominada Object Pascal. Borland en los ltimos aos
defenda que el nombre correcto del lenguaje es tambin Delphi, posiblemente debido a pretensiones de
marca, aunque en sus mismos manuales el nombre del lenguaje apareca como Object Pascal, por lo
que la comunidad de programadores no ha adoptado mayoritariamente este cambio (supuesta
aclaracin, segn Borland). Object Pascal expande las funcionalidades del Pascal estndar:

Soporte para la programacin orientada a objetos (habitualmente llamada POO) tambin

existente desde Turbo Pascal 5.5, pero ms evolucionada en cuanto a:
Encapsulacin: declarando partes privadas, protegidas, pblicas y publicadas de las clases
Propiedades: concepto nuevo que luego han adaptado muchos otros lenguajes. Las
propiedades permiten usar la sintaxis de asignacin para setters y getters.
Simplificacin de la sintaxis de referencias a clases y punteros.
Soporte para manejo estructurado de excepciones, mejorando sensiblemente el control de errores
de usuario y del sistema.
Programacin activada por eventos (event-driven), posible gracias a la tcnica de delegacin de
eventos. Esta tcnica permite asignar el mtodo de un objeto para responder a un evento lanzado
sobre otro objeto. Fue adoptada por Niklaus Wirth, autor del Pascal Original, e incorporada a
otros de sus lenguajes como Component Pascal.
Delphi es una TwoWayTool, es decir una herramienta de dos direcciones, porque permite
crear herramientas de dos formas: una de forma visual en la pantalla por medio de la funcin de
arrastrar y colocar (Drag & Drop), la otra es a travs de la programacin convencional,
escribiendo el cdigo. Ambas tcnicas pueden utilizarse de forma alternativa o simultanea.
Fuentes Bibliogrficas

delphiallimite.blogspot.com (http://delphiallimite.blogspot.com)
programacionfacil.com (http://www.programacionfacil.com/borland_delphi/start)
es.wikipedia.org
geocities.com (http://www.geocities.com/v.iniestra/delphi/index.html)

Obtenido de https://es.wikibooks.org/w/index.php?title=Lenguaje_Delphi&oldid=298085

Categoras: Libros Programacin

Esta pgina fue modificada por ltima vez el 24 feb 2016 a las 17:56.
El texto est disponible bajo la Licencia Creative Commons Atribucin-CompartirIgual 3.0;
pueden aplicarse trminos adicionales. Vase Trminos de uso para ms detalles.