Programación en Ada/Sentencias y estructuras de control

• Simple:
  • Secuencial:
    • Nula (null).
    • Asignación (X := Y;)
    • Llamada a procedimiento.
    • Código.
    • Llamada a punto de entrada (entry). En procesamiento paralelo.
    • Espera (delay).
    • Terminación abrupta (abort). En procesamiento paralelo.
  • Control:
    • Terminación de bucle (exit).
    • Salto a etiquetas (goto). No recomendable.
    • Elevación de excepción (raise).
    • Retorno de subprograma (return).
• Compuesta:
  • Secuencial:
    • Bloque.
    • Sentencia if.
    • Sentencia case.
    • Bucle (loop).
  • Paralela:
    • Sentencia accept.
    • Sentencia select.

Ada distingue entre declaraciones, que introducen identificadores nuevos, y sentencias, que no lo hacen. El fragmento de texto más simple que incluye declaraciones y sentencias es un bloque.

bloque ::=
  [ identificador : ]
  [ declare
    parte_declarativa ]
  begin
    sentencias
  [ exception
    manejador_de_excepción
    { manejador_de_excepción } ]
  end [ identificador ] ;

-- Supuestas X e Y declaradas con anterioridad de tipo Float:
declare
  Temp: Float;  -- Esta variable solo es visible dentro del bloque.
begin  -- Se intercambian 2 variables.
  Temp := X;
  X := Y;
  Y := Temp;
end;

Destacar que un bloque es una sentencia y cuando se ejecuta se elaboran las declaraciones contenidas en su parte declarativa (entre declare y begin) y después se ejecutan las sentencias del cuerpo (entre begin y end).

El ámbito de las variables declaradas en un bloque finaliza cuando termina dicho bloque.

sentencia_selección ::=
  if condición then secuencia_de_sentencias
  [ { elsif condición then secuencia_de_sentencias } ]
  [ else secuencia_de_sentencias ]
  end if ;

with Ada.Text_Io,Ada.Integer_Text_Io;
use Ada.Text_Io,Ada.Integer_Text_Io;


procedure comptar_LA is
  cp,c: character;
  n: integer;  --declaramos las variables
begin
  Put("Escribe una frase");  --pedimos y recogemos texto
  Put(c);
  n := 0;   --inicializamos n a cero
  cp := ' ';
  get(c); --si cp es espacio seguir leyendo
  while c /= '.' loop  --mientras c sea diferente del PUNTO, entrar en bucle
    if cp = 'L' and c = 'A' then     
       n := n+1;
    end if; -- si cp es L y c es A incrementar n y finalizar el if
    cp := c; 
    Get(c); --igualamos cp a c para proceder y c sigue al próximo caracter
  end loop; --FINALIZAMOS BUCLE
  Put("El numero de palabras de la frase es"); --enseñamos en pantalla la variable n
  Put(n);
end comptar_LA;

if Hoy = DOM then  -- Si hoy es domingo.
  Mañana := LUN;
elsif Hoy /= SAB then  -- Si no es domingo ni sábado.
  Laborable := True;
else  -- Cualquier otro caso.
  Mañana := TDía'Succ(Hoy);
end if;

sentencia_selección_por_casos ::=
  case expresión is
    alternativa_caso { alternativa_caso }
  end case ;

alternativa_caso ::=
  when elección { | elección } => secuencia_de_sentencias
elección ::= expresión_simple | rango_discreto | others

case Hoy is
  when MIE..VIE => Entrenar_duro;  -- Rango.
  when MAR | SAB => Entrenar_poco;  -- Varias elecciones.
  when DOM => Competir;  -- Una elección.
  when others => Descansar;  -- Debe ser única y la última alternativa.
end case;

sentencia_bucle_simple ::=
  [ identificador_bucle : ] loop
    secuencia_de_sentencias
  end loop [ identificador_bucle ] ;

Vida: loop  -- El bucle dura indefinidamente.
  Trabajar;
  Comer;
  Dormir;
end loop Vida;

Este bucle sólo se puede abandonar si alguno de los procedimientos levanta una excepción.

El bucle simple a menudo se acompaña de una sentencia exit para abandonar el bucle cuando se cumple una condición.

loop
  Alimentar_Caldera;
  Monitorizar_Sensor;
  exit when Temperatura_Ideal;
end loop;

sentencia_bucle_iterativo ::=
  [ identificador_bucle : ] for parámetros_for loop
    secuencia_de_sentencias
  end loop [ identificador_bucle ] ;

parámetros_for ::= identificador in [ reverse ] rango_discreto

for I in 1..N loop  -- I se itera desde 1 hasta N.
  V(I) := 0;
end loop;

Se desea desplegar los números del 10 al 1 de forma descendente

procedure bloque_para_inverso is
   i : Integer;
begin
   i := 0;
   for i in reverse 1..10 loop
       Put(i, 0);
       Put(" ");
   end loop;
end bloque_para_inverso;

Si bien Ada no acepta rangos en el for, estos se puede hacer mediante cálculos. Se desea mostrar los números pares comprendidos entre 1 y 10.

procedure bloque_para_inverso is
   i : Integer;
begin
   i := 0;
   for i in 0..5 loop
       Put(i*2, 0);
       Put(" ");
   end loop;
end bloque_para_inverso;

sentencia_bucle_iterativo ::=
  [ identificador_bucle : ] while condición loop
    secuencia_de_sentencias
  end loop [ identificador_bucle ] ;

I := 1;
while I > N loop  -- Se hace el bucle mientras se cumpla la condición.
  V(I) := 0;
  I := I + 1;
end loop;

Antes de nada, decir que la utilización de sentencias goto se desaconseja totalmente. Ada posee estructuras de control adecuadas para evitar su uso. Si se soporta su utilización es por si se quiere traducir de otro lenguaje a Ada automáticamente.

Se especifica una etiqueta entre los símbolos << y >>, por ejemplo, <<Salto>>.

Se realiza el salto a dicha etiqueta con la sentencia goto Salto; que transferiría el control a la siguiente sentencia después de la etiqueta.

No puede usarse para transferir control fuera de un subprograma.

Termina el bucle nombrado en la sentencia o, si no aparece, el bucle más próximo que la contiene. Su notación sintáctica es:

sentencia_exit ::= exit [ nombre_bucle ] [ when condición ] ;

Termina la ejecución del subprograma más próximo que la contiene, tanto en procedimientos como en funciones donde, además, se utiliza para devolver el resultado de dicha función. Su notación sintáctica es:

sentencia_return ::= return [ expresión ] ;

Se utiliza solo para tareas. Implica la terminación incondicional de las tareas que se especifiquen. Su notación sintáctica es:

sentencia_abort ::= abort nombre_tarea { , nombre_tarea } ;

• Section 5: Statements