Lenguaje Delphi

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

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

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

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

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

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

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

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

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
Label	.Caption	.Caption :=

Pero hay que aclarar que los métodos de entrada y salidas de Label y Edit(Caja de Texto) reciben o envían String o 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

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

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:

Tabla de Operadores con asociatividad y precedencia

Operadores	Asociatividad
+	Por la Izquierda
-	Por la Izquierda
*	Por la Izquierda
/	Por la Izquierda
div	Por la Izquierda
mod	Por la Izquierda

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

Estructuras de decisión e iteración

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
>	Mayor que
<	Menor que
>=	Mayor o Igual que
<=	Menor o Igual que
=	Igual
<>	Distinto de

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

A continuación se presenta una tabla con los operadores para cuando hay más de una condición a evaluar.

Operador	Significado
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

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

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

Implementación de Corrutinas

Manejo de Excepciones

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

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

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

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