RPG

HISTORIA DE RPG
El lenguaje de programación RPG es un lenguaje de programación desarrollado por IBM en 1964 y diseñado para generar informes comerciales o de negocios. Sus siglas en inglés significan Report Program Generator.
En 1960 RPG es creado para la familia 1400, pero hasta 1964 no es lanzada la versión final para la IBM 360. Ha sido actualizado en diversas ocasiones, dando origen a las diferentes versiones del lenguaje. Una de las últimas actualizaciones que se ha realizado hasta la fecha es el RPG/IV en 1995, disponible con los ordenadores IBM de la familia AS/400. Posteriormente, en 2001, y con la aparición de la versión 5 del OS/400, surgió una nueva modificación sobre el lenguaje, soportándose a partir de ese momento la programación en formato libre. Así mismo, se desarrollan las funciones incoporadas que sustituyen a muchos de los antiguos indicadores y códigos de operación. Todas estas incorporaciones permiten que el RPG se convierta en un lenguaje mucho más legible, claro, flexible .

RPG es, probablemente, el lenguaje de programación más extendido en nuesto entorno (AS/400, iSeries e i5). Como heredero directo de la familia de ordenadores S/3x de IBM, y dada la política de compatibilidad con versiones anteriores seguida por IBM (gracias a la cual, programas diseñados para ejecutarse en un S/34 hace aproximadamente 20 años, continúan ejecutándose sin problemas en los modernos i5), RPG se ha convertido en el lenguaje por excelencia para los ordenadores de la gama AS/400, iSeries e i5.
Poco, o nada, queda ya del antiguo RPG II, con su ciclo lógico, sus rupturas por nivel de control (cabecera, detalle y totales), su absoluto control por medio de indicadores, etc. Y pocos lenguajes habrán experimentado una transformación tan importante en los últimos años como RPG.
Actualmente RPG es un lenguaje orientado a la gestión, con absoluta integración con bases de datos relacionales (DB2), que soporta SQL embebido, permite la ejecución de módulos diseñados en otros lenguajes (dentro del entorno integrado de lenguajes de IBM - ILE o Integrated Language Environment-), puede ser invocado por métodos Java, C, C++, etc.
Así pues, y después de describir brevemente el origen y la situación actual de RPG, pasaremos a analizar un poco más a fondo el lenguaje de programación y su estructura. Para ello, nos centraremos en la estructura y sintaxis de RPG/IV.
La estructura de un programa RPG está organizada por tipos de especificaciones (o instrucciones). En un programa RPG, encontraremos habitualmente, cuatro tipos de especificaciones:
1.- Especificaciones de Control: Irán siempre al inicio del programa, y en ellas indicaremos algunos parámetros generales de definición del programa.
2.- Especificaciones de definición de ficheros: Van inmediatamente detrás de las especificaciones de control y en ellas definiremos todos los ficheros, tanto de base de datos como de dispositivos (pantalla, impresora, etc.) que utilizará nuestro programa, así como el tipo de utilización de los mismos (Entrada, Salida, Entrada/Salida) , forma de acceso (secuencial, por claves, etc.) y otra serie de valores relativos a dichos ficheros y cómo nuestro programa manejará los mismos.
3.- Especificaciones de descripción de datos: En ellas describiremos todos aquellos datos adicionales (no incluidos en ficheros), tales como variables de programa, series, punteros, estructuras de datos, etc.
4.- Especificaciones de cálculo: Son las instrucciones ejecutables propiamente dichas. En ellas definiremos tanto las instrucciones de control de flujo del programa como las operaciones matemáticas, de acceso a datos, de lectura y escritura en ficheros y dispositivos, llamadas a otros programas o procedimientos, etc.

Historia de FORTRAN
Estrictamente hablando, FORTRAN no fue el primer
lenguaje de programación que existió (Laning & Zierler, del
MIT, ya tenían un compilador de un lenguaje algebraico en
1952), pero sí fue el primero en atraer la atención de una
parte importante de la reducida comunidad de usuarios de
computadoras de la época.

El desarrollo de FORTRAN comenzó en 1955 y el lenguaje se
liberó finalmente en abril de 1957, después de 18 años-hombre
de trabajo.
FORTRAN (FORmula TRANslating system) fue
desarrollado principalmente por John Backus en IBM. Backus
recibió el “Turing Award” en 1977.

