ALGOL 68C - ALGOL 68C

ALGOL 68C es un imperativo lenguaje de programación de computadoras , un dialecto de ALGOL 68 , que fue desarrollado por Stephen R. Bourne y Michael Guy para programar el Cambridge Algebra System (CAMAL). El compilador inicial fue escrito en Princeton Syntax Compiler (PSYCO, por Edgar T. Irons ) que fue implementado por JH Mathewman en Cambridge.

ALGOL 68C se utilizó más tarde para el sistema operativo CHAOS para la computadora CAP de seguridad basada en capacidades en la Universidad de Cambridge en 1971. Otros colaboradores tempranos fueron Andrew D. Birrell e Ian Walker.

Se realizó un trabajo posterior en el compilador después de que Bourne dejó la Universidad de Cambridge en 1975. Se agregó la recolección de basura y la base de código todavía se está ejecutando en un sistema operativo / MVT emulado usando Hercules .

El compilador ALGOL 68C generó una salida en ZCODE , un lenguaje intermedio basado en registros, que luego podría interpretarse o compilarse en un ejecutable nativo. Esta capacidad de interpretar o compilar ZCODE alentó la migración de ALGOL 68C a muchas plataformas informáticas diferentes . Además de la computadora CAP , el compilador se transfirió a sistemas que incluyen Conversational Monitor System (CMS), TOPS-10 y Zilog Z80 .

Cultura popular

Guy y Bourne utilizaron un predecesor muy temprano de este compilador para escribir los primeros programas de Game of Life en el PDP-7 con una pantalla DEC 340.

Varias ediciones de Liverpool Software Gazette detallan la implementación de Z80. El compilador requirió alrededor de 120 KB de memoria para ejecutarse; por lo tanto, la memoria de 64 KB del Z80 es demasiado pequeña para ejecutar el compilador. Por lo tanto, los programas ALGOL 68C para el Z80 tenían que compilarse de forma cruzada desde la computadora CAP más grande o una computadora central IBM System / 370 .

Algol 68C y Unix

Stephen Bourne posteriormente reutilizado ALGOL 68 's , y cláusulas en el común Unix Bourne shell , pero con ' s sintaxis cambiado, eliminado y reemplazado con (para evitar conflicto con la OD de utilidad). if ~ then ~ else ~ ficase ~ in ~ out ~ esacfor ~ while ~ do ~ od inoutoddone

Después de Cambridge, Bourne pasó nueve años en Bell Labs con el equipo Versión 7 Unix (Séptima edición Unix). Además de desarrollar el shell Bourne, portó ALGOL 68C a Unix en el DEC PDP-11 -45 e incluyó una opción especial en su depurador de Unix Advanced Debugger (adb) para obtener un seguimiento de pila para programas escritos en ALGOL 68C. Aquí hay un extracto de las páginas del manual de la séptima edición de Unix:

NAME
      adb - debugger
SYNOPSIS
      adb [-w] [ objfil [ corfil ] ]
[...]
COMMANDS
[...]
       $modifier
             Miscellaneous  commands.   The  available modifiers
             are:
             [...]
             a      ALGOL 68 stack  backtrace.   If  address  is
                    given  then it is taken to be the address of
                    the current frame (instead of r4).  If count
                    is  given  then  only the first count frames
                    are printed.

Extensiones de ALGOL 68C a ALGOL 68

A continuación se muestra una muestra de algunas extensiones notables:

• Operación automática : = para cualquier operador, p. Ej. *:=Y+:=
• UPTO, DOWNTOY UNTILen bucle cláusulas;
• operador de desplazamiento ( :=:=)
• ANDF, ORFY THEF elementos sintácticos .
• compilación separada - ENVIRONcláusula y USINGcláusula
• ámbitos no comprobados
• límites en declaradores formales
• CODE... EDOCcláusula - para incrustar ZCODE

Las cláusulas ENVIRONyUSING

La compilación separada en ALGOL 68C se realiza mediante las cláusulas ENVIRONy USING. El ENVIRONguarda el entorno completo en el punto que parece. Un módulo separado escrito comenzando con una USINGcláusula se inserta efectivamente en el primer módulo en el punto en ENVIRONque aparece la cláusula.

ENVIRONy USINGson útiles para un estilo de programación de arriba hacia abajo , en contraste con el estilo de abajo hacia arriba que implican los mecanismos de biblioteca tradicionales.

Estas cláusulas son una especie de inverso del #include que se encuentra en el lenguaje de programación C , o de la importación que se encuentra en Python . El propósito del ENVIRONmecanismo es permitir que una fuente de programa se divida en piezas de tamaño manejable. Solo es necesario analizar el archivo de origen compartido una vez, a diferencia de un #include que se encuentra en el lenguaje de programación C, donde el archivo de inclusión debe analizarse para cada archivo de origen que lo incluye.

Ejemplo de ENVIRONcláusula

Un archivo llamado mylib.a68 :

BEGIN
   INT dim = 3; # a constant #
   INT a number := 120; # a variable #
   ENVIRON EXAMPLE1;
   MODE MATRIX = [dim, dim]REAL; # a type definition #
   MATRIX m1;
   a number := ENVIRON EXAMPLE2;
   print((a number))
END

Ejemplo de USINGcláusula

Un archivo llamado usemylib.a68 :

USING EXAMPLE2 FROM "mylib"
BEGIN
  MATRIX m2; # example only #
  print((a number)); # declared in mylib.a68 #
  print((2 UPB m1)); # also declared in mylib.a68 #
  ENVIRON EXAMPLE3;  # ENVIRONs can be nested #
  666
END

Restricciones al idioma del estándar ALGOL 68

• Sin ALGOL 68 FLEX y matrices de longitud variable
• MODE STRING implementado sin FLEX
• La cláusula PAR paralela no se implementó
• Transput no estándar
• otros...

Un traductor-compilador para ALGOL 68C estaba disponible para PDP-10 , IBM System / 360 y varias otras computadoras.

Referencias

enlaces externos

• Sitio web oficial
• Cambridge ALGOL 68: en la lista histórica de lenguajes informáticos ; incluye más de 10 referencias de publicaciones.
• A Transporte de ALGOL 68C - PJ Gardner, Universidad de Essex - marzo de 1977 (de 370 a DECsystem-10)
• Ejecución de ALGOL 68C en MVS : cómo instalar ALGOL 68C en un sistema MVS emulado