Sintaxis de Ada 

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 >;

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;

1
 Sintaxis de Ada 

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 >;

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;

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 >;

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

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;

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.
Tipos de datos, variables y constantes

Ejemplos :
Letra_Inicial : Character;
Apellido : String(1..15);
Longitud_nombre : Integer;
Radio : Float;
Pi : constant Float := 3.1416;
Sentencia de Asignación
<nombre de variable> := <expresion>;
<expresion> - alguna fórmula matemática

Ejemplo :
Area := Pi * Radio ** 2;
3
 Sintaxis de Ada 

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

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

4
 Sintaxis de Ada 

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

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

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

5
 Sintaxis de Ada 

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.

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

6
 Sintaxis de Ada 

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

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.

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;

7
 Sintaxis de Ada 

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 .

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) : ");
8
 Sintaxis de Ada 

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;

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

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;

9
 Sintaxis de Ada 

Subprogramas
En Ada, los subprogramas se dividen en dos categorías: procedimientos y funciones.
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

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.

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 ]

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.
10
 Sintaxis de Ada 

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

11
 Sintaxis de Ada 

Arreglos en Ada
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.

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:

precipitacione

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

temperaturas

12
 Sintaxis de Ada 

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

notas

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
Finales_aprobadoos

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

precipitacione
„ 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

precipitacione

13
 Sintaxis de Ada 

„ 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

precipitacione

2) Entrada y salida
--Entrada --Salida
Get (<variable_tipo_arreglo>(<indice>)); 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;

14
 Sintaxis de ADA
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

15
 Sintaxis de ADA

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

16
 Sintaxis de ADA

---------------------------------------------------------------------
-------------- 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;

17
 Sintaxis de ADA

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

18
 Sintaxis de ADA

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.

19
 Sintaxis de ADA

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").

20
 Sintaxis de ADA

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

Declaración de variable archivo

<nombre de variable> : tipo_archivo;

<nombre de variable>- Nombre de una variable declarada como nuestro archivo variable.

Ejemplo :
Input_File : tipo_archivo;

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.

Ejemplo :

Open ( File => Archivo_entrada,

Mode => In_File,
Name => "c:\input.dat" );

Cerrando un archivo

Close ( File => <nombre de variable>);

<nombre de variable>- Nombre de la variable archivo.

Cualquier archivo que se procese debe ser cerrado

Ejemplo :

Close ( File => Archivo_entrada);

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.

21
 Sintaxis de ADA

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 .

22
 Sintaxis de ADA

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;

23
 Sintaxis de ADA

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

Ejemplo :

Create ( File => MiArchivo,

Mode => Out_File,
Name => "c:\ MiArchivo.dat" );

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

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.

Cierre de archivo secuencial

Close ( File => < nombre de variable > );

<nombre de variable> - el nombre de la variable archivo.

Ejemplo :

Close ( File => MiArchivo);

24
 Sintaxis de ADA

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.

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

25