Lenguaje Delphi

Lenguaje Delphi
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 la actualidad da ms posibilidades.

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.

Lenguaje Delphi

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:

Lenguaje Delphi

and class do file if interface not procedure

array const downto Finalization

es

asm

begin

Case

constructor destructor dispinterface Div else finally end for inherited library or raise shr type with except function exports Goto

implementation in is object program label of property shl try while

initialization Inline mod out record string unit Xor Nil Packed repeat then Until

resourcestring set thread uses varto var

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.

Lenguaje Delphi

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)

Lenguaje Delphi

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 declarada. 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.
Elemento Entrada Label Salida

.Caption .Caption :=

Pero hay que aclarar que los mtodos de entrada y salidas de Label y Edit(Caja de Texto) reciben o envan String o cadena de caracteres as que para problemas que requieran de entradas numricas o salidas numricas se usan los siguientes mtodos de conversin.
Mtodo IntToStr(variable:Integer) StrToInt(variable:String) FloatToStr(variable:Float) Convierte de Convierte a Integer String Real String Integer String Real

StrToFloat(Variable:String) String

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.

Lenguaje Delphi

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 + * / div mod Asociatividad Por la Izquierda Por la Izquierda Por la Izquierda Por la Izquierda Por la Izquierda Por la Izquierda

Orden de Precedencia 1 2 3 4 5 Las operaciones entre parntesis Races o Potencias Multiplicaciones o Divisiones Sumas o Restas

Operadores

Si hay 2 o ms operadores del mismo Orden 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.
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 asignacin de valores. A continuacin se presenta una tabla con los operadores para cuando hay ms de una condicin a evaluar.

Lenguaje Delphi

Operador Significado AND OR NOT y lgico o lgico negacin

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;

Lenguaje Delphi 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> End; := Instruccin; Aqu ocurre el famoso return de las funciones

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.

Lenguaje Delphi

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;

Lenguaje Delphi 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.

10

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.

Lenguaje Delphi 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.

11

Lenguaje Delphi

12

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 ')' )

Lenguaje Delphi
['=' constant_expression ] .

13

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 | '..' 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 . ) . ) simple_expression_t

Lenguaje Delphi
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= ( ';' . .

14

| 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_stored= STORED [ constant_expression ] . | storage_no_default .

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)

Lenguaje Delphi
[ ';'] } $>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 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 ] ';' ':' type [ absolute ] ';' ) . [ formal_parameters ] ':' function_result_type ';'

15

| { ',' ID_NAME }

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

Lenguaje Delphi
// -- 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 label_= | AND | OR | XOR | SHR | SHL | DIV } . | ',' } .

16

'@' [ '@'] ( 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 .

Lenguaje Delphi
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 ) ';' .

17

// "procedure xxx; external;" // "procedure xxx; external 'xxx';"

Lenguaje Delphi
// "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 ] .

18

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.

Lenguaje Delphi

19

Fuentes Bibliogrficas
delphiallimite.blogspot.com [1] programacionfacil.com [2] es.wikipedia.org geocities.com [3]

Referencias
[1] http:/ / delphiallimite. blogspot. com [2] http:/ / www. programacionfacil. com/ borland_delphi/ start [3] http:/ / www. geocities. com/ v. iniestra/ delphi/ index. html

Fuentes y contribuyentes del artculo

20

Fuentes y contribuyentes del artculo

Lenguaje Delphi Fuente: http://es.wikibooks.org/w/index.php?oldid=206066 Contribuyentes: Jbarrios, ManuelGR, Rapsware, Savh, 6 ediciones annimas

Licencia
Creative Commons Attribution-Share Alike 3.0 //creativecommons.org/licenses/by-sa/3.0/