Atari BASIC es un intérprete del lenguaje de programación BASIC que se envió con la familia Atari de 8 bits de computadoras domésticas basadas en 6502 . A diferencia de la mayoría de los BASIC de la era de las computadoras domésticas, Atari BASIC no es un derivado de Microsoft BASIC y se diferencia de manera significativa. Incluye palabras clave para funciones específicas de Atari y carece de soporte para matrices de cadenas, por ejemplo.
Familia | BÁSICO |
---|---|
Diseñada por | Paul Laughton Kathleen O'Brien |
Desarrollador | Microsistemas Shepardson |
Apareció por primera vez | 1979 |
Lanzamiento estable | Revisión C / 1983 |
Plataforma | Familia Atari de 8 bits |
Licencia | Software propietario comercial |
Influenciado por | |
Datos generales empresariales básicos [1] | |
Influenciado | |
Turbo-Basic XL |
El idioma era un cartucho ROM de 8 KB para las primeras máquinas de la familia de 8 bits: 400, 800 y más tarde 1200XL. BASIC está integrado en los siguientes modelos XL y XE, pero se puede desactivar manteniendo presionada la tecla mientras se inicia. El XEGS desactiva BASIC si se alimenta sin el teclado conectado.OPTION
A pesar de que las computadoras Atari de 8 bits funcionan a mayor velocidad que la mayoría de sus contemporáneos, varias decisiones técnicas colocaron a Atari BASIC cerca de la parte inferior en los puntos de referencia de rendimiento. Los autores originales abordaron la mayoría de estos problemas en BASIC XL y BASIC XE. También apareció una gran cantidad de soluciones de terceros como Turbo-Basic XL .
El código fuente anotado completo y las especificaciones de diseño de Atari BASIC se publicaron como The Atari BASIC Source Book en 1983. [2]
Historia
Las máquinas que se convertirían en la familia Atari de 8 bits se desarrollaron originalmente como consolas de videojuegos de segunda generación destinadas a reemplazar la Atari VCS . Ray Kassar , el nuevo presidente de Atari, decidió desafiar a Apple Computer construyendo una computadora en casa. [3] Esto significó que los diseños debían incluir el lenguaje de programación BASIC , luego el estándar para computadoras domésticas.
A principios de 1978, Atari obtuvo la licencia del código fuente para la versión MOS 6502 de Microsoft BASIC . [4] Se ofreció en dos versiones: una con un formato de punto flotante de 32 bits que tenía aproximadamente 7800 bytes cuando se compiló, y otra con un formato extendido de 40 bits que estaba cerca de 9 kB. [5]
Incluso la versión de 32 bits apenas cabe en el tamaño de 8 kB del formato de cartucho ROM de la máquina . Atari también sintió que necesitaban expandir el lenguaje para admitir las características de hardware de sus computadoras, similar a lo que Apple había hecho con Applesoft BASIC . Esto aumentó el tamaño de la versión de Atari a alrededor de 11 kB; AppleSoft BASIC en el Apple II + tenía 10240 bytes de longitud. [a] Después de seis meses, el código se redujo para casi caber en una ROM de 8 kB, [4] pero Atari se enfrentaba a una fecha límite de enero de 1979 para el Consumer Electronics Show (CES), donde las máquinas serían demostradas. Decidieron pedir ayuda para preparar una versión de BASIC a tiempo para el programa. [4]
Microsistemas Shepardson
En septiembre de 1978, Shepardson Microsystems ganó la licitación para completar BASIC [4] y estaba terminando Cromemco 16K Structured BASIC para las máquinas de autobús Cromemco S-100 basadas en Z80 . [6] [7] Los desarrolladores Kathleen O'Brien y Paul Laughton utilizaron Data General Basic, una implementación de solo enteros, como inspiración para su BASIC, dada la experiencia de Laughton con Data General en un sistema de tiempo compartido . [8]
Lo que se convirtió en Atari BASIC es una versión reducida de Cromemco BASIC trasladada al 6502. Eso necesitaba 10K de código. [9] Para que quepa en el cartucho 8K de Atari, algunas de las rutinas comunes se trasladaron a las ROM del sistema operativo . Esto incluyó 1780 bytes para soporte de punto flotante que se colocaron en una ROM de 2K separada en la placa base. [4]
Atari aceptó la propuesta, y cuando se finalizaron las especificaciones en octubre de 1978, Paul Laughton y Kathleen O'Brien comenzaron a trabajar en el nuevo lenguaje. [4] El contrato especificaba la fecha de entrega a más tardar el 6 de abril de 1979 y esto también incluía un sistema de gestión de archivos (más tarde conocido como DOS 1.0). [9] Los planes de Atari eran llevar una versión temprana de 8K de Microsoft BASIC al CES de 1979 y luego cambiar a Atari BASIC para la producción. El desarrollo procedió rápidamente, ayudado por una cláusula de bonificación en el contrato, y Atari llevó una versión de cartucho de 8K a CES en lugar de la de Microsoft. [10] Posteriormente, Atari Microsoft BASIC estuvo disponible como un producto separado. [11]
Lanzamientos
Se suponía que la versión que Shepardson le dio a Atari para la demostración de CES no era la versión final. Entre el momento en que entregaron la demostración y la entrega final unas semanas después, Shepardson corrigió varios errores en el código. [10] Sin que Shepardson lo supiera, Atari ya había enviado la versión CES a la fabricación. [12]
Esta versión fue más tarde conocido como Revisión A . Contiene un error importante en una subrutina que copia la memoria; eliminar líneas de código que tenían exactamente 256 bytes de longitud provoca un bloqueo. Esto a veces se conocía como el "bloqueo de dos líneas" porque no se activaba hasta que se ingresaba la siguiente línea de código o comando. No se puede arreglar presionando la Resettecla. [13]
La Revisión B intentó corregir todos los errores principales de la Revisión A y fue lanzada en 1983 como una ROM incorporada en los modelos 600XL y 800XL. Mientras arreglaba el error de copia de memoria, el programador notó el mismo patrón de código en la sección para insertar líneas y aplicó la misma corrección. En cambio, esto introdujo el error original en este código. Insertar nuevas líneas es mucho más común que eliminar las antiguas, por lo que el cambio aumentó drásticamente el número de bloqueos. [13] La revisión B también contiene un error que agrega 16 bytes a un programa cada vez que es SAVE
d y LOAD
ed, causando eventualmente que la máquina se quede sin memoria incluso para los programas más pequeños. [14] [15] Mapping the Atari describió estos como "errores asombrosos" y aconsejó a los propietarios de la Revisión B "No pierdas el tiempo; obtén la nueva ROM, que está disponible en cartucho" de Atari. [15] El libro proporciona un programa de escritura para parchear la Revisión B a la Revisión C para aquellos que no tienen el cartucho. [dieciséis]
La Revisión C elimina las pérdidas de memoria en la Revisión B. [15] Está integrado en versiones posteriores del 800XL [14] y todos los modelos XE, incluido el XEGS. La revisión C también estaba disponible como cartucho. [15]
La versión se puede determinar escribiendo PRINT PEEK(43234)
en el indicador LISTO. El resultado es 162
para la revisión A, 96
para la revisión B y 234
para la revisión C. [17]
Descripción
Edición de programas
Como la mayoría de los BASIC de computadoras hogareñas, Atari BASIC se basa en su editor de líneas . Las líneas de programa pueden tener hasta tres líneas de pantalla física de 40 caracteres, 120 caracteres en total. El cursor se puede mover libremente, con el editor rastreando automáticamente de qué línea de programa BÁSICO forma parte la línea de pantalla actual. Por ejemplo, si el cursor está actualmente posicionado en la línea 30 y el usuario usa el cursor hacia arriba en la línea 20, cualquier edición desde ese punto se llevará a cabo en la línea 20.
El editor de Atari BASIC detecta muchos errores que no se notarían en las versiones derivadas de MS. Si se encuentra un error, el editor vuelve a mostrar la línea, resaltando el texto cerca del error en video inverso . Los errores se muestran como códigos numéricos, con las descripciones impresas en el manual. [18] Debido a la forma en que funciona el editor de líneas, el usuario puede corregir el error inmediatamente. En el ejemplo que se muestra arriba (con PRUNT
), el error se puede corregir moviendo el cursor sobre el U
, escribiendo I(el editor solo tiene un modo de sobrescritura) y presionando RETURN.
Una línea ingresada con un número inicial, de 0 a 32767, [19] se inserta en el programa actual o reemplaza una línea existente. Si no hay número de línea, el intérprete le asigna el número -1 (8000 16 ) y los comandos se ejecutan inmediatamente, en "modo inmediato". El RUN
comando ejecuta el programa almacenado desde el número de línea más bajo. Atari BASIC permite que todos los comandos se ejecuten en ambos modos. Por ejemplo, LIST
se puede usar dentro de un programa, mientras que en muchos intérpretes esto estaría disponible solo en modo inmediato.
Durante la entrada, las palabras clave se pueden abreviar utilizando el patrón establecido por Palo Alto Tiny BASIC , escribiendo un punto en cualquier punto de la palabra. Entonces L.
se expande a LIST
, como está LI.
. Solo se deben escribir las letras suficientes para que la abreviatura sea única, por lo que es PLOT
necesario PL.
porque la letra P no es única. Para expandir una abreviatura, el tokenizador busca en su lista de palabras reservadas para encontrar la primera que coincida con la parte proporcionada. Los comandos más utilizados aparecen primero en la lista de palabras reservadas, con REM
al principio (se puede escribir como .
). Cuando el programa se LIST
edita más tarde, siempre escribirá las palabras completas con tres excepciones: PRINT
tiene un sinónimo ?
; GOTO
tiene un sinónimo GO TO
; y LET
tiene un sinónimo que es la cadena vacía (entonces y significan lo mismo). Estos son tokens separados y, por lo tanto, permanecerán como tales en la lista del programa. MS BASIC también se permitió como una forma abreviada de , pero esto usó el mismo token, por lo que se expandió de nuevo a cuando ed, tratándolo como una abreviatura, no como un sinónimo.10 LET A = 10
10 A = 10
?
PRINT
PRINT
LIST
El tokenizador
Cuando el usuario presiona RETURNdurante la edición, la línea actual se copia en el Búfer de línea de entrada BÁSICO en la memoria entre 580 y 5FF 16 . [19] El tokenizador de Atari BASIC luego escanea el texto y lo convierte en tokens de un solo byte almacenados en el búfer de salida del token. El búfer de salida se encuentra en los primeros 256 bytes de la memoria libre disponible más baja, señalada por el puntero LOMEM almacenado en 80, 81 16 . [19] La salida del tokenizador se mueve a un almacenamiento más permanente en varias ubicaciones de la memoria. El programa se almacena como un árbol de análisis . [B]
Como es el caso con la mayoría de los BÁSICOS de la época, todas las palabras clave se convierten en un token de un byte. Por ejemplo, PRINT
se convierte en 20 16 . [20] Este proceso ayuda al sistema de dos formas. Debido a que la palabra clave original (en este caso) de cinco letras se reemplaza por un solo byte, el código de programa resultante puede ser significativamente más pequeño en la memoria. Esto también ayuda en gran medida al rendimiento en tiempo de ejecución, ya que no es necesario escanear el mismo texto cada vez que se encuentra, sino que se escanea solo una vez en el momento de la edición. [19]
Atari BASIC difiere mucho de la mayoría de los BASIC de la época, notablemente Microsoft BASIC, que fue ampliamente utilizado, en que toda la línea se convierte a su versión en tiempo de ejecución. En MS BASIC, cualquier elemento que no sea una palabra clave (nombres de variable, constantes numéricas, cadenas, etc.) se deja en su formato de texto original. En tiempo de ejecución, cada vez que se encuentran estos elementos, deben leerse y convertirse al formato interno, lo que podría significar que una constante numérica como "100" tendrá que convertirse a su formato de punto flotante interno una y otra vez. Incluso un elemento como una constante de cadena, que se almacena principalmente en su formato original, aún requiere que MS BASIC escanee la línea de texto para encontrar la comilla de cierre final. [20]
Por el contrario, cuando Atari BASIC encuentra este valor, primero colocará un token en la salida indicando que sigue una constante. Luego ejecuta la rutina de conversión de texto a número inmediatamente para convertirlo a su formato decimal codificado en binario de 40 bits . El valor de seis bytes resultante se coloca en el búfer de salida y ya no es necesario escanearlo. Las constantes de cadena se escanean y su longitud se coloca en la línea tokenizada, evitando esta tarea en tiempo de ejecución. Del mismo modo, mientras que las variables en MS BASIC se configuran en una tabla en la memoria cuando se encuentran por primera vez durante el tiempo de ejecución, en Atari BASIC esto se realiza durante la tokenización y el nombre de la variable original en el texto se reemplaza por un solo byte que apunta al almacenamiento resultante. [21] Durante el tiempo de ejecución, MS tiene que buscar en la tabla de nombres de variables cada vez que encuentra un nombre de variable, mientras que Atari BASIC tiene acceso inmediato a través de un puntero.
Shepardson se refirió a este concepto de tokenización completa como un "intérprete de compilación previa". [22] El código resultante completamente tokenizado tiene la ventaja de eliminar cualquier análisis durante el tiempo de ejecución, lo que tiene la ventaja potencial de hacer que se ejecute más rápido. Tiene la desventaja de que las constantes pequeñas, como 0 o 1, se almacenan internamente como valores de seis bytes, lo que potencialmente hace que el código tokenizado resultante sea más largo que el texto original. Por lo tanto, aunque el búfer de texto de entrada tiene solo 120 bytes y la salida es 256, existe la posibilidad de que el búfer de salida se desborde, lo que da como resultado un error 14 - línea demasiado larga. [23]
Un conjunto de punteros (direcciones) indica varios datos: los nombres de las variables se almacenan en la tabla de nombres de variables (VNTP - 82, 83 16 ) y sus valores se almacenan en la tabla de valores de variables (apuntados a VVTP - 86, 87 16 ). Direccionando indirectamente los nombres de las variables de esta manera, una referencia a una variable necesita solo un byte para direccionar su entrada en la tabla apropiada. Las variables de cadena tienen su propia área (apuntada a STARP - 8C, 8D 16 ) al igual que la pila de tiempo de ejecución (apuntada a RUNSTK - 8E, 8F 16 ) utilizada para almacenar los números de línea de las sentencias en bucle ( FOR...NEXT
) y subrutinas ( GOSUB...RETURN
). Finalmente, el final del uso de la memoria BÁSICA se indica mediante una dirección almacenada en el puntero MEMTOP - 90, 91 16 ).
Funciones matematicas
Atari BASIC incluye tres funciones trigonométricas: seno, coseno y arco tangente. DEG
y RAD
establezca si estas funciones usan radianes o grados, por defecto en radianes.
Ocho funciones adicionales incluyen redondeo, logaritmos y raíz cuadrada. La función aleatoria RND
, genera un número entre 0 y 1, sin el parámetro de la función que se utiliza.
Manejo de cuerdas
Atari BASIC se diferencia considerablemente de los BASIC de estilo de Microsoft en la forma en que maneja las cadenas. Microsoft BASIC mayoría copiar el sistema de manejo de series de DEC 's -PLUS BASIC tipos, en los que las cadenas son de primera clase con longitudes variables y límites. Esto permite tanto variables de cadena como matrices de cadenas, ya que ambas están representadas internamente por una palabra de computadora que apunta al almacenamiento en un montón .
Por el contrario, Atari BASIC copió el sistema de manejo de cadenas de Hewlett-Packard BASIC , donde el tipo de datos básico es un solo carácter y las cadenas son matrices de caracteres. Una cadena está representada por un puntero al primer carácter de la cadena y su longitud. Para inicializar una cadena, se debe DIMensionar con su longitud máxima, dejando de lado la cantidad requerida de memoria en el montón. Por ejemplo:
10 DIM A $ ( 20 ) 20 IMPRIMIR "INTRODUZCA MENSAJE:" ; 30 ENTRAR A $ 40 IMPRIMIR A $
En este programa, se reserva una cadena de 20 caracteres y se truncarán los caracteres que excedan la longitud de la cadena. La longitud máxima posible de una cadena en Atari BASIC es 32,768 caracteres.
MS BASIC incluye funciones para acceder a partes de cadenas. Por ejemplo, LEFT$(A$,10)
devuelve los primeros 10 caracteres de A$
. Estas funciones crean nuevas cadenas en el montón y devuelven un puntero al inicio de la nueva cadena. En Atari BASIC, la cadena está representada por una matriz y se accede a ella mediante funciones de indexación de matrices, o "corte" . La declaración equivalente en Atari BASIC sería A$(1,10)
; las matrices tienen un índice 1, no un índice 0, por lo que una cadena de longitud 10 comienza en 1 (no 0) y termina en 10. Porque la sintaxis de corte era la misma que la sintaxis para seleccionar una cadena en una matriz bidimensional en otros BASIC, no había forma de definir o trabajar con matrices de cadenas.
Una ventaja importante de este estilo de acceso es que las funciones de corte no crean nuevas cadenas, simplemente establecen punteros a los puntos inicial y final dentro de la memoria asignada existente. MS BASIC era conocido por quedarse sin espacio en el montón en dichos programas y por entrar en retrasos prolongados en la recolección de basura mientras que las cadenas temporales anteriores se eliminaban de la memoria. Atari BASIC crea nuevas entradas de montón solo con los comandos DIM explícitos, por lo que se elimina la administración de memoria. Esto ofrece una gran ventaja en términos de rendimiento y uso de memoria en programas con cantidades significativas de procesamiento de cadenas.
Atari BASIC no inicializa variables de matriz, y una cadena o matriz numérica contendrá cualquier dato que estuviera presente en la memoria cuando fue asignado. El siguiente truco permite una rápida inicialización de cadenas y también es útil para limpiar grandes áreas de memoria de basura no deseada. Las matrices numéricas solo se pueden borrar con un bucle FOR ... NEXT:
10 REM Inicializar A $ con 1000 caracteres de X 20 DIM A $ ( 1000 ) 30 A $ = "X" : A $ ( 1000 ) = A $ : A $ ( 2 ) = A $
La concatenación de cadenas en Atari BASIC funciona como en el siguiente ejemplo. La cadena de destino debe ser lo suficientemente grande para contener la cadena combinada o se producirá un error:
10 DIM A $ ( 12 ), B $ ( 6 ) 20 A $ = "Hola" : B $ = "¡ahí!" 30 A $ ( LEN ( A $ ) + 1 ) = B $ 40 IMPRIMIR A $
La instrucción INPUT no se puede utilizar con una solicitud ni con variables de matriz. Este último debe completarse indirectamente a través de una declaración como 20 ENTRADA A: B (1) = A. Las variables de matriz en Atari BASIC también pueden contener dos subíndices.
Las cadenas incluidas en las declaraciones DATA no tienen que estar entre comillas en Atari BASIC, como resultado, tampoco es posible que los elementos de datos contengan una coma. La instrucción READ tampoco se puede utilizar con variables de matriz.
Las matrices tienen un índice base de 0, por lo que una declaración como DIM A (10) en realidad crea una matriz de 11 elementos (elementos 0-10).
De entrada y salida
El sistema operativo Atari incluye un subsistema para la entrada / salida (E / S) de dispositivos periféricos conocido como CIO (entrada / salida central). La mayoría de los programas se pueden escribir independientemente del dispositivo que utilicen, ya que todos se ajustan a una interfaz común; esto era raro en las computadoras domésticas en ese momento. Los nuevos controladores de dispositivos podrían escribirse con bastante facilidad y estar automáticamente disponibles para Atari BASIC y cualquier otro programa que utilice el sistema operativo Atari, y los controladores existentes podrían ser reemplazados o aumentados por otros nuevos. Una E: de reemplazo , por ejemplo, podría desplazar la que está en la ROM para proporcionar una pantalla de 80 columnas, o llevarla a cuestas para generar una suma de comprobación cada vez que se devuelve una línea (como la que se usa para verificar una lista de programas tecleados).
Atari BASIC admite el acceso de CIO con palabras reservadas OPEN #, CLOSE #, PRINT #, INPUT #, GET #, PUT #, NOTE #, POINT # y XIO # . Hay rutinas en el sistema operativo para el relleno y el dibujo de gráficos, pero no todas están disponibles como palabras clave específicas de BASIC. PARCELA y DRAWTO para dibujo de líneas es compatible, mientras que un comando que proporciona relleno de área no lo es. La función de relleno se puede utilizar a través del punto de entrada general CIO, que se llama mediante el comando BASIC XIO .
La declaración BASIC OPEN # prepara un dispositivo para el acceso de E / S:
10 REM Abre el dispositivo de casete en el canal 1 para leer en BASIC 20 OPEN # 1 , 4 , 0 , "C: MYPROG.DAT"
Aquí, OPEN # significa "asegúrese de que el canal 1 esté libre", llame al C: controlador para preparar el dispositivo (esto pondrá a tensión los carretes de cinta de casete y avanzará los cabezales manteniendo el reproductor de casete en "pausa". 4 significa "leer" (otros códigos son 8 para escribir y 12 = 8 + 4 para "leer y escribir"). El tercer número es información auxiliar, puesto a 0 cuando no se necesita. La C: MYPROG.DAT es el nombre del dispositivo y el nombre del archivo; el nombre de archivo se ignora para el controlador de casete. Los dispositivos físicos pueden tener números (principalmente discos, impresoras y dispositivos serie), por lo que " P1: "podría ser el trazador y" P2: "la impresora de margarita, o" D1: "puede ser una unidad de disco y" D2: "y así sucesivamente. Si no está presente, se supone 1.
La instrucción LPRINT se utiliza para enviar cadenas a la impresora.
Atari BASIC no incluye un equivalente de Microsoft BASIC OBTENER o INKEY $ comandos para detectar una pulsación de tecla, esto puede ser simulado por PULSAR directamente el controlador del teclado o abrirlo como un archivo (por ejemplo ), aunque este último esperará una pulsación de tecla a diferencia de OPEN 1,4,0,"K:":GET #1,A$
OBTENER o INKEY $ .
Escribir DOSdesde BASIC saldrá al menú de comandos de Atari DOS . Se perderán todos los programas que no se hayan guardado. No hay ningún comando para mostrar un directorio de disco desde BASIC y esto debe hacerse saliendo a DOS.
DOS ocupa aproximadamente 5k de memoria, por lo que una máquina Atari basada en casetes (48k o más) tendrá alrededor de 37,000 bytes de memoria de programa BASIC libre y 32,000 bytes si DOS está presente. BASIC no puede usar la RAM adicional en máquinas XL y XE.
Soporte de gráficos y sonido
Atari BASIC tiene soporte de sonido incorporado, (a través del Declaración SOUND ), configurando los gráficos de la pantalla ( GRÁFICOS, SETCOLOR , gráficos de dibujo COLOR, PLOT, DRAWTO ), joysticks ( STICK, STRIG ) y paletas ( PADEL, PTRIG ). El sistema operativo subyacente incluía una rutina para rellenar formas arbitrarias, pero BASIC no tenía una Comando PAINT y en su lugar tuvo que ser llamado con el Comando XIO . [24]
No hay un comando dedicado para limpiar la pantalla en Atari BASIC, esto generalmente se hace con , el cual IMPRIME el código de control de pantalla clara (análogo a en Commodore BASIC). Atari BASIC no incluye una función TAB; esto se puede simular presionando la posición de la columna del cursor en $ 55 o la posición de la pestaña en $ C9, que tiene un valor predeterminado de 10. Los valores modificados no tendrán efecto hasta que se ejecute una instrucción PRINT. Tampoco hay función SPC en Atari BASIC.PRINT CHR$(125)
PRINT CHR$(147)
Los aspectos avanzados del hardware, como los gráficos de jugador / misil ( sprites ), los conjuntos de caracteres redefinidos, el desplazamiento y los modos de gráficos personalizados no son compatibles con BASIC; estos requerirán rutinas de lenguaje de máquina o declaraciones PEEK / POKE. No se puede acceder a algunos modos gráficos desde BASIC en el Atari 400/800 ya que las ROM del sistema operativo no los admiten; la única forma de acceder a ellos es en lenguaje de máquina configurando los registros ANTIC y la Lista de visualización manualmente. Las ROM del sistema operativo en el XL / XE agregaron soporte para estos modos. [25]
Los modos de mapa de bits en BASIC normalmente están configurados para tener una ventana de texto que ocupa las últimas cuatro filas en la parte inferior de la pantalla para que el usuario pueda mostrar mensajes e ingresar datos en un programa. Si se agrega un 16 al número de modo invocado a través de la instrucción GRAPHICS, toda la pantalla estará en modo de mapa de bits (por ejemplo, GRÁFICOS 8 + 16). Si se invoca el modo de mapa de bits en pantalla completa, Atari BASIC volverá automáticamente al modo de texto cuando finalice la ejecución del programa, a diferencia de muchos otros BASIC que dejan al usuario en modo de mapa de bits y tienen una pantalla ilegible que solo se puede cambiar escribiendo una persiana. comando o reiniciar la computadora.
Las coordenadas del mapa de bits se calculan en el rango de 0 al máximo de fila / columna menos uno, por lo tanto, en el Modo 6 (160x192), las coordenadas máximas para un píxel pueden ser 159 y 191. Si el usuario supera las coordenadas permitidas para el modo, BÁSICO saldrá con un error.
Técnicas avanzadas
Etiquetas de línea
Atari BASIC permite utilizar variables y expresiones numéricas para proporcionar números de línea GOTO
y GOSUB
comandos. Por ejemplo, una subrutina que borra la pantalla se puede escribir como GOSUB CLEARSCREEN
, que es más fácil de entender que GOSUB 10000
.
Incluye
La mayoría de los BASIC de la época permiten que el LIST
comando envíe el código fuente a una impresora u otro dispositivo. Atari BASIC también incluye el ENTER
comando, que lee el código fuente de un dispositivo y lo fusiona de nuevo con el programa, como si el usuario lo hubiera escrito. Esto permite que los programas se guarden en secciones, leyéndolos en el uso ENTER
para fusionar o reemplazar los existentes. código. Al usar cuidadosamente bloques de números de línea que no se superponen, los programadores pueden construir bibliotecas de subrutinas y fusionarlas en nuevos programas según sea necesario.
Lenguaje de máquina incorporado
Atari BASIC puede llamar subrutinas de código de máquina. El código de la máquina generalmente se almacena en cadenas, que pueden estar en cualquier lugar de la memoria, por lo que el código debe ser independiente de la posición, o en el área de 256 bytes (comenzando en la dirección 1536 10 , 600 16 ), que no es utilizada por BASIC o el sistema operativo. El código se puede cargar en la página 6 leyéndolo de las DATA
declaraciones.
El código de máquina se invoca con la USR
función. El primer parámetro es la dirección de la rutina del código máquina y los siguientes valores son parámetros. Por ejemplo, si el código del lenguaje de la máquina se almacena en una cadena con el nombre, ROUTINE$
se puede llamar con parámetros como .ANSWER=USR(ADR(ROUTINE$),VAR1,VAR2)
Los parámetros se insertan en la pila de hardware como enteros de 16 bits en el orden especificado en la USR
función en orden de byte bajo y byte alto. El último valor enviado a la pila es un byte que indica el número de argumentos. El código de lenguaje de máquina debe eliminar todos estos valores antes de regresar a través de la RTS
instrucción. Se puede devolver un valor al programa BASIC colocándolo en las direcciones 212 10 y 213 10 (D4 16 y D5 16 ) como un entero de 16 bits.
Actuación
En teoría, Atari BASIC debería ejecutarse más rápido que los BASIC contemporáneos basados en el patrón MS. Debido a que el código fuente está completamente tokenizado cuando se ingresa, todos los pasos de tokenización y análisis ya están completos. Incluso las operaciones matemáticas complejas están listas para ejecutarse, con cualquier constante numérica ya convertida al formato interno de 40 bits, y los valores de las variables se buscan por dirección en lugar de tener que buscarlos. [c] A pesar de estas ventajas teóricas, en la práctica, Atari BASIC es más lento que otras computadoras domésticas BASIC, a menudo en gran medida. [26]
En dos puntos de referencia ampliamente utilizados de la época, Sieve of Eratosthenes de la revista Byte y la prueba de referencia de Creative Computing escrita por David H. Ahl , el Atari terminó cerca del final de la lista en términos de rendimiento y fue mucho más lento que el Apple II contemporáneo. o Commodore PET , [27] a pesar de tener la misma CPU pero ejecutándola aproximadamente al doble de la velocidad de cualquiera. Terminó detrás de máquinas relativamente lentas como la Sinclair ZX81 e incluso algunas calculadoras programables. [28]
La mayor parte de la lentitud del lenguaje se debió a tres problemas. [26]
La primera es que las rutinas matemáticas de punto flotante estaban mal optimizadas. En el punto de referencia Ahl, una operación de un solo exponente, que internamente recorre la función de multiplicación lenta, fue responsable de gran parte del mal rendimiento de la máquina. [26]
Además de realizar la mayoría de las operaciones matemáticas lentamente, la conversión entre el formato de punto flotante interno y los enteros de 16 bits utilizados en ciertas partes del lenguaje fue relativamente lenta. Internamente, estos enteros se usaron para números de línea e indexación de matrices, junto con algunas otras tareas, pero los números en el programa tokenizado siempre se almacenaron en formato decimal codificado en binario (BCD). [29] Siempre que se encuentre uno de estos, por ejemplo, en el número de línea en GOTO 100
, el valor BCD tokenizado debe convertirse en un número entero, una operación que puede tardar hasta 3500 microsegundos. [30] Otros BASIC evitaron este retraso al convertir en mayúsculas y minúsculas la conversión de números que solo podrían ser enteros, como el número de línea que sigue a GOTO
, cambiando a código especial ASCII a entero para mejorar el rendimiento.
Otro problema se debe a cómo Atari BASIC implementó las ramas. Para realizar una bifurcación en un GOTO
o GOSUB
, el intérprete busca en todo el programa el número de línea coincidente que necesita. [31] Una mejora menor encontrada en la mayoría de los BASIC derivados de Microsoft es comparar el número de línea de destino con el número de línea actual y buscar hacia adelante desde ese punto si es mayor, o comenzar desde arriba si es menor. Esta mejora faltaba en Atari BASIC. [26]
El problema más grave fue la implementación de FOR
... NEXT
bucles. Casi todos los BASIC, incluidas las versiones derivadas de MS, empujarían un puntero a la ubicación del FOR
en una pila, de modo que cuando llegara al NEXT
, podría volver fácilmente al de FOR
nuevo en una sola operación de rama. En su lugar, Atari BASIC presionó el número de línea. Esto significaba que cada vez que NEXT
se encontraba un, el sistema tenía que buscar en todo el programa para encontrar la FOR
línea correspondiente . Como resultado, cualquier bucle en un programa Atari BASIC causa una gran pérdida de rendimiento en relación con otros BASIC. [26]
Varios BASIC para Atari abordaron algunos o todos estos problemas, lo que resultó en grandes ganancias de rendimiento. BASIC XL redujo el tiempo de referencia de Byte de 194 a 58 segundos, [26] tres veces más rápido. Esto se logró mediante el almacenamiento en caché de la ubicación de los FOR/NEXT
bucles, como en otros BASIC, y también se utilizó esta misma caché para realizar búsquedas de líneas GOTO
y realizar GOSUB
mejoras adicionales. Turbo-Basic XL incluyó una solución diferente al problema de búsqueda de líneas, así como una biblioteca de punto flotante reescrita y de alto rendimiento. En el benchmark Ahl, Atari BASIC requirió 405 segundos, mientras que exactamente el mismo código en Turbo BASIC tomó 41.6 segundos, una mejora de orden de magnitud. [32]
Diferencias con Microsoft BASIC
- Las siguientes palabras clave no están en Atari BASIC:
INKEY$
,CLS
,DEF FN
,TAB
,ELSE
. - Todas las matrices deben dimensionarse antes de su uso, mientras que Microsoft BASIC predetermina una matriz a 10 elementos si no están dimensionadas.
- Las variables de cadena se tratan como matrices y deben dimensionarse antes de su uso.
- Atari BASIC no permite matrices de cadenas o concatenación de cadenas.
- No hay soporte para variables enteras.
- No hay operadores bit a bit.
- Los nombres de las variables pueden tener una longitud arbitraria.
INPUT
no puede incluir un mensaje.PRINT
puede abreviarse como?
en Microsoft BASIC, pero Atari BASIC no lo convierte enPRINT
.LIST
-ing un programa todavía muestra el signo de interrogación.- El destino de
GOTO
yGOSUB
puede ser una variable o expresión. FOR..NEXT
Los bucles en Atari BASIC deben tener un nombre de variable referenciado por laNEXT
declaración, mientras que Microsoft BASIC no lo requiere.- No se permiten múltiples variables con
NEXT
declaraciones, ya que están en Microsoft BASIC (por ejemplo,NEXT X,Y
). LIST
utiliza una coma para separar un rango en lugar de un signo menos.
Palabras clave
Palabra clave | Descripción |
---|---|
abdominales | Devuelve el valor absoluto de un número. |
ADR | Devuelve la dirección en la memoria de una variable (se usa principalmente para rutinas de código de máquina almacenadas en variables) |
Y | Conjunción lógica |
ASC | Devuelve el valor ATASCII de un carácter. |
ATN | Devuelve el arcotangente de un número. |
ADIÓS | Transfiere el control al programa interno "Self Test" ("Bloc de notas" en los primeros modelos) |
CHR $ | Devuelve un carácter dado un valor ATASCII |
CLOAD | Carga desde la cinta de casete un programa tokenizado que se guardó con CSAVE |
OBSTRUIR | Devuelve el logaritmo común de un número. |
CERCA | Termina las transferencias pendientes (descarga) y cierra un canal de E / S |
CLR | Borra la memoria de las variables y la pila de programas |
COLOR | Elige en qué color lógico dibujar |
COM | Se canceló la implementación de COMMON de MS Basic. Reconocido, pero el código para DIM se ejecuta en su lugar |
CONT | Reanuda la ejecución de un programa después de una PARADA en el siguiente número de línea (ver PARADA) |
COS | Devuelve el coseno de un número. |
CSAVE | Guarda en una cinta de casete un programa en forma de token (ver CLOAD) |
DATOS | Almacena datos en listas de valores numéricos o de cadena |
DEG | Cambia las funciones trigonométricas para calcular en grados ( radianes es el modo predeterminado) (ver RAD) |
OSCURO | Define el tamaño de una cadena o matriz (ver COM) |
DOS | Transfiere el control al sistema operativo de disco (DOS); si DOS no se cargó, igual que BYE |
SEÑALAR A | Dibuja una línea a las coordenadas dadas |
FINAL | Finaliza la ejecución del programa, cierra los canales de E / S abiertos y detiene cualquier sonido |
INGRESAR | Carga y fusiona en la memoria un programa de texto sin formato desde un dispositivo externo, generalmente desde una cinta de casete o un disco (ver LISTA) |
Exp | Funcion exponencial |
POR | Inicia un bucle for |
FRE | Devuelve la cantidad de memoria libre en bytes. |
OBTENER | Lee un byte de un canal de E / S (consulte PUT) |
GOSUB | Salta a una subrutina en una línea dada en el programa, colocando la dirección de retorno en la pila (ver POP y RETURN) |
GOTO e IR A | Salta a una línea determinada del programa. GOTO se puede omitir en "SI ... ENTONCES GOTO ..." |
GRÁFICOS | Establece el modo de gráficos |
SI | Ejecuta código dependiendo de si una condición es verdadera o no |
APORTE | Recupera un flujo de texto de un canal de E / S; generalmente datos del teclado (predeterminado), cinta de casete o disco |
EN T | Devuelve el piso de un número |
LEN | Devuelve la longitud de una cadena. |
DEJAR | Asigna un valor a una variable. LET se puede omitir |
LISTA | Enumera (todo o parte de) el programa en la pantalla (predeterminado), la impresora, el disco, la cinta de casete o cualquier otro dispositivo externo (consulte ENTRAR) |
CARGA | Carga un programa tokenizado desde un dispositivo externo; generalmente una cinta de casete o un disco (ver GUARDAR) |
LOCALIZAR | Almacena el color lógico o el carácter ATASCII en coordenadas dadas |
INICIAR SESIÓN | Devuelve el logaritmo natural de un número. |
LPRINT | Imprime texto en un dispositivo de impresión (se puede lograr el mismo resultado con las declaraciones OPEN, PRINT y CLOSE) |
NUEVO | Borra el programa y todas las variables de la memoria; se ejecuta automáticamente antes de una CARGA o una CLOAD |
SIGUIENTE | Continúa la siguiente iteración de un bucle FOR |
NO | Negación lógica |
NOTA | Devuelve la posición actual en un canal de E / S |
EN | Un goto o gosub calculado: realiza un salto basado en el valor de una expresión |
ABIERTO | Inicializa un canal de E / S |
O | Disyunción lógica |
PALETA | Devuelve la posición de un controlador de paleta |
OJEADA | Devuelve el valor en una dirección en la memoria. |
GRÁFICO | Dibuja un punto en las coordenadas dadas |
PUNTO | Establece la posición actual en un canal de E / S |
DAR UN TOQUE | Establece un valor en una dirección en la memoria |
MÚSICA POP | Elimina una dirección de retorno de subrutina de la pila (consulte GOSUB y RETURN) |
POSICIÓN | Establece la posición del cursor de gráficos. |
IMPRIMIR y? | Escribe texto en un canal de E / S; generalmente a la pantalla (predeterminado), impresora, cinta de casete o disco (consulte LPRINT e INPUT) |
PTRIG | Indica si se presiona o no un gatillo de paleta |
PONER | Escribe un byte en un canal de E / S (consulte GET) |
RAD | Cambia las funciones trigonométricas para calcular en radianes (ver DEG) |
LEER | Lee datos de una declaración de DATOS |
movimiento rápido del ojo | Marca un comentario en un programa |
RESTAURAR | Establece la posición de dónde leer los datos de una declaración de DATOS |
REGRESO | Finaliza una subrutina, ramificándose efectivamente a la línea que sigue inmediatamente a la "llamada" GOSUB (ver GOSUB y POP) |
RND | Devuelve un número pseudoaleatorio |
CORRER | Inicia la ejecución de un programa, cargándolo opcionalmente desde un dispositivo externo (ver CARGAR) |
AHORRAR | Escribe un programa tokenizado en un dispositivo externo; generalmente una cinta de casete o un disco (ver CARGA) |
SETCOLOR | Asigna un color lógico a un color físico |
SGN | Devuelve el signo de un número. |
PECADO | Devuelve el seno de un número |
SONAR | Inicia o detiene la reproducción de un tono en un canal de sonido (consulte FIN) |
SQR | Devuelve la raíz cuadrada de un número. |
ESTADO | Devuelve el estado de un canal de E / S |
PASO | Indica el incremento utilizado en un bucle FOR |
PALO | Devuelve una posición de joystick |
DETENER | Detiene el programa, lo que permite reanudarlo más tarde (ver CONT) |
STRIG | Indica si se presiona un gatillo de joystick o no |
STR $ | Convierte un número en forma de cadena |
LUEGO | Indica las declaraciones a ejecutar si la condición es verdadera en una declaración IF |
A | Indica la condición límite en una instrucción FOR |
TRAMPA | Se establece para saltar a una línea de programa dada si ocurre un error (TRAP 40000 cancela esta orden) |
USR | Llama a una rutina de código de máquina, opcionalmente con parámetros |
VAL | Devuelve el valor numérico de una cadena. |
XIO | Rutina de E / S de uso general (desde las instrucciones "Llenar pantalla" a "Cambiar nombre de archivo" a "Formatear disco") |
Ver también
- BASIC A + , BASIC XL, BASIC XE - BASIC extendidos para Atari, de Optimized Systems Software
- Turbo-Basic XL - Freeware BASIC compatible con Atari BASIC, también disponible con un compilador para mayor velocidad y comandos adicionales.
Notas
- ^ AppleSoft BASIC ocupó ubicaciones de memoria de $ D000 a $ F7FF, un total de 10240 bytes.
- ^ Aunque el árbol de análisis se implementa como un conjunto de tablas, lo que en realidad es un detalle de implementación.
- ^ Esta es la razón por la que los conceptos básicos de MS solo tienen dos letras significativas en los nombres de las variables, se almacenan en una lista con solo dos bytes de ASCII para el nombre en otro para mejorar el tiempo de búsqueda.
Referencias
Citación
- ↑ Lorenzo, Mark (2017). Bucle sin fin: La historia del lenguaje de programación BÁSICO . Filadelfia: SE Books. pag. 106. ISBN 978-1974-27707-0.
- ^ Wilkinson, O'Brien y Laughton 1983 .
- ^ Decuir 2004 .
- ↑ a b c d e f Wilkinson , 1982 , p. ix.
- ^ Steil, Michael (20 de octubre de 2008). "Cree su propia versión de Microsoft BASIC para 6502" . Requiere ensamblaje .
- ^ Wilkinson , 1982 , págs. Iv-v.
- ^ Cromemco 1978 .
- ^ Lorenzo, Mark (2017). Bucle sin fin: La historia del lenguaje de programación BÁSICO . Filadelfia: SE Books. pag. 106. ISBN 978-1974-27707-0.
- ↑ a b Wilkinson , 1982 , p. v.
- ↑ a b Wilkinson , 1982 , p. X.
- ^ Cherry, Charles (junio de 1987). "Bonanza BÁSICA" . Antic .
- ^ Wilkinson , 1982 , p. vi.
- ^ a b "Errores BÁSICOS de Atari" . ¡Calcular! . Julio de 1986. p. 10.
- ^ a b Radcliff, Matthew (septiembre de 1995). "Conversor de revisión C" . Antic .
- ↑ a b c d Chadwick , 1985 , p. 230.
- ^ Chadwick 1985 , págs. 250-251.
- ^ Hardy, Bob (febrero de 1993). "Obtener código clave" . Clásicos de Atari . pag. 18.
- ^ Manual 1980 , Apéndice B.
- ↑ a b c d Crawford , 1982 , p. 10.3.
- ↑ a b Crawford , 1982 , p. 10.6.
- ^ Crawford , 1982 , p. 10,3-10,5.
- ^ Wilkinson, O'Brien y Laughton 1983 , p. 5.
- ^ Crawford , 1982 , p. 10.5.
- ^ Manual 1980 , p. 54.
- ^ "ATR: cap.15: Mostrar listas" .
- ↑ a b c d e f Wilkinson , 1985 , p. 139.
- ^ Ahl, David (noviembre de 1983). "Prueba de comparación de referencia" . Computación creativa . págs. 259-260.
- ^ Ahl, David (enero de 1984). "Benchmark de Computación Creativa" . Computación creativa . pag. 12.
- ^ Wilkinson, O'Brien y Laughton 1983 , p. 17.
- ^ Crawford , 1982 , p. 8.45.
- ^ Ganador, Lane (1982). "De Re Atari, Capítulo 10: Atari BASIC" . Atari, Inc.
- ^ "¿El punto de referencia de Ahl?" . 28 de noviembre de 2007.
Bibliografía
- El Manual de referencia de ATARI BASIC . Atari Inc. 1980. Archivado desde el original el 1 de mayo de 2005.
- Chadwick, Ian (1985). Mapeo del Atari . ¡Calcular! Publicaciones. ISBN 0-87455-004-1.
- Crawford, Chris (1982). De Re Atari . Intercambio del programa Atari.
- Cromemco 16K Extended BASIC (PDF) . Cromemco. 1978.
- Wilkinson, Bill (1982). Dentro de Atari DOS . Software de sistemas optimizados, Inc. ISBN 0-942386-02-7. Consultado el 4 de abril de 2009 .
- Decuir, Joe (30 de diciembre de 2004). 3 generaciones de arquitectura de máquinas de juego (habla). Classic Gaming Expo 2004. Centro de Convenciones de San José.
- Wilkinson, Bill; O'Brien, Kathleen; Laughton, Paul (1983). El libro de consulta BÁSICO de Atari . ¡Calcular! Libros. ISBN 0-942386-15-9.
- Wilkinson, Bill (febrero de 1985). "INSIGHT: Atari" . Computación creativa . págs. 139–140.
enlaces externos
- Atari BASIC, lo bueno, lo malo y lo feo
- Albrecht, Bob; Finkel, LeRoy; Brown, Jerald R. (1979). Atari Basic: una guía de autoaprendizaje . Consultado el 29 de junio de 2013 .
- Albrecht, Bob; Finkel, LeRoy; Brown, Jerald R. (1985). Atari Basic - Edición XL . Consultado el 29 de junio de 2013 .