Índice

Introducción al Lenguaje Delphi (Pág. 1-2)

Historia y contexto.

Instalación y Herramientas de Compilación (Pág. 3-4)

Requisitos por sistema operativo.

Programa "Hola Mundo" (Pág. 5-6)

Ejemplo práctico paso a paso.

Diccionario de Palabras Reservadas (Pág. 7-8)

Lista de palabras clave y símbolos del lenguaje.

Tipos de Datos Fundamentales (Pág. 9-10)

Enteros, reales, cadenas, booleanos y más.

Operaciones de Entrada y Salida (Pág. 11-12)

Comandos para aplicaciones de consola y formularios.

Estructuras de Control (Pág. 13-15)

Decisiones y ciclos en Delphi (if, for, while).

Declaración de Métodos y Funciones (Pág. 16-17)

Diferencia entre procedimientos y funciones.

Programación Orientada a Objetos (POO) (Pág. 18-20)

Encapsulación, herencia y polimorfismo.

Manejo de Excepciones (Pág. 21-22)

Bloques try...except y excepciones comunes.

Gramática del Lenguaje (Pág. 23-24)

Estructura gramatical y reglas en EBNF.

Características del Lenguaje (Pág. 25-26)

Diferencias con Pascal estándar.

Fuentes Bibliográficas (Pág. 27)

Referencias y enlaces adicionales.
 Donaciones Crear una cuenta Acceder

Lenguaje Delphi Añadir idiomas

Página Discusión Leer Editar Ver historial Herramientas

Lenguaje Delphi [ editar ]

Delphi es un entorno de desarrollo de software diseñado para la programación de propósito

general con énfasis en la programación visual. En Delphi se utiliza como lenguaje de
programación una versión moderna de Pascal llamada Object Pascal.

Historia [ editar ]

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 dólares. En sus diferentes variantes, permite producir
archivos ejecutables para Windows, Linux y la plataforma .NET.

CodeGear ha sido escondida de la empresa Borland, donde Delphi se creó originalmente, tras
un proceso que pretendía 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 propósito
múltiple, se usa también para proyectos de casi cualquier tipo, incluyendo aplicaciones de
consola, aplicaciones de web, servicios COM y DCOM, y servicios del sistema operativo.

Delphi inicialmente sólo producía ejecutables binarios para Windows: Delphi 1 para Win16 y
con Delphi 2 se introdujo Win32. En el año 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 instalación y uso de herramientas de Compilación

[ editar ]

Las herramientas usadas para la Compilación de Delphi según el sistema operativo son:
Para Windows:
Borland Delphi 7, RAD Studio 2007
Para Linux y Unix:
Kylix 3.0.
Pero en esta documentación nos centraremos en la instalación 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 código directamente ejecutable,
no pseudo − código que debe ser interpretado posteriormente en tiempo de ejecución. Esto
tiene básicamente dos consecuencias: el ejecutable es más rápido, al no tener que ser
interpretado en tiempo de ejecución y el tamaño total final de la aplicación suele ser inferior;
ya que no es necesaria la distribución adicional del programa que interpreta y ejecuta el
código al que se suele denominar Runtime.

Programa Hola Mundo [ editar ]

Ahora como todo tutorial iniciaremos con una pequeña aplicación de una ventana con un
botón que desplegará un mensaje con el rótulo de ‘Hola mundo’. Para eso, nos vamos al
primer menú de la parte superior y damos clic a la opción ‘file’, acto seguido damos clic a ‘new’
y luego a ‘application’.

Se genera un proyecto con un formulario vacío, es ahí donde comienza la tarea de comenzar
a arrastrar los demás elementos visuales al formulario vacío como: etiquetas, cajas de textos,
lista de textos, memos, botones, etc. En el programa sólo necesitaremos arrastrar un botón.
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 rótulo que deseamos para el botón. Ahora
para poder comenzar a programar lo que debe hacer el botón, recuerde que se programa por
eventos así que seleccionamos el botón, luego nos vamos a su Object Inspector y le damos a
la pestaña ‘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 código.

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 botón haga en el evento onClick; que, básicamente es el evento cuando el botón le den
clic. Ahora le ponemos la siguiente instrucción.

