Sintaxis de Ada 

1

Ejemplo : ------------------------------------------------------------ -- -- Autor : Patricia -- Descripcion : Este programa simplemente saluda al mundo diciendo: Hola Mundo!!! ¿Cómo está el día? -- Algoritmo : -- Imprime el mensaje en la pantalla -- ------------------------------------------------------------ with Ada.Text_IO; use Ada.Text_IO; procedure Primer_Mensaje is ------------------------------------------------------------ -- comienzo del programa principal ------------------------------------------------------------ begin -- Imprime el mensaje en la pantalla Put (Item => "Hola Mundo!!!,"); New_Line; Put (Item => "Como esta el dia?"); New_Line; New_Line;

Sintaxis de Programa <Programa Principal> <withs y uses de packages> procedure <nombre del Programa Principal> is <declaracion de constantes> < declaracion de tipos > <procedimientos del programa> --------------------------------------------------------- -- Comienzo del Programa Principal --------------------------------------------------------- < declaracion de variables> begin <sentencias ejecutables> end < nombre del Programa Principal >;

Sintaxis de Ada 

2

end Primer_Mensaje;

Ejemplo : ------------------------------------------------------------ -- -- Autor : Patricia -- Descripcion : este paquete contiene el encabezado de un procedimiento simple en Ada denominado Primera_Presentacion. -- ------------------------------------------------------------ with Ada.Text_IO; use Ada.Text_IO; package Ejemplo2 is procedure Primera_Presentacion; end ejemplo2;

Ejemplo : ------------------------------------------------------------ -- -- Autor : Patricia -- Descripcion : este paquete contiene el cuerpo del procedimiento en Ada -- denominado Primera_Presentacion. ------------------------------------------------------------

Sintaxis del encabezado (especificaciones) de paquetes (package) .ads <comentarios del paquete> <withs y uses de otros packages> package < nombre del package > is < declaración de constantes > < declaración de tipos> < especificaciones de los procedimientos del package> end < nombre del package >;

Sintaxis del cuerpo (body) del paquete (package) .adb <comentarios del paquete> <withs y uses de otros packages> package body < nombre del package > is < declaración de constantes > < cuerpos de los procedimientos del package> end < nombre del package >;

Sintaxis de Ada 

3

with Ada.Text_IO; use Ada.Text_IO; package body ejemplo2 is procedure Presentacion is begin put(item=>”Hola mundo, Este es mi primer package, aleluya!!!”) ; end Presentacion; end ejemplo2; Al guardar estos archivos en ADA, se genera un .ads (con las especificaciones, encabezado), y el segundo genera un .adb (el body o cuerpo). Para usarlos en otro programa, se los debe mencionar en la with (contexto de uso), y se lo debe especificar en la cláusula use.

Ejemplo:

with ejemplo2; use ejemplo2; procedure ejemplo_macro is begin Presentacion; end;

Tipos de datos, variables y constantes

Ejemplos : Letra_Inicial : Character; Apellido : String(1..15); Longitud_nombre : Integer; Radio : Float; Pi : constant Float := 3.1416;

Ejemplo :

Area := Pi * Radio ** 2;

Declaración de Variables y Constantes Variables <nombre de variable> : <tipo de dato >; <nombre de variable> - el nombre de la variable. <tipo de dato> - el tipo de dato de esa variable. Constantes <nombre de constante> : constant <tipo de dato> := <valor>; < nombre de constante > el nombre de la constante. <tipo de dato> - el tipo de dato de esa constante. <valor > - el valor de la constante.

Sentencia de Asignación <nombre de variable> := <expresion>; <expresion> - alguna fórmula matemática

Sintaxis de Ada 

4

Input/Output Simple

Ejemplo :

Entrada Simple

Get (Item => Longitud_nombre); Get (Item => Radio); Get (Item => Letra_inicial); Get (Item => Apellido); Salida Simple Put (Item => Longitud_nombre,Width => 3); Put (Item => Radio, Fore => 3, Aft => 2, Exp => 0); Put (Item => Letra_inicial); Put (Item => Apellido); Put_Line (Item => Letra_inicial); Put_Line (Item => Apellido);

Entrada Simple Para todo tipo de datos Get (Item => <nombre de variable>);

Salida Simple Integer Put (Item => <nombre de variable>, Width => <numero entero>); Width – Es el ancho que tomará la salida. Float Put (Item => <nombre de variable>, Fore => <numero entero>, Aft => <numero entero>, Exp => <numero entero>); Fore – el número mínimo de espacios de salida a la izquierda del punto decimal Aft - el número de espacios de salida a la derecha del punto decimal Exp - el número de espacios de salida para el exponente Character and String Put (Item => <nombre de variable>); Put_Line (Item => <nombre de variable>);