El principal énfasis de FORTRAN fue la eficiencia. Su diseño
se basó en un intérprete llamado “Speedcoding”, que fue
desarrollado por Backus para la IBM 701.
FORTRAN fue desarrollado inicialmente en una IBM 704,
aprovechando sus rutinas de punto flotante (proporcionadas
en hardware).
La especificación preliminar de FORTRAN fue recibida con
frialdad y escepticismo. Pocos creían que pudiera diseñarse un
compilador que fuese equiparable (en eficiencia) a un humano.
John Backus fue fuertemente criticado incluso por luminarias
de la época como John von Neumann, quienes creían que el
desarrollo de FORTRAN sólo era un desperdicio de dinero
(el proyecto estuvo a punto de ser cancelado).
El secreto del éxito de FORTRAN se atribuye a su excelente
documentación y a las sofisticadas técnicas de optimización
que se usó en el diseño de su compilador. De acuerdo a John
Backus, las técnicas utilizadas en FORTRAN no fueron
superadas sino hasta los 1960s.
En 1958 se liberó FORTRAN II.
Otro dialecto, llamado FORTRAN III, fue liberado
también en 1958, pero no resultó muy exitoso debido a su
enorme dependencia de la IBM 704.
En 1962 se liberó FORTRAN IV, que ha sido quizás la
versión más popular del compilador.

En 1958, el American National Standards Institute (ANSI)
estandarizó FORTRAN (a esta versión se le llama ANS
FORTRAN).
Un nuevo estándar fue liberado en 1977 (se le conoce como
FORTRAN 77).
Las versiones más recientes de FORTRAN (FORTRAN
90 y FORTRAN 2 000)difieren mucho del lenguaje
original.
Estructura de los FORTRAN

programas en Los programas en FORTRAN se dividen en 2 partes:
1) Una parte declarativa, la cual describe las áreas de
datos, sus longitudes (tipos) y sus valores iniciales. Las
instrucciones declarativas existen en la mayor parte de
los lenguajes estructurados, aunque se les llama de
maneras distintas. En FORTRAN se les denomina
“sentencias no ejecutables”.
Estructura de los
programas en FORTRAN
2) Una parte imperativa que contiene los comandos
a ser ejecutados en el momento en que corre un
programa. A las instrucciones imperativas de
FORTRAN se les denomina “sentencias
ejecutables”.
Parte declarativa
de un programa
La parte declarativa del programa realiza 3 funciones
principales:
1) Asignar un área de memoria de un tamaño
especificado. Los tipos de datos disponibles en
FORTRAN son: INTEGER, REAL, DOUBLE
PRECISION y arreglos. El tipo de las variables
numéricas suele considerarse REAL por omisión.
Parte declarativa
de un programa
2) Asociar un nombre simbólico a un área
específica de memoria (a esto se le llama “binding”
o declaración de variables).
3) Inicializar el contenido de esa área de memoria.
En el caso de FORTRAN, las variables no tienen
que ser inicializadas. Esto suele ser una fuente
común de errores en FORTRAN.
Parte declarativa
de un programa
Ejemplo de una declaración:
DIMENSION MIARREGLO(100)
Esto inicializa el arreglo MIARREGLO a 100 posiciones de
memoria (se presuponen números reales por omisión).
Parte declarativa
de un programa
Ejemplo de inicialización:
DATA MIARREGLO, MIVAR/100*0.0,5.0
Esto inicializa las 100 posiciones del arreglo MIARREGLO a
0.0. Adicionalmente, inicializamos la variable MIVAR a
5.0.
Parte imperativa de un programa
Las sentencias imperativas son de 3 tipos diferentes:
1) Sentencias computacionales: Son análogas a las
operaciones aritméticas y de movimiento de datos del
pseudo-código que vimos anteriormente. La asignación
es la sentencia computacional más importante de
FORTRAN.
Parte imperativa de un programa
2) Sentencias de control de flujo: Comparaciones y
ciclos. FORTRAN proporciona instrucciones
condicionales (sentencias IF), ciclos (usando DO) y
saltos incondicionales (usando GOTO). El lenguaje
tiene sentencias muy primitivas para flujo de datos.
Parte imperativa de un programa
Sentencias de entrada/salida: FORTRAN I tenía 12
sentencias de entrada/salida de un total de 26 del lenguaje.
La razón era la enorme variedad de dispositivos de E/S que
debía ser capaz de manejar el compilador. Las versiones más
recientes de FORTRAN han reducido y/o simplificado la
necesidad de usar tantas sentencias de E/S.
Parte imperativa de un programa
Ejemplo de asignación:
RESULTADO = TOTAL/FLOAT(N)
Note que en este caso, FLOAT se usa para
convertir N (presumiblemente una variable entera)
a un valor real, de manera que el resultado de la
operación sea un número de punto flotante.
Parte imperativa de un programa
¿Qué otro lenguaje conoce donde deba hacerse una
reducción de tipo (casting) similar a ésta?
Es importante recordar que el uso de notación algebraica
convencional fue una de las principales contribuciones de
FORTRAN.

