Beta Basic 4.00

Para ZX Spectrums con 128K de memoria


Beta Basic 4.00 aprovecha las facilidades extras ofrecidas por las versiones 128k del Spectrum.

Rutina SAVE del cargador del BB4
1 LET rt=PEEK 23730+256*PEEK 23731
        SAVE "Beta Basic" LINE 2
        LET ch=PEEK 23631+256*PEEK 23632
        POKE ch,27
        POKE ch+1,17
        POKE ch+2,27
        POKE ch+3,17
        SAVE "bbc1" CODE rt+1,65367-rt
        RANDOMIZE USR 63039
        RANDOMIZE USR 59910
        SAVE "bbc2" CODE 16384,6144
        CLS
        STOP

Rutina LOAD del cargador del BB4
2 CLEAR rt
        LOAD "bbc1"CODE
        RANDOMIZE USR 63039
        INK 7
        LOAD "bbc2"CODE 16384
        RANDOMIZE USR 16640
        INK 0
        CLS
        RANDOMIZE USR 58419
        DELETE 1 TO 2

Llamadas útiles:
RANDOMIZE USR 58419 - activa el Beta Basic
RANDOMIZE USR 59904 - desactiva el BB y pasa a modo 48K
RANDOMIZE USR 59907 - desactiva y pasa a 128K, la línea cero es renumerada a 1
RANDOMIZE USR 59910 - copia la parte del BB de la RAM paginada a la pantalla para salvarla. Debe evitarse la sobreescritura del archivo.




Comandos:
Para los demás comandos del Beta Basic ver el manual del BB3.

Beep!
sintaxis: BEEP ![!]p[,d,n,e,ep,v][;p,-...][!p,...]
donde:
p = periodo tonal (de 0 a 4094)
d = duración (0 a 255)
n = periodo del ruido (0 a 32)
e = envoltura (1 a 8)
ep = periodo de la envoltura (0 a 65535)
v = volumen (0 a 15)
Produce sonido a base de interrupciones. Si bien PLAY permite crear buenas composiciones, no hay modo de ejecutar otras cosas mientras suena la musica. En eso no es mejor que BEEP. La nueva sentencia BEEP! aprovecha las ventajas del chip de sonido del 128k y pone el sonido en una cola dejando que cualquier programa se ejecute al mismo tiempo. El chip es alimentado con datos 50 veces por segundo sin que el programa y todas sus facilidades peuden ser controladas mediante los diversos parámetros que BEEP! posee si bien la mayoría son opcionales.
Ejemplos:
       BEEP !400 - dura medio segundo por defecto
       BEEP !400,50 - un segundo completo, o sea un cincuentavo de segundo.
       BEEP !400,0 - fija el sonido permanentemente hasta que uno mismo lo quite con otro comando BEEP! o BEEP CLEAR.

Es posible tener más de 120 sonidos por canal con solo el periodo tonal, y unos 30 sonidos usando todos los parámetros. Si no hay más espacio para la cola de sonidos, BEEP! simplemente esperará a que haya nuevamente espacio libre.
       10 FOR n=200 TO 500 STEP 20
       20 BEEP !n,25
       30 NEXT n
El siguiente ejemplo nos muestra como generar melodias:
       10 READ p
       20 BEEP !p,20
       30 G0 TO 10
       50 DATA 212,200,189,178,168,159,150,141,133,126,119,112
       60 REM C C# D D# E F F# G G# A A# B NOTES
       70 REM 0 1 2 3 4 5 6 7 8 9 10 11 BEEP
La equivalencia con las notas del BEEP original se obtiene con:
Tono= INT (125.95/2^((Beep número-9)/12)+.5)

Ruido:
Cuando la computadora genera "ruidos", técnicamente genera notas. Ruido en este caso refiere a "siseos" semi aleatorios, mientras el tono contiene solo una frecuencia. 1 da un sonido siseante, 32 da  un ruido sordo como un estrépito y 0 apaga el ruido.
Ejemplos:
       BEEP !0,50,1: BEEP !0,50,10: BEEP !300,50,30
La línea anterior puede entrarse también de un modo más breve:
       BEEP !0,50,1;0,50,10;300,50,30
Para apagar el ruido sin especificar o modificar la duración:
       BEEP !0,-,ruido