Sintaxis de Ada 

5

Orden de Precedencia de los operadores Los operadores de Ada (incluídos los relacionales) tienen un orden de precedencia. Aquí está la lista de todos los operadores de Ada, desde la mayor a la menor precedencia. Aquellos que están en la misma línea tienen la misma jerarquía. ** (exponenciación), abs (valor absoluto), not *, /, mod (módulo), rem (resto) +, - (operadores unarios) +, -, & (operadores binarios) =, /=, <, <=, >, >= and, or, xor (or excluyente)

Estructuras de Control

Selección

Ejemplo : if ( Promedio >= 8.0 ) then

-- Imprimir mensaje para Dany Put (Item => "Tiene muy buen promedio"); New_Line; end if;

Ejemplo : if ( Promedio >= 8.0 ) then

-- Imprimir mensaje alentador Put (Item => "Tiene muy buen promedio"); New_Line; -- en otro caso else -- Imprimir mensaje para mejorar Put (Item => "Debe mejorar su dedicación "); Put (Item => "Suerte la próxima!!!"); New_Line; end if;

Sentencia If de una alternativa if <expresión Boolean > then <sentencia ejecutable > end if; <expresion Boolean > - alguna expresión cuyo valor es True o False. <sentencia ejecutable> - una o más sentencias ejecutables como asignación o llamado a procedimientos, etc.)

Sentencia IF de dos alternativas if <Expresión Boolean > then <sentencia ejecutable> else <sentencia ejecutable> end if; <Expresión Boolean > - alguna expresión cuyo valor es True o False. <sentencia ejecutable> - - una o más sentencias ejecutables.

Sintaxis de Ada 

6

Nota : La sentencia if de múltiples alternativas puede tener tantas elsif porciones como Ud necesite, y la porción else en una sentencia if de múltiples alternativas es opcional. Example : Ejemplo : if ( Promedio >= 8.0 ) then

-- Imprimir mensaje alentador Put (Item => "Tiene muy buen promedio"); New_Line; -- en otro caso elsif (promedio >= 6) then -- Imprimir mensaje para mejorar Put (Item => "Debe mejorar su dedicación "); Put (Item => "Suerte la próxima!!!"); New_Line; -- de otro modo else -- Imprimir mensaje de despedida Put (Item => "Tendrá que ponerse a practicar!!!!!"); New_Line; end if;

Sentencia If de múltiples alternativas if <Expresión Boolean > then <sentencia ejecutable> elsif <Expresión Boolean > then <sentencia ejecutable> elsif <Expresión Boolean > then <sentencia ejecutable> else <sentencia ejecutable> end if; <Expresión Boolean > - alguna expresión cuyo valor es True o False. <sentencia ejecutable> - una o más sentencias ejecutables.

Sentencia Case case <nombre de variable> is when <lista de valores> => <sentencia ejecutable> when <lista de valores> => <sentencia ejecutable> . . . when others => <sentencia ejecutable> end case; <nombre de variable> - el nombre de la varable. <lista de valores> - una lista de posibles valores de la variable. <sentencia ejecutable> - una o más sentencias ejecutables.

Sintaxis de Ada 

7

Ejemplo : case Puntaje is -- Cuando el puntaje esta entre 90 y 100 imprimir felicitaciones when 90 .. 100 => Put_Line (Item => "FELICITACIONES!!!!, tiene el primer puesto"); -- Cuando el puntaje esta entre 80 y 89 imprimir SEGUNDO LUGAR when 80 .. 89 => Put_Line (Item => "Esta en segundo lugar"); -- Cuando el puntaje esta entre 70 and 79 imprimir TERCER LUGAR when 70 .. 79 => Put_Line (Item => " Esta en tercer lugar "); -- Cuando el puntaje esta entre 60 and 69 imprimir CUARTO LUGAR when 60 .. 69 => Put_Line (Item => "Salio CUARTO!!!!"); -- de otro modo when others => Put_Line (Item => "Lo siento, esta en el último lugar"); end case;

Iteración

Ejemplo : -- Para cada entero entre 1 y 10 for I in 1 .. 10 loop -- Imprimir el cuadrado Put (Item => I ** 2, Width => 3); New_Line; end loop;

Sintaxis ciclo For

for <variable de control de ciclo> in <limite inferior> .. <limite superior> loop <cuerpo del ciclo> end loop; < variable de control de ciclo > - este es el nombre de la variable que contola el “loop” y se incrementa de a uno

a lo largo del ciclo. <límite inferior> - Valor inicial de la variable de control. <límite superior> - Valor final de la variable de control. El cuerpo del ciclo se ejecuta una o más veces hasta