Notación algebraica
Un ejemplo de notación algebraica en FORTRAN es el
siguiente:
RESULTADO = A*B+C-9.0/D**3.4

Operadores aritméticos
en FORTRAN

Funciones matemáticas
FORTRAN tiene también una cantidad considerablemente
grande de rutinas matemáticas disponibles para el cálculo
de logaritmos, funciones trigonométricas, números
complejos, etc.
Jerarquías de los operadores
Los operadores aritméticos también tienen prioridades:
1) Exponenciación
2) Multiplicación y división
3) Suma y resta
Estas mismas prioridades han sido adoptadas en la mayoría
de los lenguajes de programación modernos.
Ciclos con DO
La sentencia DO es la única estructura de control de alto
nivel que proporciona FORTRAN, puesto que les permite
a los programadores expresar lo que quieren que se haga y
no cómo quieren que se haga.
Ciclos con DO
La sentencia DO ilustra el principio de Automatización (de
MacLennan):
Deben automatizarse las tareas mecánicas, tediosas o
propensas a errores.
Ciclos con DO
La sentencia DO permite realizar iteraciones definidas
(llamadas en inglés “counted loops”):
DO 100I=1,N
haz lo que quieras
100
CONTINUE

Ciclos con DO
En el ejemplo anterior, 100 es una etiqueta (sólo se
permiten etiquetas numéricas en FORTRAN) que indica lo
que está contenido dentro del ciclo. I es el contador del
ciclo en este caso y toma un valor inicial de 1, llegando
hasta N. CONTINUE no tiene ningún efecto y sólo se usa
para indicar la finalización del ciclo (como la sentencia
NEXT en BASIC).

Ciclos con DO
Los ciclos con DO también pueden ser anidados, lo que
proporciona mucha flexibilidad.

Ciclos con DO (ejemplo)
DO 100 I=1,M
.
DO 200 J=1,N
.
200
CONTINUE
.
100
CONTINUE
Ciclos con DO
FORTRAN tiene, en general, una estructura “lineal” y no
“jerárquica”, dado que la mayoría de sus instrucciones no
permiten ningún tipo de anidamiento. Por lo tanto, la
sentencia DO resulta ser más bien una excepción que una
función más del lenguaje.

Ciclos con DO
Adicionalmente, la seguridad del lenguaje se ve comprometida
por el hecho de que FORTRAN permite saltos
incondicionales (GOTOs) dentro y fuera de los ciclos DO
bajo ciertas circunstancias. Esta es una de las razones por las
cuales la sentencia GOTO se volvió obsoleta en la segunda
generación de lenguajes de programación.

Ciclos con DO
Finalmente, el ciclo DO está altamente optimizado, lo que lo
hace altamente útil y práctico desde la perspectiva de la meta
principal del FORTRAN: la eficiencia.

Ciclos con DO
La capacidad de optimización del ciclo DO puede atribuirse
parcialmente a su estructura y al hecho de que la variable de
control y sus valores iniciales y finales se especifican
explícitamente junto con la extensión del ciclo.
Ciclos con DO
Aunque parezca extraño, suele darse el caso de que las
estructuras de más alto nivel (como el DO en este caso)
resultan más fáciles de optimizar que las de bajo nivel.
Estructura básica de un programa en
FORTRAN
Declarations
Main program
Subprogram 1
Subprogram 2
.
Subprogram n

Subprogramas
Los subprogramas son realmente una adición posterior al
FORTRAN, ya que no aparecieron sino hasta en el
FORTRAN II.
Aunque FORTRAN I proporcionaba bibliotecas con
funciones matemáticas y de E/S, no permitía que los
programadores definieran sus propios subprogramas.

Subprogramas
FORTRAN II resolvió el asunto de los subprogramas al
agregar las declaraciones SUBROUTINE y FUNCTION.

Eficiencia en la compilación
Puesto que una de las metas primordiales de FORTRAN
durante su diseño fue la eficiencia, el enfoque tomado para
generar un archivo ejecutable estaba altamente optimizado:

Eficiencia en la compilación
1) Compilación: Traducir subprogramas individuales en
FORTRAN a código objeto relocalizable (código que usa
direcciones relativas en vez de direcciones absolutas de
memoria). Estas direcciones relativas se resolverán (o sea, se
convertirán a direcciones absolutas) en tiempo de cargado.

