Lenguaje de la Materia

Se utiliza un lenguaje inventado específicamente para la materia, que nos permite definir procedimientos y funciones.

Procedimientos

Un procedimiento encapsula un bloque de código con su respectiva declaración de variables (que define el estado).

\begin{aligned} &\proc \; nombre(< \bfin | \out | \inout > p_1 : T_1, \; \ldots, \; < \bfin | \out | \inout > p_n : T_n) \\ &\quad < \textnormal{declaraciones de variables} > \\ &\quad < \textnormal{sentencias} > \\ &\bfend \; \proc \\ \end{aligned}

Donde $p_1, \; \ldots, \; p_n$ son nombres de variables (parámetros) y $T_1, \; \ldots, \; T_n$ sus respectivos tipos.

Entrada/salida de parámetros:

$\bfin$ es el parámetro de entrada (no modificable)
$\out$ el parámetro de salida.
$\inout$ el parámetro de entrada/salida.

Un ejemplo de declaración de procedimiento es el siguiente:

\begin{aligned} &\proc \; abs(\bfin \; x : \intt, \; \out \; y : \intt) \\ &\quad \if \; x >= 0 \; \then \\ &\quad \quad y := x \\ &\quad \else \\ &\quad \quad y := -x \\ &\quad \fi \\ &\bfend \; \proc \\ \end{aligned}

Un ejemplo de llamada de este procedmiento puede ser:

\begin{aligned} &\proc \; llamadordeabs() \\ &\quad \var \; a, b : \intt \\ &\quad a := -10 \\ &\quad \else \\ &\quad abs(a,b) \\ &\quad \{- \;\; b = 10 \;\; -\} \\ &\bfend \; \proc \\ \end{aligned}

Observaciones:

Los procedimientos no devuelven cosas (pero pueden escribir varios parámetros $\out$ ).
Las llamadas a estos son sentencias del lenguaje.

Funciones

Las funciones son como procedimientos salvo que todos los parámetros son $\bfin$ y devuelven algo.

\begin{aligned} &\fun \; nombre(p_1 : T_1, \; \ldots, \; p_n : T_n) \; \ret \; r : T \\ &\quad < \textnormal{declaraciones de variables} > \\ &\quad < \textnormal{sentencias} > \\ &\bfend \; \fun \\ \end{aligned}

Donde $p_1, \; \ldots, \; p_n$ y $r$ son nombres de variables (parámetros) y $T_1, \; \ldots, \; T_n$ sus respectivos tipos.

Un ejemplo de declaración de función es el siguiente:

\begin{aligned} &\fun \; abs(\bfin \; x : \intt) \; \ret \; y : \intt \\ &\quad \if \; x >= 0 \; \then \\ &\quad \quad y := x \\ &\quad \else \\ &\quad \quad y := -x \\ &\quad \fi \\ &\bfend \; \fun \\ \end{aligned}

Y un ejemplo de llamada es:

\begin{aligned} &\proc \; llamadordeabs() \\ &\quad \var \; a, b : \intt \\ &\quad a := -10 \\ &\quad b := 35 \\ &\quad b := abs(a) \\ &\quad a := abs(a) + 10 \\ &\quad \{- \;\; b = 10, \; a = 20 \;\; -\} \\ &\bfend \; \proc \\ \end{aligned}

Observaciones sobre funciones:

No hay sentencia return. Se devuelve lo que sea asignado a la variable declarada como $\ret$ . La variable se puede usar libremente en el cuerpo de la función (se puede leer, asignar varias veces, etc.).
Las llamadas a funciones no son sentencias, son expresiones (e.g. se puede usar en la parte derecha de una asignación, en una guarda, etc).
Las funciones no tienen efectos colaterales en el estado. Una función no puede escribir las variables correspondientes a los parámetros.

Observaciones generales:

Cada función y procedimiento define un estado propio llamado “contexto”. Las variables declaradas dentro de funciones y procedimientos no existen fuera de éstas.
Cualquier función o procedimiento pueden llamar a cualquier otra función o procedimiento. Incluso pueden llamarse a sí mismas (recursión), y también mutuamente (recursión mutua).
No importa el orden en que se declaran, un procedimiento puede llamar a otro que esté definido más adelante.
No se pueden definir procedimientos ni funciones dentro de procedimientos o funciones (no hay anidamiento, todas las definiciones están al mismo nivel).