El signo "-" significa "no cambiar valor en curso" y puede usarse en lugar de cualquiera de los parámetros siemrpe que se requiera.

Envolturas del volumen:
El chip de sonido permite 8 patrones de volumen. Y son:

       *                               *    *    *    *
       **                              **   **   **   **
       * *                             * *  * *  * *  * *   etc.
       *  *                            *  * *  * *  * *  *
       *   *                           *   **   **   **   *
1.      *    ***********         5.     *    *    *    *    *

            *                               *    *    *    *
           **                              **   **   **   *
          * *                             * *  * *  * *  *  etc.
         *  *                            *  * *  * *  * *
        *   *                           *   **   **   **
2.      *    ***********         6.     *    *    *    *

       *    ***********                     *         *
       **   *                              * *       * *
       * *  *                             *   *     *   *   etc.
       *  * *                            *     *   *     *
       *   **                           *       * *       *
3.      *    *                   7.     *         *         *

            ***********                *         *         *
           *                           **       * *       *
          *                            * *     *   *     *  etc.
         *                             *  *   *     *   *
        *                              *   * *       * *
4.      *                        8.     *    *         *

El quinto parámetro es necesario para especificar cuánto dura.
Ejemplos:
       10 BEEP !0,50,1,1,10000
       20 BEEP !0,150,14,5,1000
       30 BEEP !0,100,4,7,50
       40 BEEP !700,50,0,1,10000
       50 BEEP !0,0,1,7,20000

Volumen:
Al cargarse el BB4, el volumen estás puesto al máximo.
En el ejemplo vemos como el volumen baja gradualmente para subir luego:
       10 FOR n=15 TO 1 STEP –1
       20 BEEP !400,20,0,0,0,n
       30 NEXT n
       40 BEEP !0,1,0,0,0,15

Canales:
Es posible tocar más de un canal a la vez usando un "!" como separador.
Ejemplos:
BEEP !400;25!200,50 - usa dos canales a la vez
BEEP !200,25;150;100!0,50,5;800,25,0!0,150;100,5 - usa tres canales
BEEP !!200,40 - manda el sonido por el canal dos
BEEP !!!400,25 - usa solo el canal tres

Ejemplo de melodía (Frere Gustav):
       10 LET t=30,c=212,d=189,ds=178,f=159,g=141,gs=133
       20 BEEP !0,1,0,1,20000
       30 BEEP !c,t;d;ds,t/2;d;c,t
       40 BEEP !c,t;d;ds,t/2;d;c,t
       50 BEEP !ds,t;f;g,2*t
       60 BEEP !ds,t;f;g,2*t
       70 SEEP !g,3/4*t;gs,t/4;g,t/2;f;ds;d;c,t
       80 BEEP !g,3/4*t;gs,t/4;g,t/2;f;ds;d;c,t
       90 BEEP !c,t;2*g;c,2*t
       100 BEEP !c,t;2*g;c,2*t
La variable t controla la velocidad de la música. La línea 20 fija la envoltura. Se la puede cambiar para experimentar:
       20 BEEP !0,1,0,0
       20 BEEP !0,1,0,5,10
       20 BEEP !0,1,30

La cola de sonidos:
Cada una de las colas de sonido puede tener hasta 248 bytes, dando un número variable de sonidos dependiendo de la cantidad de parámetros especificados. PAra monitorear los bytes en uso en cada canal, debe hacerse un PEEK en las posiciones 49147,49148 y 49149.
De este modo se podría activar con CLOCK una subrutina de sonidos cada "n" segundos. De no concoerse el estado de la cola, se corre el riesgo de que el espacio se agote y halla un silencio descendete, o el sistema intente añadir más datos a la cola con lo que se generaría una pausa larga en mitad del programa en ejecución.
Es mejor chequear mediante:
       IF PEEK 49147 < 150 THEN BEEP ! ...etc.
Una copia del registro del chip de sonido se almacena en la posición 49150 y es de bits significativos, puede leerse con:
       PRINT BIN$(PEEK 49150)
Es más informativo y los bits tienen el significado siguiente:
       BIT 7 - siempre 1
       BIT 6 - siempre 1
       BIT 5 - Canal 3 Ruido
       BIT 4 - Canal 2 Ruido
       BIT 3 - Canal 1 Ruido
       BIT 2 - Canal 3 Tono
       BIT 1 - Canal 2 Tono
       BIT 0 - Canal 1 Tono