que la variable de control toma el valor del límite superior . Entonces el “loop” termina. <cuerpo del ciclo> - Código que es ejecutado cada vez a lo largo del ciclo.

Sintaxis de Ada 

8

Ejemplo 1 : -- Loop loop -- pedido del promedio Put (Item => "Ingrese un promedio entre (0.0 y 10.0) : "); Get (Item => Promedio); Skip_Line; -- Salir cuando el Promedio es >= 0.0 y <= 10.0 exit when ( Promedio >= 0.0 ) and (Promedio <= 10.0 ); -- Imprimir un mensaje de error Put (Item => "El Promedio debe estar entre 0.0 and 10.0 !!!"); New_Line; end loop; Ejemplo 2: -- Loop loop -- pedido del promedio Put (Item => "Ingrese un promedio entre (0.0 y 10.0) : ");

Sintaxis de Loop Básico loop <primera parte del cuerpo del loop > exit when <Expresión Boolean>; < segunda parte del cuerpo del loop > end loop; OR loop < primera parte del cuerpo del loop > if < Expresión Boolean > then exit; end if; < segunda parte del cuerpo del loop > end loop; <Expresión Boolean > - expresión cuyo valor es True o False. Ésta es evaluada cada vez. Si es true, sale del loop, y si es Falseejecuta la segunda parte del cuerpo del loop. La expresión Boolean debe contener por lo menos una variable. < primera parte del cuerpo del loop > - Código que se ejecuta antes del testeo de la expresión booleana < segunda parte del cuerpo del loop > - Código que se ejecuta cuando la expresión es verdadera, y antes de

la primera parte .

Sintaxis de Ada 

9

Get (Item => Promedio); Skip_Line; -- Salir cuando el Promedio es >= 0.0 y <= 10.0 if ( Promedio >= 0.0 ) and (Promedio <= 10.0 ); then exit; end if; -- Imprimir un mensaje de error Put (Item => "El Promedio debe estar entre 0.0 and 10.0 !!!"); New_Line; end loop;

Ejemplo : -- pedido del promedio Put (Item => "Ingrese un promedio entre (0.0 y 10.0) : "); Get (Item => Promedio); Skip_Line; -- Mientras el Promedio es menor que 0.0 o mayor que 10.0 while ( Promedio < 0.0 ) or ( Promedio > 10.0 ) loop -- Imprimir un mensaje de error Put (Item => "El Promedio debe estar entre 0.0 and 10.0 !!!"); New_Line; -- Volver a pedir el promedio Put (Item => "Ingrese un promedio entre (0.0 y 10.0) : "); Get (Item => Promedio); Skip_Line; end loop;

Sintaxis del ciclo While while <Expresión Boolean > loop <cuerpo del cilo> end loop; <Expresión Boolean > - esta es la misma expresión booleana que se usa en una sentencia IF , y que se evalúa

simplemente como True o False. La expresión booleana es evaluada cada vez que se ejecuta el cuerpo del ciclo. Si es True, “entra” al ciclo y ejecuta el cuerpo del mismo. Si es falsa, sale del ciclo. La expresión booleana debe contener por lo menos una variable.

<cuerpo del ciclo> -es el código que se ejecuta cada vez dentro del ciclo

Sintaxis de Ada 

10

Subprogramas

En Ada, los subprogramas se dividen en dos categorías: procedimientos y funciones.

Los parámetros que se le pueden pasar a un procedimiento pueden ser de tres modos diferentes:

- in: el parámetro formal es constante y toma el valor del parámetro actual asociado. (Paso de parámetro

por valor).

- in out: el parámetro formal es una variable y este modo habilita la captura y modificación del valor del

parámetro actual asociado. (Paso de parámetro por referencia).

- out: el parámetro formal es una variable y este modo habilita únicamente la modificación del valor del

parámetro actual asociado.

Ejemplo procedure Una_Prueba (A, B: in Integer; C: out Integer) is begin C:= A + B; end Una_Prueba; Cuando se invoca al procedimiento con la sentencia Una_Prueba (5 + P, 48, Q); las expresiones 5 + P y 48 toman valor, son asignadas a los parámetros formales A y B, y éstos se comportan como constantes durante la ejecución de Una_Prueba. Recuerde que sólo se permiten expresiones en los parámetros actuales cuando el correspondiente parámetro formal está en modo in. A continuación, se asigna el valor A + B a la variable formal C. Obsérvese que al especificar C de modo out , el valor del parámetro actual (Q) no se conoce dentro de Una_Prueba. En este caso, el parámetro formal C es una nueva variable cuyo valor se asignará al parámetro actual (Q) cuando finalice el procedimiento. Si se hubiera querido trabajar con el valor de Q dentro de Una_Prueba, se debería haber empleado C: in out Integer.

