Teoría de los lenguajes de programación

Borrador: arreglos unidimensionales

Ignacio Trejos Zelaya, Tecnológico de Costa Rica, circa 2002

Presentamos a continuación tres variantes de arreglos que podrían incluirse en un lenguaje de

programación imperativo. Las variantes son:
1. arreglos no inicializados
2. arreglos inicializados en un solo valor escalar (* pendiente *)
3. arreglos inicializados en un valor-arreglo (* pendiente *)

En todos los casos los arreglos se subindizan con valores entre los naturales, a partir de 1. Es
posible también hacer definiciones que incluyan declaración de cotas inferior y superior, típos
índice distintos de los naturales, etc.

Como definitivamente Word no fue concebido para escribir textos matemáticos, escribiremos
los nombres de juicios así =nombre⇒ ...

1. Arreglos no inicializados

El dominio de valores debe ser extendido, de manera que comprenda un valor indefinido,
distinto tanto de los enteros como de los booleanos. Loc son las ubicaciones. A continuación
los dominios semánticos.

Val :: = Booleanos | ℤ
Val :: = Val | {indefinido}
Asociables :: = Booleanos | ℤ | Loc
Arreglo = = ℤ © Loc
Mem = = Loc © (Val | arr Arreglo)
Amb = = Id © Asociables

1.1 Cambios en la sintaxis

En los comandos podrá ponerse var : = exp donde antes podía ponerse id : = exp.

La sintaxis de var es:

var :: = id | id [exp]

En los comandos podremos tener ahora la asignación a un elemento de arreglo:

var : = exp

En las declaraciones se puede declarar un arreglo sin inicializar:

t array [exp] id (* es como id : array [exp] of t *)

Los arreglos se subindizan a partir de 1.

1
1.2 Semántica operacional

1.2.1 Definición del arreglo

A las declaraciones debemos añadir una nueva regla, que asocia la variable id con una celda
compuesta, cuya ubicación es l y su contenido es una celda compuesta (arreglo). La cota
inferior es 1 y la superior es valmax.

r, s |- exp =e⇒ valmax

s.m, ∅, 1 |- valmax =arr⇒ m’, arreglo
l ´ dom m’
---------------------------------------------------------------------------
r, s |- t array [exp] id =d⇒ {id ↦ l}, s ⊕ (ÏÐ, ÏÐ, m’ ⊕ {l ↦ arr arreglo})

Se añade un juicio _ |- _ =arr⇒ _ para dar contenido (indefinido inicialmente) a cada celda
que es parte del arreglo y asociar un índice (elem) con cada celda componente. Esto se hace
para los valores comprendidos entre 1 y valmax.

elem ≤ max
l ∉ dom m
m ⊕ {l ↦ indefinido}, arreglo ⊕ {elem ↦ l}, elem+1 |- max =arr⇒ m’, arreglo’
---------------------------------------------------------------------------
m, arreglo, elem |- max =arr⇒ m’, arreglo’

elem > max

---------------------------------------------------------------------------
m, arreglo, elem |- max =arr⇒ m, arreglo

1.2.2 Acceso “a la izquierda”

Introducimos un nuevo juicio para el acceso a variables al lado izquierdo de una asignación.
Recordar que en ese contexto id [exp] denotará una ubicación, lo que nos permitirá modificar
su contenido en una asignación.

r, s |- id =l⇒ l
r, s |- exp =e⇒ elem
s.m (l) = arr arreglo
elem ∈ dom arreglo
l’ = arreglo (elem)
---------------------------------------------------------------------------
r, s |- id [exp] =var⇒ l’

2
 r, s |- id =l⇒ l
s.m (l) ∈ Val
---------------------------------------------------------------------------
r, s |- id =var⇒ l

1.2.3 Acceso “a la derecha” (expresiones)

Estas reglas deben ser añadidas al juicio =e⇒ de expresiones. Tenemos dos casos: el acceso
a un elemento del arreglo y el acceso a una variable escalar.

r, s |- id [exp] =var⇒ l
v = s.m (l)
---------------------------------------------------------------------------
r, s |- id [exp] =e⇒ v

r, s |- id =var⇒ l
s.m (l) ∈ Val
v = s.m (l)
---------------------------------------------------------------------------
r, s |- id =e⇒ v

1.2.4 Comandos

La descripción original de la asignación también debe ser modificada. Por énfasis ponemos
inicialmente dos reglas.

r, s |- exp =e⇒ v
r, s |- id =var⇒ l
---------------------------------------------------------------------------
r, s |- id : = exp =c⇒ (s.i, s.o, s.m ⊕ {l ↦ v})

r, s |- exp’ =e⇒ v
r, s |- id [exp] =var⇒ l
---------------------------------------------------------------------------
r, s |- id [exp] : = exp’ =c⇒ (s.i, s.o, s.m ⊕ {l ↦ v})

Sin embargo, lo anterior puede ser explicado mediante una sola regla (donde var es una meta-
variable que corresponderá a algo de forma id o id [exp]):

3
 r, s |- exp =e⇒ v
r, s |- var =var⇒ l
---------------------------------------------------------------------------
r, s |- var : = exp =c⇒ (s.i, s.o, s.m ⊕ {l ↦ v})

1.3 Introducción de cotas

Podríamos introducir una forma sintáctica en la cual se permitan declarar las cotas del arreglo.
Por ejemplo:
t array [exp1 .. exp2] id (* es como id : array [exp1..exp2] of t *)

La definición del arreglo ahora debe tomar en cuenta que el valor correspondiente a exp1 (val1)
sea mayor que el que corresponda a exp2 (val2). Además, los índices deberán comenzar en
val1 y terminar en val2.

r, s |- exp1 =e⇒ val1

r, s |- exp2 =e⇒ val2
val1 ≤ val2
s.m, ∅, val1 |- val2 =arr⇒ m’, arreglo
l ´ dom m’
---------------------------------------------------------------------------
r, s |- t array [exp1 .. exp2]id =d⇒ {id ↦ l}, s ⊕ (⟨⟩,⟨⟩, m’ ⊕ {l ↦ arr arreglo})

Todas las demás reglas expuestas en la sección anterior quedan igual.