Comentarios:
(***********************
* comentario de programa
************************)

(========================
* comentario de sección
=========================)

(*-- comentario de orden --*)

(* comentario al margen *)

Constantes:
CONST Nombre= valor;

Variables:
VAR Nombre : Tipo;

Secuencia:
Secuencia ::= sentencia;

Tipos:
TYPE declaracion = Tipo;

Tipos Enumerados:
TYPE nombre_Tipo = Indentificadores;

Tipos Subrango:
TYPE rango_Tipo = Tipo [Valor inicial .. valor final];

Tipos conjunto:
TYPE tipo_Conjunto = SET OF Tiporeferencial;

Funciones:

• La función devuelve un valor determinado

PROCEDURE Nombre (Argumento:Tipo;... ); Tipo_Resultado
BEGIN
Sentencias;
END Nombre;

• Para invocar una función se escribe su nombre y, entre paréntesis, los valores concretos de los argumentos separados por comas.

Procedimientos:

• El procedimiento NO devuelve ningún valor determinado

PROCEDURE Nombre (Argumento:Tipo;... );
BEGIN
Sentencias;
END Nombre;

• Para invocar un procedimiento se escribe su nombre y, entre paréntesis, los valores concretos de los argumentos separados por comas. Se puede dar el caso que no tenga argumentos, si es así, sólo se escribe el nombre

Paso de argumentos:

• Vale tanto para funciones como para procedimientos.

• Por Valor:

PROCEDURE Nombre (Argumento:Tipo;... );
BEGIN
Sentencias;
END Nombre;

• Por Referencia:

PROCEDURE Nombre (Argumento:Tipo;... );
BEGIN
Sentencias;
END Nombre;

Estructura de un programa completo:
MODULE nombre_programa;
FROM lista_importaciones;

CONST lista_constantes;
TYPE lista_tipos;
VAR lista_variables;
PROCEDURE nombre_proce;
BEGIN
sentencias;
END nombre_proced;

BEGIN
sentencias;
END nombre_programa.

Vectores:
TipoVector = ARRAY Tipo_Indice OF Tipo_Elemento

• Acceder: nombre_vector[i]

Matrices:
TipoMatriz = ARRAY Tipo_Indice1, TipoIndice2,... OF
Tipo_Elemento

• Acceder: nombre_matriz[i,j] ó nombre_matriz[i][j]

Vector Abierto:
PROCEDURE ejemplo (X: ARRAY OF Tipovector)

• Si es CHAR es así, si es de otro tipo tiene que llevar VAR

Registros:
RECORD
nombre : TIPO;
(Puede ir las variantes que sean);
nombre : TIPO;
END;

• ACCEDER: nombre_registro.campo; o con WITH

Punteros:
TYPE Tipo_Puntero = POINTER TO Tipo_de_Variable;

Variables Dinámicas:

ALLOCATE (puntero,tamaño);
DEALLOCATE (puntero,tamaño);

Sentencia IF:

• Consiste en evaluar la expresión de condición y a continuación ejecutar la 'sentencia1' si se cumple la condiciín, y la 'sentencia2' si no.

IF condicion THEN
sentencia1
ELSE
sentencia2
END;

Sentencia WHILE:

• Significa que mientras la expresión condición resulta cierta, se ejecuta la acción de forma repetitiva. Si la condición es falsa desde la primera evaluación, no se ejecuta nunca.

WHILE condicion DO
sentencia
END;

Sentencia FOR:

• La condición de la iteración se limita a comprobar si se ha alcanzado el límite correspondiente al número de repeticiones previstas

FOR valor inicial TO valor final [BY +1]
DO
sentencia
END;

Sentencia RETURN:
RETURN expresion;

Sentencia REPEAT:

• Es aconsejable su uso si existe al menos una iteración y con WHILE se tienen que forzar las condiciones para que la iteración se produzca

REPEAT
sentencias
UNTIL
condicion

Sentencia LOOP y EXIT:

• Exit es incondicional y sale del bucle. SOLO actúa dentro de un LOOP.

LOOP
sentencias
EXIT
END;

Sentencia CASE:
CASE valor OF
valor1: accion1|
valor2: accion2|
valor3: accion3|
ELSE
accion por defecto
END;

Sentencia WITH:
WITH registro DO
secuencia_de_sentencias;
END;

• Evitas tener direcciones muy largas con los registros que te pueden liar.

Módulo de Definición:
DEFINITION MODULE Nombre;
...lista de importaciones...
...definiciones...
END Nombre.

Módulo de Implementación:
IMPLEMENTATION MODULE Nombre;
...lista de importaciones...
...definiciones...
BEGIN
...sentencias de inicializacion
END Nombre.