Al contrario que los procedimientos, a la función sólo se le pueden pasar parámetros de modo entrada (in) . No se puede especificar otro modo pues el de entrada es por defecto y obligatorio.

Sintaxis de Procedimiento

Procedure <nombre del procedimiento> [ ( lista de parámetros formales ) ] is [declaración de constantes y variables ] begin secuencia_de_sentencias end <nombre del procedimiento> ; parámetro formal ::= <nombre del parámetro> : [ modo ] tipo [ := expresión ] modo ::= in | out | in out

Sintaxis de función

Function <nombre de la función> [ ( lista de parámetros formales ) ] return tipo is [declaración de constantes y variables ] begin secuencia_de_sentencias end <nombre de la función> ; parámetro formal ::= <nombre del parámetro> : [ in ] tipo [ := expresión ]

Sintaxis de Ada 

11

Ejemplo: function Mínimo (A, B: Integer) return Integer is begin if A > B then return (B); else return (A); end if; end Mínimo;

Los parámetros formales de una función se comportan como constantes locales cuyos valores son proporcionados por los parámetros actuales correspondientes.

La sentencia return se utiliza para indicar el valor devuelto por la llamada a la función y para devolver el control a la expresión que llamó a la función. La expresión de la sentencia return es de complejidad arbitraria y debe ser del mismo tipo que se declara en el encabezado de la función.. El cuerpo de la función puede contener varias sentencias return y la ejecución de cualquiera de ellas terminará la función devolviendo el control a la sentencia que la había invocado. Si el flujo del programa sigue varios caminos dentro de la función hay que asegurarse de que se termine siempre con una sentencia return en cada uno de ellos. Así pues, el cuerpo de una función deberá tener al menos una sentencia return obligatoriamente.

Toda llamada a una función produce una nueva copia de cualquier objeto declarado dentro de ella, incluyendo los parámetros. Cuando la función finaliza, desaparecen sus objetos. Por tanto, es posible utilizar llamadas recursivas a una misma función. Como ejemplo, se muestra una posible implementación de la función factorial: function Factorial (N: integer) return integer is begin if N in (0..1) then return 1; else return (N * Factorial (N - 1)); end if; end Factorial; Ejemplo invocación de una función: Dada la siguiente función Sumatoria: function Sumatoria(N: in integer) return integer is Total: integer := 0; begin for I in 1..N loop Total := Total + I; end loop; return Total; end Sumatoria; Se la puede invocar de las siguientes maneras distintas, debiendo cuidarse que se use un parámetro actual para cada parámetro formal: I := Sumatoria(4); I contiene el valor 10 I := Sumatoria(4) * Sumatoria(8) + 5; I contiene el valor 365 Put(Sumatoria(4)); Imprime un 10

Sintaxis de Ada 

12

Arreglos en Ada

Ejemplos

-- declaramos los tipos

inferior: constant integer := 1;

superior: constant integer := 12;

type vector is array (inferior..superior) of float;

type matriz is array (inferior..superior,inferior..superior) of integer;

-- declaramos las variables

precipitaciones: vector;

temperaturas: vector := (28.0, 26.0, 20.0, 16.0, 14.0, 10.0, 9.0, 10.0,

15.0, 18.0, 22.0, 25.0);

notas: vector := ( 1..3 => 4.0, 4|6|8 => 2.0,5 => 1.5, others => 1.0);

finales_aprobados: matriz := (inferior..superior => (others => 0));

El efecto de estas declaraciones es:

28.0 26.0 20.0 16.0 14.0 10.0 9.0 10.0 15.0 18.0 22.0 25.0

Definición de tipo arreglo y declaración de variable arreglo < constante tamaño del arreglo> : constant Integer := <tamaño del arreglo>; type < nombre_tipo > is array (1 .. < constante tamaño del arreglo >) of <tipo_elementos>; <nombre_variable> : <nombre_tipo>; < constante tamaño del arreglo > - nombre de la constante que almacena el tamaño del arreglo <tamaño del arreglo > - El tamaño actual del arreglo. < nombre_tipo > - El nombre del nuevo tipo que se está definiendo. < tipo_elementos > - El tipo de cada elemento del arreglo. < nombre_variable > - El nombre de la variable declarada de nuestro tipo arreglo nombre_tipo.

precipitacione

temperaturas

Sintaxis de Ada 

13

4.0 4.0 4.0 2.0 1.5 2.0 1.0 2.0 1.0 2.0 1.0 1.0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

1) Asignación de valores a un arreglo o parte de éste:

