Tiny BASIC

El Tiny BASIC es una versión muy sencilla y simplificada de un intérprete del lenguaje de programación BASIC que originalmente fue programado en assembler y cabía en tan solo 2 a 3 KB de memoria. Este pequeño tamaño resultaba muy útil en los comienzos de los primeros microcomputadores, a mediados de los años 1970, cuando el tamaño típico de la memoria RAM era de 4 a 8 KB.

Historia

El primer lenguaje consistió únicamente en un documento de estándares, escrito principalmente por Dennis Allison, un miembro de la facultad de Ciencias de la Computación en la Universidad de Stanford. Bob Albrecht, del Homebrew Computer Club, lo instó a crear el estándar. Él había visto el lenguaje BASIC en minicomputadores y creyó que encajaría perfectamente con las nuevas máquinas como el Altair 8800 de MITS, que había sido lanzada en enero de 1975.

Bob y Dennis publicaron el documento de diseño en el boletín de noticias de People's Computer Company. En diciembre de 1975, Dick Whipple y John Arnold crearon un intérprete del lenguaje que requirió solamente 3K de RAM. Bob y Dennis decidieron publicar esta versión y las correcciones a los documentos de diseño originales en un boletín de noticias dedicado al Tiny BASIC, que llamaron "Dr. Dobb's Journal of Tiny BASIC Calisthenics and Orthodontia". En las ediciones de 1976 fueron publicadas varias versiones del Tiny BASIC, incluyendo descripciones de diseño y el código fuente completo.

Gramática del Tiny BASIC

La gramática es listada abajo en la notación de Backus-Naur. En el listado, un asterisco ("*") denota cero o más del objeto a su izquierda - excepto para el primer asterisco en la definición de "term", que es el operador de la multiplicación; objetos del grupo de paréntesis; y un épsilon ("ε") significa el conjunto vacío. Como es común en la notación de la gramática de lenguaje de programación, la barra vertical ("|") distingue alternativas, al igual que ser listado en líneas separadas. El símbolo "CR" denota un retorno del carro (usualmente generado por la tecla "ENTER" de un teclado).

   line ::= number statement CR | statement CR

   statement ::= PRINT expr-list
                 IF expression relop expression THEN statement
                 GOTO expression
                 INPUT var-list
                 LET var = expression
                 GOSUB expression
                 RETURN
                 CLEAR
                 LIST
                 RUN
                 END

   expr-list ::= (string|expression) (, (string|expression)* )

   var-list ::= var (, var)*

   expression ::= (+|-|ε) term ((+|-) term)*

   term ::= factor ((*|/) factor)*

   factor ::= var | number | (expression)

   var ::= A | B | C .... | Y | Z

   number ::= digit digit*

   digit ::= 0 | 1 | 2 | 3 | ... | 8 | 9

   relop ::= < (>|=|ε) | > (<|=|ε) | =

   A BREAK from the console will interrupt execution of the program

Fuente: Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Volume 1, Number 1, 1976, p.9.

Implementación en lenguaje interpretado

Para la implementación, es usado un lenguaje interpretado (IL). Un interpretador escrito en IL interpreta una línea de código de Tiny BASIC y la ejecuta. El IL corre en una máquina abstracta, que interpreta el código IL. La idea de usar un lenguaje interpretado viene desde Val Schorre (con el META II, 1964) y Glennie (Syntax Machine). Ver también la máquina virtual, CLI.

La tabla siguiente da una lista parcial de los comandos del lenguaje interpretado en la cual el interpretador Tiny BASIC está escrito. La longitud del programa interpretador completo es de solamente 120 operaciones del IL. Así la opción de un acercamiento interpretativo economizó en espacio de memoria y esfuerzo de implementación, aunque los programas BASIC eran ejecutados algo lentamente. El CRLF en la última línea simboliza un retorno del carro (CR) seguido por una nueva línea (LF).

TST lbl, string	Si string coincide con la línea BASIC, avanza el cursor sobre el string y ejecuta la siguiente instrucción IL; si la prueba falla, ejecuta la instrucción IL en la etiqueta lbl
CALL lbl	Ejecuta la subrutina IL comenzando en lbl; guarda la dirección IL que sigue la llamada (CALL) en el stack de control
RTN	Retorna a la posición del IL especificada en el tope del stack de control
DONE	Reporta un error de sintaxis si después de borrar los blancos a la izquierda, el cursor no está posicionado para alcanzar un retorno del carro
JUMP lbl	Continúa la especificación del IL en la etiqueta especificada
PRS	Imprime caracteres del texto BASIC hasta pero no incluyendo el signo de interrogación cerrado
PRN	Imprime el número obtenido al hacer un POP en el stack de expresiones
SPC	Inserta espacios para mover el cabezal de impresión a la próxima zona
NLINE	Envía un CRLF a la impresora

Fuente: Dr. Dobb's Journal, Volume 1, Number 1, 1976, p.12.

Véase también

• Palo Alto Tiny BASIC, por Li-Chen Wang
• BASIC
• Dr. Dobb's Journal
• Copyleft

Enlaces externos

• Tiny Basic User Manual and Experimenter's Kit – by Tom Pittman
• Robert Uiterwyk's MICRO BASIC – A MC6800 tiny BASIC later sold with the SWTPC 6800 computer
• MINOL – Erik Mueller's MINOL – Tiny BASIC with strings for Intel 8080
• TBL – A similar IL to Tiny BASIC's, used in the first successful compilers for PL/I, Fortran, etc, on limited memory minicomputers
• M68000 Tiny BASIC – Based on Li-Chen Wang's Palo Alto Tiny BASIC, and published in the 100th edition of Dr. Dobb's
• Tiny BASIC – An implementation written in SmallBASIC
• tinyBasic – An implementation written in iziBasic
• Tiny BASIC – A live web version, ported to Run BASIC from iziBasic
• TinyBasic – A port of Tom Pittman's TinyBasic C interpreter to Java, C# and Adobe Flex. Includes live web versions.
• TinyBasic – A modern implementation on a 16bit Microcontroller.
• Category:Tiny BASIC Treas implementadas en Tiny BASIC en rosettacode.org
• Category:Palo Alto Tiny BASIC Tareas implementadas es Palo Alto Tiny BASIC en rosettacode.org

• Datos: Q586622