Si el bit está a cero, significa que está activo.
Nota: BEEP! usa la zona superior del disco RAM, con menos de 2k libres habrá reporte "Out of memory". DIM! y SAVE! pueden sobreescribir en la cola de sonidos afectándola.

Beep clear
sintaxis: BEEP CLEAR [canal]
donde:
canal = un número de cero a tres.
0 = es omitible y aclara todos los canales
1 - 3 = aclara solo el canal correspondiente especificado
Limpia uno o todos los canales de sonido. El canal es apagado, su sonido es silenciado, y su cola de sonidos asociados es limpiada. El volumen es puesto al máximo (15) y la duración a 0.5 (25 interrupciones)


Cat!
sintaxis: CAT!
Muestra el catalogo del disco RAM. Ahora también da el número de bytes libres en el disco RAM, siendo el total inicial de 73k es decir 1k menos de lo normal.
Si se deseara un total más preciso o si no se hubiese cargado el Beta Basic, se puede usar:
       PRINT PEEK 23429+256*PEEK 23430+65536*PEEK 23431

Circle
sintaxis: CIRCLE <x,y,r>
El comando CIRCLE ha sido mejorado. Ahora es más rápido en comparación al ZX Basic normal. Hace círculos 12 veces más rápido que antes y los hace más simétricos además de formar mejores patrones cuando se superimponen.
Los círculos pueden salirse de la pantalla sin que haya mensaje de error. OVER, INK, PAPER e INVERSE son también aceptados.
Ejemplo:
       10 FOR r=1 TO 255 STEP 2
       20 CIRCLE 127,79,r
       30 NEXT r
       40 PAUSE 0

Delete
sintaxis: DELETE [x] TO [y]
Borra líneas de programa. DELETE ha sido mejorado para que no de error si es que una o las dos líneas especificadas no existiesen.

Dim!
sintaxis : DIM! <nom>[,] (dim [,dim2,...])
donde:
nom = nombre de fichero o de matriz numérica o de cadena
dim = el número de dimensiones de la matriz
Crea matrices en el disco RAM. Estas peuden ser manipuladas de la misma forma que las matrices normales y pueden ser de hasta 64k. El tamaño pleno de una matriz de cadena resulta de multiplicar cada una de sus dimensiones.
Ejemplos:
       DIM !fred$(100,10) - crea matriz de cadena "fred$" de 100 por 10 caracteres.
       DIM !long$(2000) - crea matriz "long$" de 2000 caracteres.
       DIM !nums(100) - crea cadena numérica "nums" de 100 números.
       DIM !num#(5,5) - crea matriz "num#" de 5 hileras de 5 números.

Los nombres deben empezar por una letra y terminar con "$" para cadenas y "#" o cualquier otra letra para números. Las matrices DIM! no admiten que el nombre sea una variable. En cambio considerados como ficheros si es posible usar variables pero seguidas de ",":
       DIM !a$,(100,20)

Entrando datos en una matriz de disco RAM:
       10 DIM !fred$(20,10)
       20 FOR n=1 TO 20
       30 LET !fred$(n)=STR$ n+" hello!"
       40 NEXT n
       50 FOR n=1 TO 20: PRINT !fred$(n): NEXT n
En la línea 50 reemplazar PRINT! por: LIST !"fred$" (ver LIST!).
Nota: una matriz de disco RAM no puede ser borrada por RUN, CLEAR o NEW.

Ejemplos de entradas permitidas:
       LET a$=!fred$(n,f TO g)+"qwerty"+x$ - es permitido,
pero:
       LET a$="qwerty"+!fred$(n) - no lo es.
Debe usarse:
       LET t$=!fred$(n): LET a$="qwerty"+t$

Una matriz creada con DIM! es igual a usar DIM y SAVE!:
       DIM !fred$(100,20)
es igual que:
       DIM a$(100,20): SAVE !"fred$" DATA a$()