<variable_de_tipo_arreglo>:=(<lista_valores1>); --Asignación completa

<variable_de_tipo_arreglo>(<ind_inf>..<ind_sup>):=(<lista_valores2>); --Asignación a slice

<variable_de_tipo_arreglo>(<indice>):=<elemento>; --Asignación de elemento

Ejemplos precipitaciones:= (1|3 => 10.0, others => 5.0);

10.0 5.0 10.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0

precipitaciones(2..4) := (10.0, 9.0, 8.0);

10.0 10.0 9.0 8.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0

notas

Fina

les_

apro

bado

os

precipitacione

precipitacione

Sintaxis de Ada 

14

precipitaciones(12) := 5.5;

10.0 10.0 9.0 8.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.5

2) Entrada y salida

--Entrada

Get (<variable_tipo_arreglo>(<indice>));

--Salida

Put (<variable_tipo_arreglo>(<indice>));

Ejemplos Get (finales_aprobados(1,5));

For i in inferior..superior loop

Put (precipitaciones(i)); New_line;

End loop;

3) Atributos del tipo array

• First: Devuelve el índice inferior del arreglo -- notas’First devuelve 1 • Last: Devuelve el índice superior del arreglo -- notas’Last devuelve 12 • Length: Devuelve la cantidad de elementos del arreglo -- notas’Length devuelve 12 • Range: Devuelve el intervalo del índice del arreglo -- notas’Range devuelve 1..12