procedure TForm1.Button1Click(Sender: TObject);

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

Ahora unas aspectos a tomar en cuenta: cada instrucción 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 sólo con darle clic a F9, se ejecutará
siempre y cuando no halle ningún error, y si lo hubiera en la parte inferior del editor de código
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 instrucción showMessage(); desplega un mensaje con
el argumento que reciba puede ser un mensaje string o del tipo Pchar(Combinacion de
números y letras). Ejecución del programa.

Diccionario de palabras reservadas, operadores y símbolos del

lenguaje [ editar ]

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 adición a las palabras de arriba, private, protected, public, published, y automated actúan
como palabras reservadas dentro las declaraciones de tipos de objetos, pero en otra forma
son tratadas como directrices. También las palabras at y on tienen significados especiales.

Símbolos especiales [ editar ]

Los símbolos especiales son caracteres no alfabéticos, o pares de estos caracteres, que
tienen significados fijos. Los siguientes caracteres son símbolos especiales:

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

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

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

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

Comentarios y directrices de compilación [ editar ]

Los comentarios son ignorados por el compilador, excepto cuando su función es de

separadores delimitando tokens adyacentes o directrices de compilación. Existen muchas
directrices de compilación:

{ El texto entre llaves constituye un comentario. }

(* El texto entre paréntesis mas asteriscos constituye un comentario. *)
// Todo texto después de un doble slash constituye un comentario hasta
el final de la línea.

Un comentario que contenga un signo de $ es una directriz de compilación. Por ejemplo,

{$WARNINGS OFF}

indica al compilador que no genere avisos.

Tipos de datos fundamentales y su representación [ editar ]

Integer

Números enteros comprendidos entre −32768 y 32767; 16 bits (ocupan 2 bytes cada uno en la
memoria)

Byte

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

Word

Números positivos comprendidos entre 0 y 65535; 16 bits (ocupan 2 bytes cada uno en la
memoria)

LongInt

Números enteros comprendidos entre −2147483647 y 2147483647 32 bits (ocupan 4 bytes

cada uno en la memoria)

ShortInt

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

Real

Números de coma flotante de 11 a 12 decimales significativos (delante y detrás de la coma);

ocupan 6 bytes cada uno en la memoria

Single

Números de coma flotante de 7 a 8 decimales significativos; solo es posible si está activada la

opción de compilador {$N+}; ocupan 4 bytes cada uno en la memoria

Double

Números de coma flotante de 15 a 16 cifras delante y detrás de la coma; solo es posible si

está activada la opción de compilador {$N+}; ocupan 8 bytes cada uno en la memoria

String

Secuencia de símbolos con una longitud máxima de 255 caracteres ASCII.

Char

Caracteres ASCII simples

Pchar

Puntero a una cadena terminada en carácter 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 básica [ editar ]

Las operaciones de entrada y salida en Delphi son variadas dependiendo de la aplicación que
se está programando. Si es una aplicación 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 número que está almacenado en una variable
simplemente se pone el nombre de la variable como parámetro.

Si es una aplicación con formularios y ventanas, eso depende de cuales sean los elementos
de entrada y cuales los de salida, a continuación una breve descripción de objetos (Más
comunes) y sus métodos de entrada y salida.

Elemento Entrada Salida Pero hay que aclarar que los métodos de entrada y salidas
.Caption := de Label y Edit(Caja de Texto) reciben o envían String o
Label .Caption cadena de caracteres así que para problemas que
requieran de entradas numéricas o salidas numéricas se
usan los siguientes métodos de conversión.

Método 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 representación [ editar ]

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 declaración se hace en la parte ‘var’ del programa principal, en el caso de una aplicación
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 varía 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.

Declaración e inicialización de variables [ editar ]

Para la declaración 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 recién creadas:

<Nombre de Variable> := <Valor>

Tabla de Operadores con asociatividad y precedencia [ editar ]

Operadores Asociatividad Orden de