Para pasar las matrices del disco RAM a casette o disco:
       10 LET rt=DPEEK(23730)
       20 SAVE !"programa" LINE 100
       30 DELETE 100 TO
       40 RANDOMIZE USR 59907: REM BB off, va a modo 128K
       50 SAVE !"bbc1"CODE rt+1,65367-rt
       60 CLEAR 65535
       70 DIM a$(1): LOAD !"big$" DATA a$()
       80 SAVE "big$" DATA a$()
       90 LOAD !"programa": REM Trae de vuelta resto del programa!
       100 CLEAR rt
       110 LOAD !"bbc1"CODE
       120 RANDOMIZE USR 58419: REM Beta Basic ON
       130 REM resto del programa
Una vez en el menú del 128k elegir el basic 128 y tipear "RUN 50".
Nota: EL DIM de la línea 70 es apra evitar un bug del 128k que sin el BB4 sería evidente.

Draw to
sintaxis: DRAW [TO] <x,y>
Al igual que Circle, DRAW también ha sido mejorado, ahora es 2.5 veces más rápido haciendo líneas y como Plot también puede dibujar en la zona baja ya sea con coordenadas relattivas (DRAW normal) o absolutas (DRAW TO)
Ejemplo:
       10 BORDER 6: INPUT ""
       20 DO
       30 DRAW TO RNDM(255),RNDM(191)-16
       40 LOOP
El INPUT de la línea 10 permite controlar el color en la zona baja.

Erase!
sintaxis: ERASE! <nombre>
Elimina archivos del disco RAM. Los archivos son colocados uno después del otro a medida que se salvan. Si se elimina el primer archivo salvado, todos los que le siguen serán movidos de sitio en el disco RAM lo cual toma su tiempo.
Ejemplo:
       10 SAVE !"uno"CODE 0,30000
       20 SAVE !"dos"CODE 0,30000
       30 PRINT "Borrando"
       40 ERASE !"uno"
       50 ERASE !"dos"
Erase! combinado con Cat$ permite eliminar todo el contenido del disco RAM:
       100 DEF PROC erall
               DO UNTIL CAT$()=""
               ERASE !CAT$()(1 TO 10)
               LOOP
           END PROC
Para activar este procedimiento basta con tipear: ERALL

Fill Using
sintaxis: FILL USING <var$;x,y>
BB4 ofrece una rutina FILL mejorada. Es mucho más rápida que la de las versiones BB anteriores. Toda la pantalla puede ser llenada en solo un segundo. Fill Using también trabaja con patrones de 16x16 píxeles especificados en una cadena, la cual puede ser una cadena simple, un bloque GET, o cualquier área MEMORY$, incluyendo sets de 4 UDG's.

Ejemplo de bloque GET:
       10 PRINT CSIZE 16;"O"
       20 GET a$,0,175,2,2
       30 CIRCLE 127,87,60
       40 FILL USING a$;127,87
Ejemplo de STRING$ normal:
       50 LET a$=STRING$(32,CHR$ BIN 11001100)
       60 FILL USING a$;0,0
Ejemplo de patrón de 4 UDG's con MEMORY$:
       40 FILL USING MEMORY$()(USR "a");127,87
Ejemplo con INK y PAPER:
       10 REM bricks
       20 LET a$=""
       30 FOR n=1 TO 8
               READ a
               LET a$=a$+CHR$ a
          NEXT n
       40 LET a$=STRING$(4,a$)
       50 DATA 16,16,16,255,1,1,1,255
       60 CIRCLE 127,87,60
       70 FILL USING a$; INK 1;127,87
PAPER en cambio muestra las limitaciones de atributos del Spectrum:
       70 FILL USING a$; INK 7; PAPER 2;127,87
Ejemplo sin uso de atributos:
       60 REM check
       70 LET b$=STRING$(8,CHR$ BIN 11001100+CHR$ BIN 11001100
               +CHR$ BIN 00110011+CHR$ BIN 00110011)
       80 REM horizontal stripe
       90 LET c$=STRING$(16,CHR$ 255+CHR$ 0)
       100 CIRCLE 88,87,70
       110 CIRCLE 158,87,70
       120 FILL USING a$;127,87
       130 FILL USING b$;70,87
       140 FILL USING c$;160,87
Nota: FILL usa parte del disco RAM. Usar más de 63k hará que FILL genere un error "Out of memory" (no hay espacio en la RAM).