Eficiencia en la compilación
La mayor parte de los errores de sintaxis se interceptarán en
esta etapa (p.ej., sentencias inexistentes, uso erróneo de
variables u operadores, etc.)

Eficiencia en la compilación
2) Ligado (Linking): Incorporar bibliotecas de subprogramas
que han sido previamente escritos, depurados y compilados.
Los programas en FORTRAN contienen referencias externas
que deben resolverse durante esta etapa.

Eficiencia en la compilación
Cualquier referencia errónea a funciones externas se resuelve
en esta etapa.
3) Cargado: Es el proceso en el cual se coloca un programa en
la memoria de la computadora. Las direcciones relativas (o
direcciones relocalizables) se traducen a direcciones absolutas
de memoria.
Eficiencia en la compilación
4) Ejecución: El control de la computadora se pasa al
programa que se encuentra en memoria. Puesto que el
programa se ejecuta directamente y no a través de un
intérprete, tiene el potencial de correr significativamente más
rápido.
Pasos de la compilación
La compilación de un programa en FORTRAN se realiza
normalmente en 3 pasos:
1) Análisis sintáctico: El compilador debe clasificar las
sentencias y constructores de FORTRAN y extraer sus
partes.
Pasos de la compilación
2) Optimización: Los compiladores originales de
FORTRAN incluían un optimizador muy
sofisticado cuya meta era producir código tan
bueno como el de un buen programador humano.
Hasta la fecha, la mayor parte de los compiladores
de FORTRAN que existen realizan algún tipo de
optimización.
Pasos de la compilación
3) Síntesis de código: Juntar las porciones de las
instrucciones en código objeto en un formato
relocalizable.

Estructuras de control
En sus orígenes, FORTRAN fue un lenguaje muy
dependiente de la máquina en la que se desarrolló (la IBM
704). Esa es la razón por la que algunas de sus instrucciones
lucen un tanto extrañas, redudantes y hasta tontas.

Estructuras de control
Algunas de estas sentencias fueron removidas en versiones
posteriores del lenguaje, pero la mayor parte de ellas han
permanecido ahí durante más de 40 años.
Estructuras de control
La sentencia IF aritmética:
IF (e) n1, n2, n3
evalúa la expresión “e” y salta a n1,n2 o n3, dependiendo
de si el resultado de la evaluación es <0, =0 o >0.
Estructuras de control
La sentencia IF aritmética corresponde de manera exacta a
una instrucción en lenguaje máquina de la IBM 704 y es un
buen ejemplo de cómo NO diseñar una sentencia IF.
Estructuras de control
Llevar el control de 3 etiquetas es algo difícil y el hecho de
que en muchos casos dos de estas etiquetas pueden fusionarse
(por ser idénticas) hacen de ésta una instrucción muy
primitiva.

Estructuras de control
La sentencia IF lógica:
IF (X .EQ. 5) M=A+3
.LT., .GT., .GE., .LE., .AND., .OR.,
.NOT., .EQV., .NEQV.
Esta sentencia reemplaza a la primitiva sentencia IF
aritmética y la vuelve más fácil de usar y más regular.

Estructuras de control
Sentencias Condicionales
GOTO era el caballito de batalla del control de flujo en
FORTRAN, ya que no existía estructura IF-THEN-ELSE
como en la mayoría de los lenguajes de programación
modernos.

Estructuras de control
IF (se cumple) GOTO 100
. . . caso para condición falsa . . .
GOTO 200
100
. . . caso para condición cierta . . .
200
. . .

Estructuras de control
El uso de GOTO puede llevarnos (cuando no se aplica
adecuadamente) al desarrollo del denominado “código
spaghetti”, lo cual genera programas difíciles de leer y
modificar.

Estructuras de control
Sentencias para casos:
Como no había CASE como en los lenguajes de
programación modernos, se utilizaba en su lugar el
denominado “GOTO calculado” (computed GOTO).


COBOL


