En 1979, Honeywell Information Systems anunció un nuevo lenguaje de programación para su servicio de tiempo compartido llamado TEX , acrónimo del sistema de procesamiento de texto Text Executive . TEX fue un lenguaje de secuencias de comandos de primera generación desarrollado en la época de AWK y utilizado inicialmente por Honeywell como una herramienta interna de automatización de pruebas de sistemas.
TEX amplió el editor de línea del servicio de tiempo compartido (TSS) de Honeywell con capacidades programables, lo que permitió al usuario una mayor libertad para desarrollar extensiones de edición fáciles de usar, así como escribir scripts para automatizar muchas otras tareas de tiempo compartido que antes realizaban empresas más complejas. Programas TSS FORTRAN.
TEX era un subsistema de Honeywell Timesharing (TSS). Los usuarios ingresarían el comando TSS tex para cambiar a un modo de operación de sesión TEX. Las expresiones TEX se pueden ingresar directamente en la línea de comando o ejecutar desde un archivo de script mediante la llamada de comando TEX ⟨filename⟩ .
Los programas TEX son una colección de comandos de edición de líneas TSS, comandos de sesión TSS y declaraciones TEX. Las variables TEX se pueden insertar en los comandos TSS y en los comandos del editor de líneas TSS a través de la función de sustitución de variables TEX. Los programas TEX fueron diseñados principalmente para ampliar el sistema de edición de líneas. En consecuencia, TEX no tenía ningún concepto de entrada/salida de archivos, sino que se basaba en aplicar comandos de edición de línea al archivo de trabajo y guardarlo según fuera necesario.
Los desarrolladores clave de TEX en Honeywell fueron Eric Clamons y Richard Keys con Robert Bemer , famoso por ser el padre de ASCII y abuelo de COBOL , actuando en calidad de asesor. [1]
TEX no debe confundirse con TeX, un lenguaje de marcado tipográfico inventado por Donald Knuth .
La Sociedad Estadounidense de Matemáticas también reclamó una marca registrada para TeX, que fue rechazada porque en el momento en que se intentó (principios de la década de 1980), Honeywell registró "TEX" (todo en mayúsculas) para el sistema de procesamiento de texto "Text EXecutive". [2]
Todas las variables [3] se almacenaron como cadenas y se convirtieron a valores numéricos enteros cuando fue necesario. Las variables de punto flotante, matrices u otros tipos de datos comunes en los lenguajes de programación actuales no existían en un entorno TEX.
Todas las variables se almacenaron en un único grupo de variables global que los usuarios debían administrar para evitar conflictos de nombres de variables. No había capacidades de alcance variable en TEX. Los nombres de las variables se limitaron a 40 caracteres.
TEX proporcionó varios registros internos de solo lectura llamados funciones en estrella [4] que cambiaban de estado cuando se ejecutaban ciertas operaciones de análisis de cadenas TEX. Las funciones en estrella proporcionaron un medio para obtener la fecha y hora actuales, las cadenas resultantes de una operación de análisis de cadenas divididas o de escaneo o del nivel de llamada interna de TEX y la información de la sesión TSS.
La longitud máxima de un valor de cadena era de 240 caracteres ASCII. Esto incluye resultados intermedios al evaluar una expresión TEX. Los valores de cadena numérica están limitados a 62 dígitos en la cadena, incluido el (-) para números negativos. Los valores numéricos también se normalizan donde los ceros iniciales se eliminan de la representación de la cadena.
Algunos ejemplos de uso variable:
_ podemos usar comillas u otros caracteres como delimitadores siempre que la cadena no los contenga _ y puede usar el operador coma para unirlos _ a="hola" b=/mundo/ c=a,/ /,b
_ la declaración de salida imprime "hola mundo" en la terminal sin comillas _ fuera:c
_ Usar variables TEX en un comando de edición de línea para encontrar una línea que contenga "hola" _ reemplazando la cadena "hola" con la cadena "hola mundo" _ rs:a:c
TEX tiene tres tipos de operadores: [5]
Al construir una expresión TEX, se deben comprimir todos los espacios excepto los literales de cadena. En general, los espacios delimitan declaraciones TEX.
_ NOTA: En la declaración "d=", no hay espacios entre las comas. _ o las variables a="hola" b=" " c="mundo" d=a,b,c salida:d
_ Por el contrario, se necesita un espacio para separar el 'si' de su expresión y _ la expresión del siguiente comando TEX para ejecutar condicionalmente _ si a:eqs:"hola" fuera:a
solo admite operaciones aritméticas enteras básicas:
con hasta 16 niveles de paréntesis.
Algunos ejemplos son:
un=1 b=-2 c=3*(ab)/(2*2+(4+1))
vienen en dos sabores para:
Se utilizaban con mayor frecuencia en el contexto de una declaración de control IF .
Una lista de operadores de comparación numérica disponibles es:
Una lista de operadores de comparación de cadenas disponibles es:
Los operadores booleanos de cadena se ven afectados por el modo TEX CASE . En el modo CASE, cadenas como 'ABC' y 'abc' se consideraban iguales (TEX convirtió 'ABC' en 'abc' antes de la comparación). En el modo NOCASE, la cadena 'abc' se consideraría mayor que la cadena 'ABC' según el valor del punto del código ASCII , ya que 'a' es un valor mayor que el valor del punto del código ASCII 'A'.
El operador booleano NOT estaba representado por el carácter circunflejo (^). [8]
Algunos ejemplos de operadores booleanos en acción:
if name:eqs:"luke" out:"¡Que la fuerza te acompañe!" if ^age:gtn:500 out:"¡Je, no puedes ser Yoda!"
TEX no proporcionó conectores ni para crear expresiones booleanas más complejas. En su lugar, los programadores tuvieron que usar sentencias if anidadas para conexiones y un bloque de sentencias if...do Something para manejar conexiones :
_ un ejemplo de una construcción y si a:eqs:'a' si b:eqs:'b' ir a !its_true ir a !its_false _ un ejemplo de una construcción o si a:eqs:'a' ir a !its_true si b:eqs:'b' ir a !its_true si c:eqs:'c' ir a !its_true ir a !its_false !its_true out:"¡Es verdad!" ir a !next_block !its_false out: "¡Es falso!" ir a !next_block !siguiente_bloque ...hacer algo...
La concatenación de cadenas en TEX fue proporcionada por el operador de coma:
a="hola","mundo"
TEX proporcionó varios operadores de división de cuerdas: [9]
Algunos ejemplos de división de cuerdas:
a="hola mundo" b=a']5 c=a]'5 out:"Es una novedad extraña ",c", pero ",b," ¡de todos modos!"
TEX proporcionó varios operadores de escaneo/análisis de cadenas: [10]
Algunos ejemplos de escaneo/análisis de cadenas:
a="hola mundo" b=a'>" "
fuera:b
Todas las etiquetas de declaraciones TEX tenían el prefijo (!). [11] Las etiquetas de las declaraciones se ignoraron a menos que se hiciera referencia a ellas mediante una declaración goto [12] o call [13] . Una característica notable de TEX fue la capacidad de llamar o ir a etiquetas en otros archivos. Junto con el modo TEX SUBS , significaba que TEX podía crear nuevos scripts mediante la edición de líneas, guardar y luego llamar o ir a etiquetas en estos scripts dinámicamente.
El archivo mypgm.tex :
!Hola salida: "hola mundo" devolver !hola2 salida: "hola mundo otra vez" salida (marcador de fin de archivo)
Ejemplo de llamada por etiqueta:
llame a /mycat/mypgm.tex!hola
En el ejemplo anterior, TEX procesaría el archivo /mycat/mypgm.tex buscando la etiqueta !hello (*). TEX continuaría procesando el archivo hasta que se ejecutara una declaración de devolución o de salida , o se alcanzara el final del archivo.
Ir a ejemplo de etiqueta:
ir a /mycat/mypgm.tex!hola2
En el siguiente ejemplo, TEX procesaría el archivo /mycat/mypgm.tex buscando la etiqueta !hello2 (*). TEX continuaría procesando hasta que se alcanzara una declaración de salida o el final del archivo. Se produciría un error si se ejecutara una declaración de devolución y no hubiera CALL activas.
(*) TEX no comprobó si había etiquetas duplicadas en el mismo archivo , por lo que la ejecución era impredecible si estaba presente.
TEX proporciona los comandos SUBS y NOSUBS para activar o desactivar la sustitución de variables para declaraciones TEX o comandos TSS.
xx=/salida:"Hola mundo"/ substitutos? ?xx? no-subs ?xx?
En el ejemplo anterior, la variable xx contiene una declaración de salida TEX como valor. El comando subs especifica que (?) es el carácter de sustitución para todas las declaraciones futuras del programa. Al procesar el primer ?xx? línea, TEX sustituirá el comando out:"Hello World" por ?xx? y luego ejecutar la declaración resultante. El comando nosubs desactiva las sustituciones para declaraciones posteriores y, por lo tanto, TEX emite un error cuando intenta ejecutar el segundo ?xx? línea.
Además de la sustitución de variables, TEX admitía la dirección indirecta de variables. Se consideraba que las variables con el prefijo de guión bajo (_) contenían un nombre de variable como contenido y, por lo tanto, TEX usaría la dirección indirecta para obtener el valor. TEX limitó la dirección indirecta a 64 niveles para evitar posibles bucles.
Como ejemplo:
a="b" b="c" c="hola mundo" _ aquí out:__a imprimiría "hola mundo" en la terminal, _ ya que dos prefijos de subrayado de a significan a >> b >> c fuera:__a
Las sesiones de Honeywell Timesharing tenían un concepto de archivo de trabajo. Para editar un archivo existente, primero debe convertirlo en el archivo de trabajo mediante el comando anterior . Para crear un nuevo archivo, primero debe crearlo mediante el nuevo comando. Una vez que se completen los cambios, deberá guardar (para archivos nuevos) o volver a guardar el archivo de trabajo. Básicamente, sólo se puede abrir un archivo para editarlo a la vez.
Los programas TEX fueron diseñados principalmente para ampliar el sistema de edición de líneas. En consecuencia, TEX no tenía ningún concepto de entrada/salida de archivos, basándose en cambio en realizar cambios en el archivo de trabajo mediante comandos de edición de línea y guardarlos según fuera necesario.
Sin embargo, TEX proporcionó comandos de entrada/salida orientados a terminales:
Un ejemplo simple usando dentro y fuera :
en: "¿Cómo te llamas?" fuera:"Hola",*en
como medio para acceder a resultados/efectos secundarios de las funciones del subsistema TEX o para representar códigos de terminal ASCII. [14]
A continuación se incluye una lista de variables estrella :
Los códigos de terminales se asignaron a variables en estrella para facilitar la referencia en los programas TEX. [15]
TEX se creó sobre el editor de líneas TSS , ya que dichos comandos del editor de líneas podrían usarse dentro de un programa TEX. Los programas TEX pueden tener:
El formato de comando general fue:
verbo:<expr_búsqueda>;<cnt_repetición>;<cnt_ocurrencia>:<cadena_reemplazo>
⟨search_expr⟩ podría contener un rango como en F:/hello/,/world/ para encontrar todas las líneas que comienzan con la cadena "hello" y también contienen la cadena "world".
TEX proporcionó comandos estándar de edición de archivos basados en líneas:
Cada comando podría modificarse con un valor de repetición numérico o con un asterisco (*):
Los comandos se pueden modificar aún más con una línea que coincida con una cadena o expresión:
Para el modo de cadena, se agregó una S. Siempre que se encontraba /xxx/ dentro de la línea, se aplicaba la edición:
Por último, los comandos se pueden modificar aún más con V para activar el modo de verificación y con O para especificar el modo de cadena de ocurrencia enésima :
Hay algunos otros comandos de edición menos utilizados:
En todos los formatos de comando de edición, /xxx/ o /yyy/ o 999 se pueden reemplazar con una variable TEX. Además, el valor 999 podría sustituirse por un asterisco (*) para indicar todas las apariciones.
TEX no proporcionó comandos para bucles numéricos o condicionales o casos de cambio como es común en los lenguajes de programación modernos. Estos tuvieron que construirse usando if , etiquetas y comandos goto . Como ejemplo, para eliminar líneas duplicadas de un archivo, se usaría:
!ELIM_DUPS a=*cl f;1 _ !NEXT_LINE si *eof out: regreso "tarea completada" b=*cl si a:eqs:bd;1 ir a !NEXT_LINE a=bf;1 ir a !NEXT_LINE
Comandos TEX:
Los modos TEX definían cómo funcionarían otros comandos TEX. [16] La variable *svmd contenía el estado actual de todos los modos TEX en forma de comandos TEX para restaurar los modos. Cada modo tenía un comando inverso para desactivar el modo que se podía realizar en cualquier momento.
Aunque están fuera del alcance de este artículo, los comandos TSS más utilizados fueron:
Este código fue extraído de un juego de aventuras basado en TEX escrito por un equipo de Explorer Scouts de GE Post 635, Schenectady, Nueva York, alrededor de 1980. El juego de aventuras fue el primero de varios juegos de aventuras populares en línea basados en texto disponibles en el servicio GE Timesharing. Los exploradores decidieron crear su propio juego de aventuras utilizando TEX. El juego de aventuras original usaba comandos de dos palabras para navegar por Colossal Cave . El analizador que se muestra a continuación manejó comandos simples de dos palabras, como ir hacia el oeste o moverse hacia la derecha , y los convirtió en deltas x,y para posicionamiento y orientación direccional en el juego.
Analizando los comandos de dos palabras de Adventure:
...
_ forzar una pantalla clara en el terminal de televideo !en eso salida:*esc,":" _ borrar variables del programa rmdr=*nulo del=0 dirección="n" xlocn=1 ylocn=1 devolver
_ _______________________________________________________________ _ _ La subrutina PARSER interpreta sus comandos de entrada e intenta _ procéselos antes de regresar a su programa. _ !analizador qry=*cr,*lf,"-->" sntc=*llamada nula !ask1 ergo !unkn_cmd verbo=ans vdel=0 ir a !$ans$_cmd _ !walk_cmd del=2 llamar !move_to regresar !run_cmd del=4 llamar !move_to regresar !fly_cmd del=6 llamar !move_to regresar !swim_cmd del=2 llamar !move_to regresar ... !unkn_cmd retorno
!move_to llamar !ask3 si ans:eqs:*null ir a !to_$dir$ ercall !a_la misma llamada !to_$ans$ _ !to_locn xlocn=xlocn+xdel ylocn=ylocn+ydel retorno _ !a_f !a_reenviar !a_ahead !to_same ir a !to_$dir$ _ !to_b !to_backward ir a !inv_$dir$ _ !colina !to_right ir a !rt_$dir$ _ !to_l !to_left ir a !lt_$dir$ _ !inv_sur !rt_noroeste !lt_noreste !tonelada !to_north dir="norte" xdel=0 ydel=del retorno _ !inv_oeste !rt_noreste !lt_sureste !dedo del pie !to_east dir="este" xdel=del ydel=0 retorno _ !inv_norte !rt_sureste !lt_suroeste !a_s !to_sur dir="sur" xdel=0 ydel=-del retorno _ !inv_east !rt_suroeste !lt_noroeste !remolcar !to_west dir="oeste" xdel=-del ydel=0 retorno
_ ajuste la velocidad delta si estas palabras aparecen como en "ir muy rápido" !to_very vdel=vdel+1 ir a !to_same !to_fast del=del+vdel vdel=0 ir a !to_same !to_slow del=del-vdel vdel=0 ir a !to_same
_ ______________________________________________________________ _ _ Las subrutinas ASK obtienen la entrada de su terminal y la dividen dependiendo _ en los espacios. Ask1 cae en Ask2 y Ask2 cae en Ask3 y luego regresa. _ _ rmdr contiene el resto de la línea de entrada, sntc contiene el resto de la frase de comando actual _ las oraciones terminan con un punto. ans contiene la palabra actual que se está procesando _ !preguntar1 si rmdr:eqs:*null en:qry rmdr=*in sntc=*null !ask2 si sntc:eqs:*null scan:rmdr:"." sntc=*l rmdr=*r]'1 !ask3 escaneo:sntc:" " ans=*l sntc=*r retorno
Dados rodantes:
_ _______________________________________________________________ _ _ La subrutina DICE tira los dados por ti y devuelve la respuesta _ en la variable llamada DADOS. _ _ La entrada a la subrutina DICE se realiza a través de la variable DICE como se muestra a continuación: _ _ 1d6 - tira el dado de 6 caras una vez _ 3d8 - tira el dado de 8 caras 3 veces _ d% - tira el dado de 100 caras una vez (tirada de porcentaje) _ !dice si dice:eqs:"d%" dice="1d100" escaneo:dados:"d" i=*lj=*r dados=0 !dice_1 k=*aleatorio si j:gt:9 k=k,*aleatorio k=k/j dados=dados+*rmdr+1 i=i-1 si i:gt:0 ir a !dice_1 claro i claro j claro k devolver
Códigos de pantalla de televideo:
_ _______________________________________________________________ _ _ Las siguientes rutinas le permiten hacer dibujos fácilmente en el _ el terminal Televideo 950. _ _ xyplot: posiciona el cursor _ _ gr: activa el modo de gráficos _ _ nogr: desactiva el modo de gráficos _ _clear: borra la pantalla _ _ load: utilizado por xyplot para cargar xytbl _ !xyplot ercall !cargar xytbl=xytbl cx=(xytbl]'(x-1))']1 cy=(xytbl]'(y-1))']1 salida:*ESC,"=",cy,cx,z devolver _ _ !carga xytbl=" !",/"/,"#$%&'()*+,-./" xytbl=xytbl,"0123456789:;<=>?",*AT,"ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_" xytbl=xytbl,"`abcdefghijklmnopqrstuvwxyz{|}~",*DEL devolver _ _ !gr nosubs salida:*ESC,"$" subs $ $*SVMD$ devolución _ _ !nogr salida:*ESC,"%" retorno _ _ !clarar:*ESC,":" regresarLa característica más notable de TEX fue su modo SUBS que permitía que los valores variables se cruzaran y se convirtieran en código ejecutable. Permitió a un programador crear nuevas variables sobre la marcha para usarlas en expresiones TEX posteriores de forma similar a LISP . TEX también permitió a los programadores crear scripts sobre la marcha mediante la edición de líneas, guardando el contenido en un archivo para ejecutarlo más tarde como parte del programa actual mediante llamadas entre archivos y declaraciones goto . Sin embargo, en la mayoría de los casos, estas características se utilizaron para proporcionar declaraciones goto dinámicas simples en el código, como se ve en el ejemplo del analizador del juego de aventuras. Nunca se exploraron por completo qué otros tipos de construcciones de Inteligencia Artificial podrían desarrollarse.
Un ejemplo de cómo crear variables sobre la marcha y luego usarlas para hacer un goto entre archivos .
_ incorporar x,y,z al grupo de variables globales cmd="x=1 y=2 z=3" substitutos? ?cmd?
_ a continuación modificamos mycat/mypgm_1_2.tex para que diga "hola mundo" en el que estamos escribiendo un código _ejecutar más tarde en nuestro script _ antiguo mycat/mypgm_1_2.tex r:*cl:/!label_3 out:'Hola mundo'/ volver a guardar mycat/mypgm_1_2.tex
_ por último, substituimos en x,y,z y luego evaluamos el goto mypgm_1_2!label_3 que hace un goto entre archivos _ ir a mycat/mypgm_?x?_?y?.tex!label_?z?
El programa TEX anterior ilustra la creación de scripts dinámicos y luego su ejecución mediante sustitución, edición de archivos y goto entre archivos . En efecto, escribir programas fue posible aunque nunca se hizo. En el ejemplo anterior, el archivo mycat/mypgm_1_2.tex se ejecutaría en label_3 imprimiendo "hola mundo" .