Format
sintaxis 1: FORMAT letra;<modo>
sintaxis 2: FORMAT letra;<baudios>
donde:
letra = "p" o "P"
modo = un valor de cero a dos
baudios = 50, 110, 300, 600, 1200, 2400, 4800 o 9600
Selecciona el tipo de LPRINT. BB4 usa la sintaxis normal de FORMAT para elegir el rango de baudios del RS-232. LPRINT y LLIST enviarán los datos a imprimir vía RS-232.
Ejemplo: FORMAT "p";1200

FORMAT "p";0
Da el RS-232 normal del modo 128k sin BB4. CHR$ 13 (retorno de acarreo) da automáticamente CHR$ 10 (línea siguiente) Los otros códigos del 0 al 31 no se envían. Las palabras reservadas son enviadas expandidas (por ejemplo: CHR$ 255 COPY es enviado como C,O,P,Y)

FORMAT "p";1
Fija el RS-232 a modo binario. Todos los caracteres son enviados sin cambio, ya sean códigos de control a imprimir o datos mandados a otra computadora. En este modo uno debe añadir CHR$ 10 a cada CHR$ 13 o fijar la impresora para que lo haga automáticamente.
Es posible pasar de un modo a otro incluso sin BB4 instalado:
       POKE 23349,36: POKE 23350,1: REM modo texto
       POKE 23349,39: POKE 23350,1: REM modo binario

FORMAT "p";2
Fija la salida de impresora estilo 48k. La impresora ZX funcionará correctamente así como cualquier otra impresora conectada al bus de expansión. COPY funcionará con cualquier impresora o intefase que permita hacer COPY en un 48k.
Normalmente muchas impresoras que funcionan con un 48k no lo hacen en modo 128k debido a que el buffer de impresora del modo 48k es usado por el modo 128k para almacenar variabels del sistema extras y otras usos internos.

Input!
sintaxis: INPUT <#canal>;!<nombre>
Input! carga un archivo desde el disco RAM a traves de un canal. Se requiere de microdrive o de un DOS que acepte ficheros seriales.
Input! trabaja con archivos creados con List!
Ejemplo:
       10 OPEN #5;"m";1;"fichero"
       20 INPUT #5;!"fred$"
       30 CLOSE #5