Generalidades
El lenguaje COBOL, acrónimo de "COmmon Business Oriented Language" nació en 1959 del deseo de crear un lenguaje de programación "universal", que pudiera ser usado en cualquier ordenador (en los años 60 existían numerosos modelos de ordenadores incompatibles entre sí) y que estuviera orientado principalmente a los negocios, es decir, a la Informática de gestión. En la creación de este lenguaje participó la comisión CODASYL, compuesta por fabricantes de ordenadores, usuarios y el departamento de defensa de Estados Unidos. El primer prototipo del lenguaje salió a la luz en 1960. A pesar del tiempo transcurrido, sigue siendo uno de los lenguajes de programación más usados en el mundo.
COBOL es un lenguaje en el que no se diferencian las minúsculas y las mayúsculas (no es case sensitive). Es un lenguaje de formato fijo, donde la estructura de cada instrucción viene definida por el lenguaje. En general, cada instrucción debe ir en una única línea y una línea solo puede tener una instrucción. Además, cada instrucción termina siempre con un punto (.). Por otro lado, las instrucciones deben comenzar en una determinada columna. Cada línea está formada por tres áreas, definidas por la columna (o posición) que ocupan dentro de la línea:
Números de Secuencia: Se representan en las columnas 1 a 6. Constituyen una numeración de las líneas de código y están formados por números de 6 dígitos. No es obligatorio que todas las líneas de código lleven el número de secuencia, pero si éstos aparecen, deben ser siempre crecientes (un número de secuencia de una línea siempre tiene que ser mayor que cualquier otro número de secuencia que pueda aparecer previamente) [no es obligatorio implementar los números de secuencia, pero siempre hay que dejar este hueco de seis columnas].
Área indicadora: Se representa por un carácter en la columna 7. Se utiliza para indicar ciertas características de cada línea: , continuación de la línea anterior (si se desea partir una instrucción en varias líneas, la segunda y sucesivas deben tener un guión "-" y comenzar en la columna 12) [es opcional implementar la continuación de líneas con el guión, pero se debe respetar el hueco de la columna 7].
Área de código fuente: Se representa en las columnas 8 a 80. Se utiliza para escribir todo el código fuente en COBOL [es opcional limitar las líneas a 80 columnas, pero cada línea de código debe comenzar en la columna 8].
Las más de 300 palabras clave que tiene el lenguaje son reservadas, aunque cada grupo de alumnos sólo ha de tener en cuenta las palabras asignadas a su grupo.
COBOL no es un lenguaje con estructura de bloques y, por tanto, no maneja los conceptos de nombres globales y no locales. Todos los nombres son locales.
En COBOL es necesario declarar previamente los identificadores (salvo las etiquetas) antes de que se utilicen. Además, hay que implementar el Compilador de COBOL considerando que es un lenguaje con recursividad, por lo que cualquier subprograma puede ser recursivo.
Estructura de un Programa
Para el Proyecto de Compiladores debe considerarse que un programa COBOL estará compuesto por un único fichero que ha de tener uno o varios subprogramas colocados uno tras otro. Un subprograma está estructurado en tres divisiones que han de aparecer exactamente en el siguiente orden:
IDENTIFICATION DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
Dentro de cada división se especifica un tipo de información. Seguidamente, se va a comentar la utilidad de cada una de las divisiones.
División de Identificación
Mediante esta división se asigna un nombre al subprograma (se usa la palabra reservada PROGRAM-ID seguida de un punto). El nombre del subprograma, que siempre debe aparecer, constituye un y va seguido de un punto. Opcionalmente, se puede añadir información (que se considera como un comentario) sobre autor (mediante la palabra AUTHOR), fecha de escritura (mediante la palabra DATE-WRITTEN), etc. [solo es obligatorio implementar el nombre del subprograma]. La sintaxis es:
IDENTIFICATION DIVISION.
PROGRAM-ID. Nombre-de-programa.
AUTHOR. Profesores de Compiladores.
DATE-WRITTEN. 19 de octubre de 2005.
División de Datos
En esta división se declaran los datos del subprograma, de forma que el compilador pueda reservar memoria para ellos. Dentro de esta división hay una serie de secciones opcionales de las que solo hay que considerar, en este orden, la LINKAGE SECTION, que es la que se utiliza para declarar los parámetros del subprograma, y la WORKING-STORAGE SECTION, que es la que se utiliza para declarar las variables locales del subprograma. Si alguna de las secciones no contiene ninguna declaración, no es necesario indicarla. Si la división no tiene ninguna sección, tampoco hay que indicarla. Por tanto, la estructura general de esta división sería:

División de Procedimiento
En esta división se declaran las sentencias del subprograma. Cuando se llame al subprograma, la ejecución comenzará por la primera sentencia que aparezca en esta división y proseguirá secuencialmente hasta que se llegue bien a la sentencia de retorno de subprograma (EXIT PROGRAM) o bien a la de fin de programa (STOP RUN) Esta división comienza con las palabras reservadas PROCEDURE DIVISION y termina con las palabras reservadas END PROGRAM, que indican también el final del código del subprograma.