Tipos Nativos

Los tipos nativos son los tipos que trae predefinido el lenguaje de programación.

Tipos básicos:

$\bool$ : booleanos ( $True$ y $False$ )
$\intt$ : enteros
$\nat$ : naturales (con el $0$ )
$\real$ : reales
$\char$ : caracteres ( $\textnormal{'} a \textnormal{'}$ )
$\string$ : secuencias de caracteres ( $\textnormal{"string"}$ )

Se utilizan constantes que sirven como infinito/-infinito, etc.

Tipos estructurados:

$\array$ : arreglos
$\pointer$ : punteros

Expresiones

Expresiones válidas en programación imperativa:

valores constantes
variables y constantes declaradas
operaciones básicas $(+, -, *, /, \textnormal{div}, \textnormal{mod}, \textnormal{max}, \textnormal{min}, \land, \lor, \neg, =, \not=, \leq, <, >)$
accesos a elementos de arreglos
llamadas a funciones

Sentencias

Skip

Utilizamos $\skip$ para no hacer nada.

Asignación

La sintaxis es: $v := E$ donde $v$ es variable y $E$ expresión. No se utiliza la asignación múltiple en este lenguaje

Llamada a procedimiento

Llamamos los procedimientos como $nombreproc(e_1, \ldots, e_n)$

Condicional

Utilizamos $\if, \; \then, \; \else$ de las siguientes maneras:

\begin{aligned} &\if \; B \; \then \\ &\quad S_1 \\ &\else \\ &\quad S_2 \\ &\fi \end{aligned}

O también, sin el $\else$

\begin{aligned} &\if \; B \; \then \\ &\quad S \\ &\fi \end{aligned}

Donde $B$ es una guarda y expresión booleana, y $S, S_1, S_2$ sentencias.

Repetición

Utilizamos $\while, \; \do$ :

\begin{aligned} &\while \; B \; \do \\ &\quad S \\ &\od \end{aligned}

Donde $B$ es una guarda y expresión booleana, y $S$ una sentencia.

Otras repeticiones, for to, for downto

Sintaxis de $\for \; \too$ :

\begin{aligned} &\for \; i:=N \; \too \; M \; \do \\ &\quad S \\ &\od \end{aligned}

Donde $N$ y $M$ son expresiones de tipo $\intt$ y $S$ es sentencia.

Su semántica es la siguiente:

Se declara la variable $i$ (sólo exisitirá dentro de la sentencia $S$ )
Se le asigna a $i$ el valor $N$
Se ejecuta $S$
Se incrementa $i$ en $1$
Si $i > M$ termina, si no vuelve al punto 3.
$i$ deja de existir al terminar.

Sintaxis de $\for \; \downto$ :

\begin{aligned} &\for \; i:=N \; \downto \; M \; \do \\ &\quad S \\ &\od \end{aligned}

Donde $N$ y $M$ son expresiones de tipo $int$ y $S$ es sentencia.

Su semántica es igual a $\for \; \too$ pero restando $1$ .

Observaciones:

No hace falta declarar el $i$ (el $\for$ ya lo declara)
Si había otra variable $i$ afuera, esta $i$ la tapa.
No se puede modificar $i$ con asignaciones en el cuerpo del ciclo ( $S$ )
No agrega expresividad al lenguaje (todo se puede hacer con $\while$ ).
itera desde $N$ hasta $M$ inclusive

Un ejemplo de $\for \; \too$ podría ser:

\begin{aligned} &\var \; precios : \array [1..100] \; \of \; \intt \\ &\for \; i:=1 \; \too \; 100 \; \do \\ &\quad precios[i] := 0 \\ &\od \end{aligned}

Y para $\for \; \downto$ ,

\begin{aligned} &\var \; precios : \array [1..100] \; \of \; \intt \\ &precios[100] := 35 \\ &\for \; i:=99 \; \downto \; 1 \; \do \\ &\quad precios[i] := precios[i+1] * 2 \\ &\od \end{aligned}

Secuenciación

No hay secuenciación explícita como en Algoritmos 1, basta con poner una sentencia después de otra.