List!
sintaxis: LIST [#canal ;]!<nombre>
Lista contenido de archivo en disco RAM. si no se especifica un canal, el archivo será mostrado en la pantalla.
LIST! puede operar con cualqueir canal ""S", "P" o "T".
LLIST! también funciona como LIST! pero lo hace directamente con impresoras.
Ejemplo:
       LIST !"fred$"
List! permite pasar los archivos del dsco RAM a disco o microdrive:
       10 DIM !name$(120,10)
       20 OPEN #6;"m",1;"name$"
       30 LIST #6;!"name$"
       40 CLOSE #6
Es importante cerrar el canal o se perderá parte del archivo. List! crea archivos seriales que podrían no ser cargados con LOAD, pero sí con INPUT!

Play
sintaxis: PLAY <cadena de sonidos>
Este comando propio del 128k funciona del modo normal.
El UDG "U" es usado tanto para el comando PLAY como para USING, dependerá del cotnexto sintáctico apra ver el comando correspondiente.
Ejemplo:
       10 PLAY "acd"
Es aceptado, pero si uno edita la línea y añade un PRINT antes, PLAY es automáticamente reemplazado por USING.

Plot
sintaxis: PLOT <x,y>
Ahora PLOT puede actuar en la zona baja de la pantalla reservada a INPUT. Los valores para "y" ahora son de 0 a 175 para la zona de arriba y de -16 a 0 para la zona baja. Se podría coregir eso con YOS para obtener "y" de 0 a 191.
Ejemplo:
       10 FOR y= -16 TO 175
       20 PLOT 0,y
       30 DRAW 255,0
       40 NEXT y

Save!
sintaxis 1: SAVE ! [línea x TO línea y;]<nombre>
sintaxis 2: SAVE ! DATA ;<nombre>
Salva al disco RAM ya sea parte de un programa o solamente sus variables.
Ejemplos:
       SAVE !1000 TO 2000;"parte2"
       SAVE ! DATA "vars4"

Asumiendo que uno tenga un programa dividido en tres secciones en el disco o microdrive, uno puede adaptar el programa para aprovechar las ventajas del disco RAM. Obviamente uno deberá vovler a salvar los datos al disco para no perderlos pues el disco RAM se borra al apagar el Spectrum.
Ejemplo:
       1 (rutina SAVE. MERGE cargador Beta Basic y modificarlo al gusto.)
       2 (rutina LOAD. Para autoejecutar el programa.)
       10 MERGE "sect1": SAVE !1000 TO;"sect1": DELETE 1000 TO
       20 MERGE "sect2": SAVE !1000 TO;"sect2": DELETE 1000 TO
       30 MERGE "sect3": SAVE !1000 TO;"sect3": DELETE 1000 TO
Este prodría ser el programa principal:
       40 CLS: DELETE 1000 TO
       50 PRINT "1. Entrar datos"
       60 PRINT "2. Mostrar datos"
       70 PRINT "3. Calcular resultados"
       80 INPUT ch
       90 IF ch=1 THEN MERGE !"sect1": GOSUB 1000
       100 IF ch=2 THEN MERGE !"sect2": GOSUB 1000
       110 IF ch=3 THEN MERGE !"sect3": GOSUB 1000
       120 GO TO 40
Para tener una mejor estructura se podrían cambiar los GOSUB's por procedimientos y para saber qué sección del programa se está invocando se podría añadir en cada una una función que nos lo diga:
       1000 DEF FN n$()="sect1": REM or "sect2" or "sect3"

Sort!
sintaxis: SORT [INvERSE]! <mat>
donde:
mat = matriz de cadena de disco RAM.
Ordena matrices en el disco RAM. Este comando ha sido modificado para que ordene cadenas y matrices normales, así como las nuevas matrices especiales de cadena del disco RAM. SORT! no trabaja con las matrices numéricas del disco RAM pero se pueden convertir a cadenas con CHAR$, USING$ o FP$ y entonces usar SORT!
Una matriz $(1000, 60) tardará 14 segundos en ordenarse, mientras que en un disco tardaría 14 minutos a lo más. Cuanto ma´s vacía esté la matriz más tardará la ordenación. Es posible usar BREAK para interumpir un SORT! lo cual dejará la matriz del disco RAM parcialmente ordenada.

Ejemplo:
       10 DIM !rand$(20,8)
       20 FOR n=1 TO 20
       30       FOR c=1 TO 8
       40               LET !rand$(n,c)=CHR$(RNDM(25)+65)
       50       NEXT c
       60 NEXT n
       70 LIST !"rand$"
Para ordenar y listar la matriz:
       SORT !rand$(): LIST !"rand$"
Para hacer un orden inverso con subcadenas:
       SORT INVERSE !rand$(1 TO 10)(2 TO)





Funciones:

Cat$ <FN y$>
sintaxis: CAT$ ()
Esta función devuelve todo el catálogo del disco RAM como una cadena. Facilita la busqueda de archivos para hacer ERASE!, SAVE! o evitar LOAD! a un archivo no existente.
CAT$() devuelve una cadena de trece caracteres por archivo en el disco RAM, mostrando primero el archivo más recientemente creado. El número de archivos se obtiene mediante: LEN CAT$()/13.
Los trece caracteres contienen lo siguiente:
Del 1 al 10, el nombre del archivo
El 11 almacena el tipo de archivo:
       CHR$ 0 = programa
       CHR$ 1 = matriz numérica
       CHR$ 2 = matriz de cadena
       CHR$ 3 = código máquina
12 y 13 contienen la longitud e su forma de byte más y menos significativo. Se puede leer y convertir con NUMBER.

Ejemplo 1:
       10 INPUT "Archivo a salvar como: ";n$
       20 IF INSTRING(1,CAT$(),a$)<>0 THEN ERASE !a$
       30 SAVE !a$

Ejemplo 2:
       10 ncat
       20 STOP
       100 DEF PROC ncat
               LET a$=CAT$ ()
               FOR f=1 TO LEN a$ STEP 13
                       PRINT a$(f TO f+9);
                       ON CODE a$(f+10)+1
                        PRINT" Programa";
                        PRINT" Numerico";
                        PRINT" Cadena";
                        PRINT" Codigo ";
       110             PRINT " Largo:";NUMBER(a$(f+11 TO f+12))
               NEXT f
          END PROC

Fp$ <FN f$>
sintaxis: FP$ (x,y)
donde:
x = el número a convertir
y = el número de caracteres
Convierte números a cadenas. FP$ es por Floating Point String (Cadenas de coma flotante). Convierte cualquier número x en una cadena de longitud y.
FP$ permite un manejo balanceado y flexible de la memoria y la precisión para las matrices.
Ejemplo:
       10 PRINT " Original 4 Chars 3 Chars"
       20 FOR n=1 TO 20
       30 LET x=RND*200000-5000
       40 LET a$=FP$(x,4)
       50 LET b$=FP$(x,3)
       60 PRINT x;TAB 11;NUMBER(a$);TAB 22;NUMBER(b$)
       70 NEXT n
Un número normalmente ocupa 5 bytes, en el ejemplo vemos la precisión de FP$ con 4 y 3 caracteres.

Inarray <FN i(>
nueva sintaxis: INARRAY ("n$", c$)
donde:
n$ = nombre del archivo en disco RAM siempre entre comillas
c$ = la cadena a buscar
Busca cadenas dentro de matrices del disco RAM. INARRAY ha sido modificado para poder manejar busquedas con matrices de cadena de disco RAM.
INARRAY da la posición de la primera cadena que contenga el dato buscado, de lo cotnrario devolverá cero.
Ejemplo:
       10 DIM !name$(100,10)
       20 LET !name$(100)="SMITH"
       30 PRINT "Hallado en la cadena:";INARRAY("name$(1)","SMITH")
Se pueden usar variables pero repetando el chequeo sintactico:
       30 LET a$="name$": PRINT INARRAY(a$+"(1)","SMITH")
En cambio:
       INARRAY(a$(1),"SMITH") ó INARRAY(a$,"SMITH")
no funcionarán para el caso ya que buscarán una cadena normal a$.
Si se conociera la posición exacta del dato a buscar entocnes podría hacerse:
       PRINT INARRAY("name$(1,1 TO 5)","SMITH")
lo cual reduce el tiempo de busqueda.

Mdp$ <FN x$>
sintaxis: MDP$()
MDP$ es por "Missing DEF PROC" (procedimiento faltante). Esta funcción combinada con ON ERROR permitiría cargar un procedimiento faltante siemrpe que exista en la unidad de almacenamiento de datos. Pensado para trabajar con el disco RAM, también puede ser usado con Microdrives o discos.
Ejemplo de su uso:
       9000 DEF PROC testing n
               FOR x=1 TO n
                       PRINT n,"Beta"
               NEXT x
       9010 END PROC
Salvarlo en el disco RAM con:
       SAVE !9000 TO 9010;"testing"
Escriba ahora estas líneas:
       10 ON ERROR 100
       20 testing 5
       30 STOP
       100 IF error=32 THEN MERGE !MDP$( )
               ON ERROR 100
               POP
               CONTINUE
               ELSE STOP
Ejecutar esto para ver que pasa sin error alguno.
Borrar después las líneas del procedimiento 9000 y 9010 y hacer RUN.
Ahora se activará la rutina que cargará con MERGE el procedimiento faltante y el programa continuará con su ejecución normal.
También es posible hacer MERGE "p."+MDP$() o cualquier otra combinación aceptable.

Number <FN n(>
sintaxis: NUMBER (x$)
Convierte unca cadena a número. NUMBER ha sido modificado para que admita y convierta las cadenas de 3, 4 o 5 caracteres creadas con FP$. Las cadenas creadas por CHAR$ siguen siendo convertidas a enteros pero las de FP$ son convertidos a valores de coma flotante que pueden ser tanto positivos como negativos.
Es posible manejar todo el rango numérico del Spectrum (desde 10E-39 a 10E38).




Códigos de error:
Para los demás reportes de error ver el manual del BB3.

ERROR           MENSAJE

170      MERGE error
171      Wrong file type - tipo de archivo erroneo
172      CODE error
173      Too many brackets - demasiados paréntesis
174      File already exists - el archivo ya existe
175      Invalid name - nombre no válido
176      (not used)
177      File does not exist - el archivo no existe
178      Invalid device - dispositivo no válido
179      Invalid baud rate - rango de baudios no válido
180      Invalid note name - nombre de nota no válido
181      Number too big - número demasiado grande
182      Note out of range - nota fuera de rango
183      Out of range - fuera de rango
184      Too many tied notes - demasiadas notas conectadas



2006 -   F. L. <zx_if1@hotmail.com>