Programa Principal
Existe un subprograma especial que constituye el programa principal. Tiene que ser siempre el último subprograma del programa. El programa principal (lo que se ejecutará al arrancar el programa) será siempre un subprograma sin parámetros. La finalización del programa principal se especifica mediante la instrucción de fin de programa (STOP RUN), que solo puede estar presente en el programa principal. Ejemplo:
IDENTIFICATION DIVISION.
PROGRAM-ID. Nombre-de-programa.
DATA DIVISION.
WORKING-STORAGE SECTION.
* declaración de las variables locales
PROCEDURE DIVISION.
* sentencias
STOP RUN.
* sentencias
END PROGRAM.
Comentarios
En COBOL los comentarios se especifican colocando el carácter "*" en la columna 7 de cada línea donde se desee introducir un comentario. Por lo tanto, las líneas de comentario, tantas como se quiera, solamente podrán contener comentarios. Ejemplos:
* Línea de Comentario con el asterisco en la columna 7
*Otra línea con comentario
Constantes
El lenguaje dispone de varios tipos de constantes, de las cuales solamente habrá que tener en cuenta las siguientes:
Enteros
Las constantes enteras se escribirán en notación decimal (por ejemplo, 159). El ensamblador que se utilizará dispone de números enteros de 2 bytes (con signo), por lo que el máximo entero será el 32767.
Cadenas de caracteres
Las constantes de cadena van encerradas entre comillas simples ('Hola, mundo'). Puede aparecer cualquier carácter imprimible en la cadena excepto la propia comilla, que siempre actuará como delimitador.
Constantes figurativas
Son constantes a las que se les ha asignado un nombre fijo (que se considera palabra reservada). Como ejemplos de constantes figurativas se tiene zero, que representa el valor numérico cero; space, que representa al carácter espacio, etc. [es opcional implementar las constantes figurativas].
Operadores
Este lenguaje presenta un conjunto de operadores con los que escribir distintas expresiones. Además, se pueden utilizar los paréntesis para agrupar subexpresiones. Cada símbolo de operador debe tener obligatoriamente al menos un espacio antes y otro después (esto no se aplica si el operador es una palabra reservada). De esta manera, la expresión 8 > 3 es correcta, mientras que 7+9 es incorrecta.
Operadores aritméticos
Son los operadores que permiten realizar la suma, resta, producto y división: +, -, * y / [obligatorio implementar al menos uno]. Se aplican sobre datos enteros, proporcionando un resultado entero.
También existen los operadores más y menos unarios: +, - [implementación opcional].
Operadores de relación
Son los operadores que permiten realizar las comparaciones de igual, distinto, menor, mayor, menor o igual, mayor o igual: =, <, >, IS EQUAL TO, IS NOT EQUAL TO, IS LESS THAN, IS GREATER THAN, IS NOT GREATER THAN e IS NOT LESS THAN (obsérvese que algunos operadores pueden escribirse de más de una forma) [obligatorio implementar al menos uno de los operadores]. Se aplican sobre datos enteros y proporcionan un resultado lógico.
Operadores lógicos
Representan las operaciones de conjunción, disyunción y negación: AND, OR y NOT [obligatorio implementar al menos uno]. Se aplican sobre datos lógicos y devuelven un resultado lógico.
Precedencia de operadores
En la tabla siguiente se muestra la precedencia de los operadores con el siguiente significado: los operadores del mismo grupo tienen la misma precedencia y, conforme se desciende por la tabla, la precedencia disminuye. En cualquier caso, el uso de paréntesis permite alterar el orden de evaluación de las expresiones [es obligatorio para todos los grupos implementar el uso de paréntesis y tener en cuenta las precedencias de sus operadores.

Identificadores
Los nombres de identificadores pueden estar formados por letras, dígitos y el guión ("-"), siendo el primero siempre una letra y no pudiendo empezar ni terminar con guión. Además, los identificadores deben tener una longitud máxima de 30 caracteres.
Declaraciones
La declaración de variables se considerará obligatoria en el lenguaje definido para este Proyecto. No se admite la redeclaración de nombres en un mismo ámbito. La declaracion de variables se realiza en la DATA DIVISION, dentro de la WORKING-STORAGE SECTION, mediante la cláusula PICTURE (que también puede escribirse como PIC [cada grupo eligirá una de las dos]). En el caso de los parámetros de un subprograma, se deben definir usando esta misma notación, dentro de la LINKAGE SECTION.
Para realizar una declaración de una variable, se escribe el número de nivel 77 (salvo para los registros, que se usan los números del 01 al 49) y a continuación el nombre de la variable seguido de una cláusula PICTURE con la especificación del tipo y tamaño de la variable, finalizando en un punto:
77 nombre PICTURE tipo-tamaño.
Tipos de Datos
El lenguaje dispone de distintos tipos de datos, que pueden ser clasificados en Tipos Básicos (o elementales) y Tipos Compuestos (que se forman a partir de tipos básicos).
Tipos Básicos
Se deben considerar los tipos de datos básicos entero y lógico (aunque no se pueden declarar variables de tipo lógico). Se define una variable entera utilizando el carácter 9 para determinar el número de dígitos que se reservan para la variable (la cantidad de nueves indica la cantidad de dígitos que puede tener el número entero). Teniendo en cuenta el tamaño determinado por el ensamblador, el tamaño máximo sera de 5 dígitos (según la especificación del ensamblador) [es opcional implementar tamaños de enteros inferiores a 5 dígitos].
Tipos Compuestos
Cada grupo tendrá que implementar uno de estos tipos compuestos, basándose en la opción que le corresponda. Todas las declaraciones de variables deben realizarse en la DATA DIVISION del subprograma correspondiente. En los ejemplos se va a hacer uso de elementos del lenguaje que se explicarán posteriormente.
Vectores
Un vector permite almacenar varios valores en una sola variable y acceder a ellos por su posición. Para usar una variable de tipo vector es obligatorio declararla mediante la cláusula OCCURS [implementación obligatoria para algunos grupos].
Cadenas
Una cadena permite almacenar en una variable una secuencia de caracteres alfanuméricos. Para usar una variable de tipo cadena es obligatorio declararla [implementación obligatoria para algunos grupos].
Registros
Un registro es una estructura compuesta de un número fijo de componentes, llamados campos, donde cada uno viene definido por su nombre y su tipo [implementación obligatoria para algunos grupos].
Sintaxis: núm-nivel-1 nombreRegistro. {núm-nivel-2 nombreCampo PICTURE tipoCampo.}
Descripción: Para declarar un registro se utilizan los números de nivel en cascada. El número de nivel (núm-nivel-1) del nombre del registro tiene que ser un número de dos dígitos entre 01 y 49. En primer lugar, se declara el nombre del registro (nombreRegistro). En las líneas siguientes se declaran los campos, cuya sintaxis es exactamente la misma que la explicada para las de enteros [solo hay que implementar campos enteros], salvo que el número de nivel (núm-nivel-2) tiene que ser un número entero de dos dígitos entre 01 y 49, pero con un valor superior al número utilizado para el nombre del registro (todos los campos de un mismo registro han de tener el mismo número de nivel). Los campos de un registro pueden tener el mismo nombre (nombreCampo) que otros identificadores situados fuera de dicho registro, no existiendo ambigüedad porque siempre se accede a un campo (mediante la palabra OF) utilizando el nombre del campo y el del registro.
Ejemplos:
01 empleado.
05 nombre PICTURE x(50).
05 sueldo PICTURE 9(5).

Instrucciones de entrada/salida
La instrucción DISPLAY expresiones escribe los datos recibidos en las expresiones (que deberán ir separadas entre sí por comas) y, a continuación, imprime un salto de línea. Si no hay ninguna expresión, se limita a imprimir un salto de línea. Las expresiones pueden ser de tipo entero, lógico o cadena. Por ejemplo:
Move 100 to a.
DISPLAY 'Precio: ', a, 'Euros. Con IVA: ', a + a * 16 / 10.
* imprime: “Precio: 100Euros. Con IVA: 116”
DISPLAY a > 50, a < 50.
* imprime: “TrueFalse”
La instrucción ACCEPT lista recibe una lista (no vacía) de variables enteras separadas por comas y lee números enteros del teclado, asignándole cada valor leído a cada una de las variables recibidas, respectivamente [los grupos que tengan el tipo cadena, también deberán implementar la lectura de variables cadena]:
77 an Picture 99999.
77 na Pic 9(5).
* ...
* imprime una cadena:
DISPLAY 'Escribe en qué año naciste y en qué año estamos' .
* lee dos números:
ACCEPT na, an.
* imprime entre dos cadenas la edad y salta de línea:
DISPLAY 'Hola, tienes ', an - na, ' años.' .
Sentencias
De todo el extenso grupo de sentencias del lenguaje COBOL, se han seleccionado para ser implementadas en el Proyecto las que aparecen a continuación (opcional u obligatoriamente, según se indique en cada caso):
Sentencias de Asignación
Existen dos sentencias de asignación en COBOL, MOVE y COMPUTE cuyo funcionamiento se explica a continuación [es obligatorio implementar la sentencia MOVE y es opcional implementar la sentencia COMPUTE].
Sentencia MOVE
Esta sentencia permite asignar un valor a una variable [implementación obligatoria]:
Sintaxis: MOVE expresión TO identificador.
Descripción: Se evalúa la expresión y se asigna el valor resultante al identificador.
Ejemplo:
MOVE 12 * x TO salario-anual-juan.
MOVE salario-anual-juan TO salario-anual-pedro.
Sentencia COMPUTE
Esta sentencia permite asignar un valor a una variable [implementación opcional]:
Sintaxis: COMPUTE identificador = expresión.
Descripción: Se evalúa la expresión y se asigna el valor resultante al identificador.
Ejemplo:
COMPUTE salario-anual-juan = 12 * x.
COMPUTE salario-anual-pedro = salario-anual-juan.
Sentencias Varias
Sentencia de llamada a un subprograma
Esta sentencia permite invocar la ejecución de un subprograma previamente definido.
Sintaxis: CALL nombre-subprograma [USING expresiones].
Descripción: La llamada a un subprograma se realiza mediante la instrucción CALL, que va seguida del nombre del subprograma y de los argumentos actuales indicados mediante la cláusula USING y separados por comas (si no tiene argumentos, no se indica esta cláusula).
Ejemplo:
* llamada al subprograma mul con dos parámetros:
CALL mul USING total, 8 + b.
* llamada al subprograma imprime, que no tiene parámetros:
CALL imprime.
ELSE
move 2 to tasa.
END IF.
Sentencia condicional GO TO DEPENDING
Esta sentencia constituye una sentencia de selección múltiple, similar a la que presentan otros lenguajes, aunque su ejecución presenta unos matices propios [implementación obligatoria para algunos grupos].
Sintaxis: GO TO etiqueta1 {etiqueta2} DEPENDING ON expresión.
Descripción: En primer lugar, las etiquetas indicadas identifican cuerpos de perform, tal como se ha explicado con anterioridad y, por tanto, se les imponen las mismas condiciones, incluido que deben aparecer después de la clausula STOP RUN o EXIT PROGRAM. El funcionamiento general del GO TO se basa en el valor de la expresión. Si ésta vale 1, se salta a etiqueta1 y una vez ejecutado el código correspondiente se termina el GO TO. Si la expresión vale 2, se salta a la etiqueta2, y así sucesivamente. Si no existiera la etiqueta correspondiente al valor de la expresión (por ejemplo, si la expresión vale 3 y sólo se especifican dos etiquetas), la ejecucion del GO TO finalizará. Lo mismo ocurre si la expresión vale 0 ó un valor negativo.
Ejemplo:
GO TO director subdirector empleado DEPENDING ON tipo.
* ...
Stop Run.
* si tipo es 1 se ejecuta:
director.
move 5000 to sueldo.
Exit.
* si tipo es 3 se ejecuta:
empleado.
move 900 to sueldo.
Exit.
* si tipo es 2 se ejecuta:
subdirector.
move 2500 to sueldo.
EXIT.
Subprogramas
Es necesario definir cada subprograma antes de poder utilizarlo. La definición de un subprograma se realiza indicando su nombre y las divisiones identification, data y procedure. Dentro de la DATA DIVISION se coloca la WORKING-STORAGE SECTION, donde se definen las variables locales (si las tiene) y la LINKAGE SECTION, donde se definen los nombres y tipos de los parámetros formales del subprograma (si los tiene). Además, en el título de la PROCEDURE DIVISION se vuelven a indicar los nombres de los parámetros recibidos mediante una lista tras la palabra USING. Dentro de esta PROCEDURE DIVISION se tiene el cuerpo del subprograma y el final de la ejecución del subprograma se indica con la sentencia EXIT PROGRAM. El final del código del subprograma se indica mediante la instrucción END PROGRAM.
Los parámetros de los subprogramas podrán ser de cualquiera de los tipos que le corresponda a cada grupo. Existen dos formas de pasar los parámetros: por valor (BY VALUE) y por referencia (BY REFERENCE). Estas palabras se indican tras la lista de parámetros en la declaración .

PHP es un lenguaje de programación (originario del nombre PHP Tools, o Personal Home Page Tools) que sirve principalmente para proporcionar características dinámicas a una página web. Puede combinarse con bases de datos MySQL, ofreciendo resultados muy interesantes para todas aquellas páginas web que pretendan figurar como activas y dinámicas.

El lenguaje PHP tiene la característica de poder mezclarse con el lenguaje HTML.
, al contrario que este último, se interpreta y ejecuta directamente en el servidor en el que está albergada la página web, con lo que el visitante a la misma únicamente recibe el resultado buscado por el código en el que está escrito.