4) Ejemplo de programa completo: with Ada.Text_Io, Ada.integer_text_io, Ada.float_text_io; use Ada.Text_Io, Ada.integer_text_io, Ada.float_text_io; procedure Vectores is Maximo: constant integer := 5; type Vector is array (1 .. Maximo) of Float; Serie: Vector := (others => 0.0); Media: Float := 0.0; procedure Leo_Vector (vec: out Vector) is begin Put_Line ("Ingrese los valores:"); for I in 1..Maximo loop Put("Nro. " & Integer'image(I) & ": "); Get(vec(I)); end loop; end Leo_Vector; procedure Media_Elementos (vec: in Vector; prom: in out Float) is acum: Float := 0.0; begin for I in 1..Maximo loop acum := acum + vec(I); end loop;

precipitacione

Sintaxis de ADA

15

prom := acum/Float(Maximo); end Media_Elementos; procedure Imprimo_resultados (vec: in Vector; prom: in Float) is begin Put("El promedio de los valores es: "); Put(prom, Aft=>2, Exp=>0); Put_Line("Valores mayores que el promedio:"); for I in 1..Maximo loop if vec(I) > prom then Put("Nro. " & Integer'image(I) & ": "); Put(vec(I), Aft=>2, Exp=>0); end if; end loop; end Imprimo_resultados; begin Leo_vector(Serie); Media_Elementos(Serie,Media); Imprimo_resultados(Serie,Media); end Vectores;

Cadenas (Strings) En Ada los strings son un tipo especial de array (no restringido) que está implicitamente definido en el paquete Standard. Por ser no restringidos debemos definir variables de tipo String fijando los límites del array explícitamente o implícitamente. Los literales de tipo String se encierran entre comillas dobles.

Declaración de variables subtype <nombre del subtipo> is String (1 .. < constante positivo>);

<nombre de variable> : <nombre del subtipo>;

<nombre del subtipo> - nombre del subtipo string que definimos.

<constante positivo> - este es el nombre de la constante que indica el

tamaño del string.

<nombre de variable> - nombre de la variable.

Ejemplos

subtype Nombre_Cliente is String (1 .. 15);--definimos un subtipo de

-- tipo String

Nombre : Nombre_Cliente := "Pepe García "; -- Inicialización

Direccion : String (1 .. 30);

Saludo: constant String := "Hola!"; --En la declaración de constantes -- se puede omitir la restricción

Sintaxis de ADA

16

Uso:

Nombre (4) := 'a'; -- Ahora Nombre es Pepa García

Nombre (1 .. 4) := "Jose"; -- Ahora Nombre es Jose García

Direccion := "Av. Kennedy"; -- Error: no tiene 30 caracteres!!

Problemas con String Al declarar una variable:

Direccion: String (1 .. 30);

no puedo asignarle una cadena de menor longitud:

Direccion := "Av. Kennedy"; --error Direccion := "Av. Kennedy "; -- debo completar hasta 30

Solución: Utilizando slices* (rebanada) puedo manejar la dimensión. Por ejemplo, un slice de la cadena anterior puede ser:

Direccion (1 .. 11) := "Av. Kennedy";

*Slice: recurso que provee Ada para hacer referencia a una parte de un array Ingreso de una cadena

Get_Line (Direccion, long_palabra);

En long_palabra queda almacenada la longitud de la cadena Direccion al momento de ser leída.

Operaciones Con Cadenas Concatenación &

put_line("Dir: " & Direccion (1..long_palabra));

Comparación =, /=, <, <=, >, >= Se aplica el orden lexicográfico elemento a elemento aunque tengan distintos límites S1(1..7):= "feriado"; S2(1..3):= "mes";

s1 > s2 -- TRUE o FALSE?? Al comparar el primer caracter de la cadena vemos que la f es anterior a la m por lo tanto la comparación resulta false Atributos para String

< Cadena >'first -- denota el limite inferior del rango del string < Cadena >'Last -- denota el limite superior del rango del string < Cadena >'Range -- devuelve el rango del string < Cadena >'Length -- devuelve la longitud fija del string

Conversión Entero / String

Integer'Image(entero); -- devuelve un entero como string

Integer'value(cadena); -- devuelve la cadena como entero

Sintaxis de ADA

17

--------------------------------------------------------------------- -------------- ejemplo de uso de cadenas en ADA ------------------ --------------------------------------------------------------------- with gnat.io;use gnat.IO; procedure Uso_string is subtype cadena is String(1 .. 15); cad1,cad2 : cadena:= (others => ' '); longitud: integer; saludo: constant string:= "hola"; -- esta cadena no se puede modificar begin Get_Line (cad1, longitud); --entrada de una cadena por consola

put (cad1 (1.. longitud)); --salida de una cadena indicando su rango

put (cad1); -- muestra la cadena de 1.. 15;

new_line; -- si no fue inicializada, muestra basura.

----- uso de slice ----------

cad2(2..4) := ('a','b','c'); -- conjunto de caracteres

cad2(1):= 'x'; -- un caracter

cad2(5..7):= "hoy"; -- un string, debe coincidir con el slice

cad2(8..11):= cad1(1..4); -- asignacion de slices

cad2(12..15) := (others => '*'); -- rellena con el carácter ‘*’

cad1:= cad2; -- es posible si tienen la misma longitud

if cad1(1) = 'a' then put_line("primer caracter de cad1 es a"); end if;

if cad1(1..2) = "ab" then put("cad1 comienza con la cadena ab"); end if;

end Uso_string;

Tipos compuestos: Registros Los record son estructuras heterogéneas: agregados de elementos (campos) del mismo o distintos tipos que se pueden acceder individualmente mediante su nombre. Un record se define con la palabra "record", seguida de la declaración de los campos del record y "end record".

Declaración de tipo registro type <nombre del tipo> is

record <nombre de campo 1> : <tipo de dato 1>;

<nombre de campo 2> : <tipo de dato 2>; … <nombre de campo N> : <tipo de dato N>; end record;

Sintaxis de ADA

18

Declaración de variables y constantes <nombre de variable> : <tipo de dato registro>; <nombre de constante>: constant <tipo de dato registro>:= ( <nombre de campo 1> => <valor campo 1> , <nombre de campo 2> => <valor campo 2>, … , <nombre de campo N> => <valor campo N>);

Ejemplo: type fecha is

record dia:integer range 1..31;

mes:string (1..10); anio:integer; end record;

nacimiento: fecha; fecha_fija: constant fecha:= (dia => 01, mes => "Enero", anio => 2000);

Se pueden especificar valores iniciales para los campos de un record en la propia definición del tipo.

type fecha is record dia:integer range 1..31; mes:string (1..10) := (others => ' '); anio:integer:=2007;

end record;

Para acceder a los campos de un registro se usa la clásica notación registro.componente: ... procedure Mostrar_fecha_nacimiento is nacimiento: fecha; begin nacimiento.dia := 17; nacimiento.mes := "Junio"; nacimiento.anio := 1980; -- ... Put_Line ("Su fecha de nacimiento es: " & integer’image(nacimiento.dia) & " de " & nacimiento.mes & " de " & integer’image(nacimiento.anio)); end Mostrar_fecha_nacimiento;

Los registros pueden ser manipulados como objetos completos. Además, es posible asignar valores a todos los componentes de un registro mediante un conjunto ordenado o desordenado.

1. agregado posicional: especificando los valores de todos los campos en el orden adecuado y entre paréntesis:

nacimiento := (17, "Junio", 1980 );

Sintaxis de ADA

19

2. agregado nominal: especificando los nombres de los campos junto con los valores:

nacimiento := (anio => 1980, mes => "Junio", dia => 17);

Cuando se usa un agregado nominal los campos se pueden enumerar en cualquier orden, pero siempre hay que enumerarlos a todos.

Registros discriminados

Es un tipo de dato para un uso muy restringido. Un registro discriminado tiene un componente discriminante, del que dependen otros tipos. A esa componente se la conoce como discriminante y tiene que ser de tipo discreto. Ejemplo: type TMatriz is array (Integer range <>, Integer range <>) of Float; type TMatrizCuadrada (Orden: Positive) is record Matriz: TMatriz(1..Orden,1..Orden); end record; De esta forma, se asegura que la matriz utilizada sea cuadrada. El primer componente (Orden) es el discriminante (de tipo discreto Positive) y el segundo componente (Matriz) es una matriz siempre cuadrada , cuyos límites dependen del valor de Orden. Por ejemplo, si se quiere declarar una matriz cuadrada de 3 X 3, podemos poner: M: TMatrizCuadrada(3); ó TMatrizCuadrada(Orden => 3); Una vez que se declara la variable ya no se puede cambiar su restricción. Sin embargo, si se declara lo siguiente: Max: constant := 100; subtype TIndice is Integer range 0..Max; type TVectorEnteros is array (Integer range <>) of Integer; type TPolinomio (N: TIndice := 0) is -- Discriminante con valor inicial. record Pol: TVectorEnteros(0..N); end record; Ahora, se pueden declarar variables que no tengan restricciones: P, Q: TPolinomio; El valor inicial de sus discriminantes sería cero (el valor por defecto de N). Así, se podría cambiar el discriminante posteriormente.

Sintaxis de ADA

20

Registro con Variante

Se pueden definir tipos record que puedan tener campos diferentes en función del valor de un discriminate discreto.

Declaración con parte variante

type <nombre del tipo> is (<valor 1> , <valor 2> , … , <valor N>); type <nombre del tipo> (<nombre del discriminante> : <nombre del tipo>) is

record

<nombre de campo 1> : <tipo de dato 1>; <nombre de campo 2> : <tipo de dato 2>; … <nombre de campo N> : <tipo de dato N>; case <nombre del discriminante> is

when <valor 1> => <nombre de campo 1.1>,…,<nombre de campo 1.N>: <tipo de dato>;

when <valor 2> => <nombre de campo 2.1>: <tipo de dato>; … when <valor N> => <nombre de campo 3.1>: <tipo de dato>; end case;

end record;

Ejemplo: type Figura is (Rectángulo, Círculo); type Polígono(Forma:Figura) is record --Forma es el discriminante Pos_X, Pos_Y: Float; case Forma is when Rectángulo => Base,Altura: Float; when Círculo => Radio: Float; end case; end record;

Cuando se declaren variables con parte variante se debe especificar obligatoriamente el valor del campo discriminante.

R: Polígono (Rectángulo);

Archivos de Entrada/Salida

Los archivos con los que se trabaje deben “abiertos”, y en esa instancia, debe especificarse el nombre lógico, el modo y la identificación del archivo físico en el soporte magnético en el que está almacenado.

o Mode es el modo de apertura (puede tomar los valores: "In_File", "Out_File", "Append_File").

Sintaxis de ADA

21

o In_File abre el archivo en modo lectura.

o Out_File abre el archivo en modo escritura (si el fichero ya existe, se vacía).

Ejemplo : Input_File : tipo_archivo;

Ejemplo : Open ( File => Archivo_entrada, Mode => In_File, Name => "c:\input.dat" );

Cualquier archivo que se procese debe ser cerrado

Ejemplo : Close ( File => Archivo_entrada);

Declaración de variable archivo <nombre de variable> : tipo_archivo; <nombre de variable>- Nombre de una variable declarada como nuestro archivo variable.

Abriendo un archivo de entrada Open ( File => <nombre de variable>, Mode => In_File, Name => "<nombre_externo del archivo >" ); <nombre de variable>- Nombre de la variable archivo. <nombre_externo del archivo> - Nombre del archivo en el disco.

Cerrando un archivo Close ( File => <nombre de variable>); <nombre de variable>- Nombre de la variable archivo.

Creando un archivo Create ( File => <nombre de variable >, Mode => Out_File, Name => "< nombre_externo del archivo >" ); <nombre de variable > Nombre de la variable archivo. <nombre_externo del archivo> - Nombre del archivo en el disco.

Sintaxis de ADA

22

Ejemplo : Create (File => archivo_salida, Mode => Out_File, Name => "c:\output.dat");

Entrada Simple Todo tipo de datos Get (File => <nombre de variable_archivo>, Item => <nombre de variable>); <nombre de variable_archivo>- Nombre de la variable archivo <nombre de variable> - Nombre de la variable.

Salida Simple Enteros Put (File => <nombre de variable_archivo>, Item => <nombre de variable>, Width => <numero entero>); <nombre de variable_archivo> - Nombre de la variable archivo. <nombre de variable> - Nombre de la variable . Width - Número de espacios que tomará la salida. Flotantes Put (File => <nombre de variable_archivo>, Item => <variable name>, Fore => <numero entero>, Aft => <numero entero>, Exp => <numero entero>); <nombre de variable_archivo>- Nombre de la variable archivo. <nombre de variable>- Nombre de la variable . Fore - Número de espacios a la izquierda del punto decimal. Aft - Número de espacios a la derecha del punto decimal. Exp - Número de espacios para el exponente. Caracteres y Strings Put (File => <nombre de variable_archivo>, Item => <nombre de variable>); <nombre de variable_archivo>- Nombre de la variable archivo. <nombre de variable>- Nombre de la variable . Put_Line (File => <nombre de variable_archivo>, Item => <variable name>); <nombre de variable_archivo> - Nombre de la variable archivo. <nombre de variable>- Nombre de la variable .

Sintaxis de ADA

23

Ejemplos : Entrada Simple Get (File => Input_File, Item => Name_Length); Get (File => Input_File, Item => Radius); Get (File => Input_File, Item => First_Initial); Get (File => Input_File, Item => Last_Name); Salida Simple Put (File => Output_File, Item => Name_Length, Width => 3); Put (File => Output_File, Item => Radius, Fore => 3, Aft => 2, Exp => 0); Put (File => Output_File, Item => First_Initial); Put (File => Output_File, Item => Last_Name); Put_Line (File => Output_File, Item => First_Initial); Put_Line (File => Output_File, Item => Last_Name);

Archivos secuenciales

Los elementos necesarios para manejar archivos secuenciales se encuentran en el paquete "Sequential_IO". with Ada.Sequential_IO;

Declaración Para poder usar archivos secuenciales se deben definir previamente el tipo de sus componentes

type TPersona is record Nombre : string(1..20); DNI : string(1..10); Edad : natural; end record;

Una vez definido el tipo, se definen instancias de los paquetes de manejo de archivos, según el tipo de acceso que se vaya a utilizar. package ArchTPersona_Sec is new Ada.Sequential_IO(TPersona); -- Acceso secuencial use ArchTPersona_Sec;

Ahora se pueden declarar variables de tipo archivo secuencial:

MiArchivo : ArchTPersona_Sec.tipo_archivo;

Sintaxis de ADA

24

Ejemplo : Create ( File => MiArchivo, Mode => Out_File, Name => "c:\ MiArchivo.dat" );

Ejemplo : Open ( File => MiArchivo, Mode => In_File, Name => "c:\ MiArchivo.dat" );

o Mode es el modo de apertura (puede tomar los valores: "In_File", "Out_File", "Append_File").

o In_File abre el archivo en modo lectura.

o Out_File abre el archivo en modo escritura (si el fichero ya existe, se vacía).

o Append_File abre un archivo secuencial en modo escritura para añadir información al final.

Ejemplo : Close ( File => MiArchivo);

Creación de archivo secuencial Create ( File => <nombre de variable >, Mode => Out_File, -- por defecto Name => "<nombre de archivo externo>" ); <nombre de variable > - el nombre de la variable archivo <external file name> - el nombre del archivo externo (físico).

Apertura de archivo secuencial Open ( File => <nombre de variable >, Mode => In_File, Name => "<nombre de archivo externo>" ); <nombre de variable > - el nombre de la variable archivo <external file name> - el nombre del archivo externo (físico).

Cierre de archivo secuencial Close ( File => < nombre de variable > ); <nombre de variable> - el nombre de la variable archivo.

Sintaxis de ADA

25

Otras funciones: End_Of_File(Archivo1) es una función que devuelve True si se ha alcanzado el final de Archivo1 y False en caso contrario. Is_Open(Archivo1) devuelve True si el archivo "Archivo1" está abierto y "False" en caso contrario. Mode(Archivo1) devuelve el modo en que ha sido abierto el archivo. Name(Archivo1) devuelve el nombre del archivo externo correspondiente a “Archivo1” (nombre lógico). Los errores que pudieran producirse al intentar abrir un archivo pueden controlarse mediante excepciones.

Operaciones de entrada/salida : Read y Write Read( File => < nombre de variable >, Item => < nombre componente>); <nombre de variable> - el nombre de la variable archivo. < nombre componente> Nombre del componente del archivo que se lee desde éste.

Write( File => < nombre de variable >, Item => < nombre componente>);

<nombre de variable> - el nombre de la variable archivo. < nombre componente> Nombre del componente del archivo que se graba en éste.