Operadores
Precedencia
+ Por la Izquierda
1 Las operaciones entre paréntesis
- Por la Izquierda
2 Raíces o Potencias
* Por la Izquierda
3 Multiplicaciones o Divisiones
/ Por la Izquierda
4 Sumas o Restas
div Por la Izquierda
Si hay 2 o más operadores del mismo
mod Por la Izquierda
5 Orden entonces se usa la asociatividad
por la izquierda

Estructuras de decisión e iteración [ editar ]

Antes de iniciar con las estructuras de decisión e iteración, se debe conocer los operadores de
las condiciones que son la base de las dos siguientes estructuras a ver.

Operador Significado Hay que tener claro que la diferencia entre ‘=’ y “:=” es, que el
> Mayor que primero compara dos variables y el segundo es una
asignación de valores.
< Menor que

>= Mayor o Igual que A continuación se presenta una tabla con los operadores para
cuando hay más de una condición a evaluar.
<= Menor o Igual que

= Igual Operador Significado

<> Distinto de AND “y” lógico

OR “o” lógico

NOT negación

Decisión
Uso del If

If Condición(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 sería 1, 2, 3,… hasta donde sea
necesario, y si es un Char, cada constante a evaluar sería ‘a’, ‘b’, ‘c’,…etc.

Iteración
Ciclo For

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

Begin
Instrucciones;
End

Ciclo While

While (Condición) Do
Begin
Instrucciones;
*Instrucción de salida del Ciclo;
End

Ciclo Repeat Until

Repeat
Instrucciones;
*Instrucción de salida del Ciclo;
Until (Condición);

Dependiendo de la condición, la instrucción puede variar pero esta instrucción es vital para
evitar ciclos infinitos.

Declaración, definición y uso de métodos y funciones [ editar ]

Delphi por supuesto tiene lo que es el uso de funciones y Procedimientos, ahora definiremos
por separado cada uno de estos módulos.
Procedimientos:
Es un modulo de un programa que realiza tareas específicas y que no puede regresar valores
a la parte principal del programa u otro procedimiento que lo esté invocando.
Declaración y Definición de los Procedimientos.

Procedure <Nombre del Procedimiento>

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

Este esquema de la definición y declaración se hace en la sección 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 función es un módulo de un programa separado del cuerpo principal, que realiza una
tarea específica y que puede regresar un valor a la parte principal del programa u otra función
o procedimiento que la invoque.
Declaración y Definición de las Funciones.

Function<Nombre de la Función> (Parámetros): <Tipo de Dato a retornar>;

Var
{Lista de variables locales}
Begin
{Bloque de instrucciones }
<Nombre de la Función> := Instrucción; Aquí ocurre el famoso
‘return’ de las funciones
End;

Este esquema de la definición y declaración se hace en la sección de ‘VAR’ del programa

principal.
Uso.
Simplemente en el programa principal se hace el llamado a función.

Implementación y uso de la Programación Orientada a Objetos [ editar ]

Generalmente la POO se asocia rápidamente con lenguajes como C++, pero Object Pascal,
de ahí su nombre, cuenta con todos los componentes básicos de un lenguaje orientado a
objetos con la encapsulación, la herencia y el polimorfismo.

Comenzando con el concepto de encapsulación de datos que trata básicamente de encerrar

un conjunto de datos dentro de un objeto que sólo los métodos 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 sólo 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 sólo pueda ser
accesado o modificado por medio de métodos del propio Objeto. El primer atributo se asume
que es un atributo público; es decir, que puede ser modificado y/o accesado sin necesidad de
métodos. A continuación 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 definición de las funciones y procedimientos se hace en la sección ‘var’ del ‘main’ y la
diferencia está en que el nombre de la función o del procedimiento siempre es precedido por
el Nombre del objeto más 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 parámetros que necesiten y en el caso de las
funciones no es necesario escribe ‘: <tipo que retornan>’ porque ya están 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 recomendación es que los métodos comunes entre el padre y el hijo se deben declarar y
definir en el padre, porque esos métodos se heredan de manera implícita en el hijo, dejando
solamente la tarea de declarar y definir los métodos únicos del hijo.

Por último falta mencionar la declaración del polimorfismo, básicamente es una herencia
múltiple de un padre a varios hijos, acá se usa la palabra reservada ‘virtual’. Este hace que los
métodos (procedimientos y funciones) comunes entre el padre y el hijo puedan sobrescribirse.
Básicamente permite que si hay un padre que hereda a varios hijos un método en común pero
que cada método según el hijo funciona de manera diferente, puedan ser definidos en cada
hijo usando siempre el mismo nombre.

Esquema de administración y separación de la memoria [ editar ]

Implementación de Corrutinas [ editar ]

Manejo de Excepciones [ editar ]

El manejo de excepciones en Delphi no varía mucho de los demás lenguajes de hoy en día 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 genérica, pero también se puede diseñar bloques de
excepciones con indicaciones más específicas.

Por ejemplo del Bloque anterior se pueden puede cambiar de la siguiente manera para que
sólo intente el Try-Except con errores específicos.

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 inválidos.
EBitsError: Previene intentos para acceder a arrays de elementos booleanos.
EComponentError: Nos informa de un intento inválido 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 máscara de texto.
EDivByZero: Errores de división por cero.
EExternalException: Significa que no reconoce el tipo de excepción (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 conversión de tipos.
EInvalidGraphic: Indica un intento de trabajar con gráficos que tienen un formato
desconocido.
EInvalidOperation: Ocurre cuando se ha intentado realizar una operación inválida sobre un
componente.
EInvalidPointer: Se produce en operaciones con punteros inválidos.
EMenuError: Controla todos los errores relacionados con componentes de menú.
EOleCtrlError: Detecta problemas con controles ActiveX.
EOleError: Especifica errores de automatización de objetos OLE.
EPrinterError: Errores al imprimir.
EPropertyError: Ocurre cuando se intenta asignar un valor erróneo a una propiedad del
omponente.
ERangeError: Indica si se intenta asignar un número entero demasiado grande a una
propiedad.
ERegistryExcepcion: Controla los errores en el registro.
EZeroDivide: Controla los errores de división para valores reales.

Gramática en EBNF del lenguaje [ editar ]

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

Características específicas del Lenguaje [ editar ]

Delphi está basado en una versión de Pascal denominada Object Pascal. Borland en los
últimos años defendía que el nombre correcto del lenguaje es también Delphi, posiblemente
debido a pretensiones de marca, aunque en sus mismos manuales el nombre del lenguaje
aparecía como Object Pascal, por lo que la comunidad de programadores no ha adoptado
mayoritariamente este cambio (supuesta aclaración, según Borland). Object Pascal expande
las funcionalidades del Pascal estándar:

Soporte para la programación orientada a objetos (habitualmente llamada POO) también

existente desde Turbo Pascal 5.5, pero más evolucionada en cuanto a:
Encapsulación: declarando partes privadas, protegidas, públicas y publicadas de las
clases
Propiedades: concepto nuevo que luego han adaptado muchos otros lenguajes. Las
propiedades permiten usar la sintaxis de asignación para setters y getters.
Simplificación 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.
Programación activada por eventos (event-driven), posible gracias a la técnica de
delegación de eventos. Esta técnica permite asignar el método 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 Two−Way−Tool, 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 función de arrastrar y colocar (Drag & Drop), la otra es a través de la programación
convencional, escribiendo el código. Ambas técnicas pueden utilizarse de forma alternativa
o simultanea.

Fuentes Bibliográficas [ editar ]

delphiallimite.blogspot.com
programacionfacil.com
es.wikipedia.org
geocities.com

Categorías: Libros Programación

Esta página se editó por última vez el 10 may 2023 a las 22:48.

El texto está disponible bajo la Licencia Creative Commons Atribución-CompartirIgual 4.0. Pueden existir condiciones
adicionales. Véanse los términos de uso para más detalles.

Política de protección de datos Acerca de Wikilibros Descargos Código de conducta Desarrolladores Estadísticas

Declaración de cookies Versión para móviles