Tema 1 - Lo más básico de Basic
Este apartado será largo, porque veremos casi todos los conceptos necesarios para crear programas sencillos en Basic de los Amstrad CPC. Los siguientes apartados serán temáticos y, por tanto, más breves.
Dentro de este apartado veremos:
- 1.1 Órdenes sueltas y programas
- 1.2 Operaciones matemáticas
- 1.3 Variables. Introducción de valores
- 1.4 Comentarios
- 1.5 Condiciones
- 1.6 Repitiendo una serie de pasos
- 1.7 Guardando nuestro programa
- 1.8 El teclado de un CPC
- 1.9 Un primer ejercicio propuesto
1.1 Órdenes sueltas y programas
Los Amstrad CPC incluían un intérprete de lenguaje Basic. Eso quiere decir que, en condiciones normales, nada más encender el ordenador, este estaría dispuesto a recibir las órdenes que le indicáramos (en lenguaje Basic).
Por ejemplo, podríamos pedirle que escribiera un cierto texto en pantalla, con la orden "print". El texto que queremos que se muestre deberíamos indicarlo a continuación, entre comillas, así:
print "hola"
Obtendremos como respuesta:
hola
(Nota: podemos teclear las órdenes en mayúsculas o minúsculas, el intérprete de Basic no hará distinciones entre unas y otras, da igual escribir "print", "PRINT" o "Print").
Pero también tenemos la opción de que nuestras órdenes no se pongan "en marcha" inmediatamente, sino que se queden memorizadas, formando "un programa". Cuando nuestro programa esté completo, podemos decir que todas esas órdenes se pongan en funcionamiento, tecleando la orden RUN. Para conseguirlo, introducimos un número delante de cada línea:
10 print "Que tal" 20 print "estas?" run
El ordenador mostraría las palabras que tal, y bajo ésta, estas?:
Me imagino que aquí habrá un primer problema: si estás usando un emulador, quizás no te sea fácil encontrar todos los símbolos en tu teclado. Las comillas en un CPC están en mayúsculas+2, igual que en casi cualquier ordenador actual, pero la interrogación posiblemente no estará en la misma tecla (por ejemplo, en mi Pc está junto al 0, mientras que en el CPC estaba junto a la tecla derecha de mayúsculas).
Muchos emuladores te permiten "redefinir" el teclado, para que las teclas de tu equipo "anfitrión" muestren a los caracteres equivalentes del CPC. Si tu emulador no permite redefinir teclas, o si consideras que no merece la pena (bien por pereza, o porque se parece bastante a un teclado en inglés estándar, o porque todavía lo recuerdes casi por inercia), siempre puedes mirar el apartado 1.8: el teclado de un CPC para saber dónde está cada símbolo.
Puede ocurrir que, después de haber tecleado varias órdenes, nuestro programa inicial ya no esté visible en la pantalla. Para que el ordenador nos lo vuelva a mostrar, se emplea la orden LIST, a lo que respondería con:
10 PRINT "Que tal" 20 PRINT "estas?"
(Se puede observar que las órdenes se han convertido a mayúsculas. Eso quiere decir que el Amstrad ha detectado esas órdenes como válidas, lo que nos puede ayudar a descubrir errores: si la orden sigue en minúsculas, es casi seguro que no la hemos escrito correctamente)
Un detalle sobre la numeración de las líneas: lo habitual en estos Basic "antiguos" era no numerar las líneas de 1 en 1, sino con una separación mayor, habitualmente de 10 en 10, lo que permite que podamos insertar nuevas líneas entre las ya existentes, utilizando un número intermedio. Por ejemplo, la línea 15 se "ejecutaría" después que la 10 y antes que la 20. A su vez, si añadimos una línea 12, ésta se pondría en funcionamiento después de la 10 y antes que la 15.
1.2 Operaciones matemáticas
Con la orden PRINT también podemos escribir números (y entonces no harán falta las comillas), e incluso hacer operaciones entre ellos:
10 PRINT 23 20 PRINT 44 + 5; 30 ? 50-9
En ese programa hay dos pequeñas novedades: en la línea 20, si una orden PRINT termina en punto y coma, no se avanzará a la siguiente línea de la pantalla, sino que se seguirá escribiendo a continuación, en la misma línea; en la línea 30, he empleado ? como sinónimo de PRINT, algo que permiten muchas versiones de Basic (entre ellas la de los Amstrad CPC).
La salida de este programa sería
23 49 41
(Los números no aparecen totalmente juntos, sino separados por un espacio en blanco, que es donde aparecería el signo - si los números fueran negativos).
Las operaciones matemáticas habituales se representan con los siguientes símbolos:
+ Suma - Resta y negación (cambio de signo). * Multiplicación / División ↑ Exponenciación (un número elevado a otro: la flecha hacia arriba)
Y un ejemplo de su uso sería
10 PRINT "Ejemplo de operaciones, con los numeros 5 y 2" 20 PRINT "Suma: "; 5 + 2 30 PRINT "Diferencia: "; 5 - 2 40 PRINT "Producto: "; 5 * 2 50 PRINT "Division: "; 5 / 2 60 PRINT "Potencia: "; 5 ↑ 2
que tendría como resultado:
Suma: 7 Diferencia: 3 Producto: 10 Division: 2.5 Potencia: 25
1.3 Variables. Introducción de valores
Hemos visto cómo escribir un texto que habíamos fijado nosotros mismos desde el programa, o como hacer una operación con dos valores fijos. Pero eso no es lo habitual, sino hacer cálculos a partir del resultado de una cierta operación o de un valor introducido por el usuario, etc.
Para eso se emplean las llamadas "variables": una variable es un espacio de memoria en el que podremos guardar un determinado dato y al que podremos asignar un nombre. Este dato lo podremos modificar cuando queramos. Por ejemplo, podemos reservar un espacio, llamarlo "X" y guardar en él un cierto valor, así
10 LET X = 2 20 PRINT "X VALE:" 30 PRINT X
Como se ve, la orden LET es la que permite dar un valor a una cierta variable. Esta orden es opcional en la mayoría de versiones de Basic (incluyendo la de los Amstrad CPC), de modo que también podríamos haber escrito simplemente X=2. Para mostrar en pantalla el valor de una variable, utilizamos la orden PRINT, pero indicando el nombre de la variable sin comillas. El resultado del programa anterior sería:
X VALE: 2
Más adelante podemos modificar el valor de X nuevamente:
10 LET X = 2 20 PRINT "X VALE:" ; X 30 LET X = 5 40 PRINT "AHORA X VALE:" ; X
El resultado de este programa sería:
X VALE: 2 AHORA X VALE: 5
Aquí hay otra novedad: ya habíamos usado el punto y coma al final de una orden PRINT para que se continuara escribiendo en la misma línea. Ahora hemos incluido en una misma orden PRINT dos "cosas": un texto (entre comillas) y una variable (sin comillas), separados por punto y coma, que se escribirán en la misma línea de pantalla.
Como ya hemos visto, la orden LET no es obligatoria, así que es programa es equivalente al anterior:
10 X = 2 20 PRINT "X VALE:" ; X 30 X = 5 40 PRINT "AHORA X VALE:" ; X
Si queremos que sea el usuario el que introduzca un valor para una variable, se usa la orden INPUT, así:
10 INPUT X 20 PRINT "EL VALOR TECLEADO ES: " ; X 30 PRINT "SU CUADRADO ES:" ; X*X
La orden INPUT mostrará una interrogación para avisarnos de que está esperando un valor. Por ejemplo, si el usuario introduce el valor 3, en pantalla aparecería lo siguiente:
?3 EL VALOR TECLEADO ES: 3 SU CUADRADO ES: 9
También podemos indicar en la orden INPUT un texto entre comillas, para que aparezca delante de la interrogación:
10 INPUT "QUE NUMERO DESEA ELEVAR AL CUADRADO"; X 20 PRINT "EL VALOR TECLEADO ES: " ; X 30 PRINT "SU CUADRADO ES:" ; X*X
Hasta ahora sólo hemos usado una variable llamada X, pero este no es un nombre demasiado claro. Normalmente nos interesará tener nombres de variables más significativos, para que nuestro programa sea más fácil de leer:
10 PRIMERAVARIABLE = 20 20 SEGUNDAVARIABLE = 55 30 RESULTADO = PRIMERAVARIABLE * SEGUNDAVARIABLE 40 PRINT "RESULTADO VALE:" ; RESULTADO
Son válidos los nombres de variables que empiezan por una letra y después contengan letras o números (y en algún caso, algún otro símbolo, como el signo de subrayado). No podrán contener espacios, caracteres internacionales (letras acentuadas, eñes, etc), ni casi ningún signo de puntuación (puntos, comas, etc). Algunos símbolos especiales podrán aparecer al final del nombre de una variable, y tendrán un cierto significado, pero eso lo veremos un poco más adelante...
Un gran problema que puede existir con las variables se debe al hecho de que en el lenguaje Basic no es necesario declarar una variable antes de usarla: no hace falta decir "voy a usar una variable llamada X", sino que el propio intérprete de Basic, cada vez que ve una variable nueva la acepta como válida y le da el valor 0. ¿Qué problemas puede provocar esto? Vamos a verlo con un ejemplo:
10 PRIMERAVARIABLE = 20 20 SEGUNDAVARIABLE = 55 30 RESULTADO = PRIMERAVARIABLE * SEGUDNAVARIABLE 40 PRINT "RESULTADO VALE:" ; RESULTADO
Me temo que el resultado que obtenemos no es el que queríamos obtener: 20*55 = 1100, pero sin embargo nuestro programa está respondiendo RESULTADO VALE: 0 ¿Por qué? El fallo está en la línea 30: no hemos escrito SEGUNDAVARIABLE, sino SEGUDNAVARIABLE, hemos cambiado de sitio las letras N y D. En otros lenguajes, esto haría que recibiésemos una aviso de que la variable llamada SEGUDNAVARIABLE no se ha declarado previamente, pero en Basic no ocurre así: se da por sentado que hemos escrito correctamente la variable, y se le da el valor 0. Por eso el resultado de nuestro programa es 22*0 = 0, correcto para el intérprete de Basic... pero posiblemente incorrecto para nosotros.
Esto supone que haya que teclear con MUCHO CUIDADO y que aún así se deba PROBAR todos los programas con varios datos, para los que sepamos el resultado que se deba obtener. En cuanto notemos algo raro, habrá que revisar el programa. En los CPC existen ciertas ayudas para la depuración de errores, pero ese llegará más adelante...
Las variables que hemos estado utilizando hasta ahora estaban almacenando números. Concretamente, almacenaban números enteros (sin decimales). Esto es lo que permitirá cualquier versión del lenguaje Basic. En el Locomotive Basic de los Amstrad CPC se puede almacenar otros tipos de datos, como números reales (con decimales), que veremos más adelante.
Pero existe otro tipo de datos aun no conocíamos y que utilizaremos mucho en la práctica: se trata de cadenas de texto: conjuntos de una o más letras que utilizaremos para escribir mensajes, por ejemplo.
La variables que almacenen cadenas de texto deberán tener nombres terminados con el signo $:
10 NOMBRE$="JUAN PEDRO" 20 PRINT "HOLA " ; NOMBRE$
Podemos concatenar dos cadenas de texto con el signo +:
10 SALUDO$="HOLA " 20 INPUT "INTRODUCE TU NOMBRE" ; NOMBRE$ 30 FRASE$ = SALUDO$ + NOMBRE$ 40 PRINT FRASE$
Así, si el usuario teclea ALBERTO cuando se le pide su nombre, el valor de FRASE$ (que se mostraría en pantalla en la línea 40) sería HOLA ALBERTO
1.4 Comentarios
A veces nos puedes interesar que en nuestro programa aparezcan comentarios, que a nosotros nos aclaren por qué hemos dado un cierto paso. Será muy útil cuando se trabaje en grupo, o incluso cuando nosotros mismos tengamos que revisar un programa un cierto tiempo después de haberlo creado: nos ahorrará tiempo de "descifrar" qué habíamos hecho y por qué, especialmente en las partes más complicadas de un programa.
Los comentarios en Basic se indican con la palabra REM (abreviatura de REMARK, comentario, en inglés):
10 REM SIMPLEMENTE UN SALUDO 20 PRINT "HOLA"
El Basic de los CPC, al igual que otras muchas versiones del lenguaje Basic permite abreviar todavía más la palabra REM, poniendo un apóstrofe ( ' ) en su lugar:
10 ' SIMPLEMENTE UN SALUDO 20 PRINT "HOLA"
1.5 Condiciones
La forma básica de comprobar condiciones es con la construcción "IF condición THEN orden" (SI condición ENTONCES orden). Un ejemplo de su uso podría ser:
10 PRINT "Introduzca un numero" 20 INPUT x 30 IF x > 10 THEN PRINT "Es mayor de 10"
Una variante habitual de esta orden es la que nos permite saltar a otra posición del programa en caso de que se cumpla la condición: "IF condición THEN GOTO linea", que se puede abreviar como "IF condición THEN linea" o "IF condición GOTO linea". En un programa grande, usar GOTO será una forma sencilla de dar varios pasos seguidos (veremos otras mejores), pero en un programa tan corto, el resultado sería más incómodo y menos legible:
10 PRINT "Introduzca un numero" 20 INPUT x 30 IF x > 10 THEN GOTO 50 40 END 50 PRINT "Es mayor de 10"
La mayoría de las versiones de Basic permiten indicar qué hacer si no se cumple la condición, con la orden ELSE:
10 PRINT "Introduzca un numero" 20 INPUT x 30 IF x > 10 THEN PRINT "Mayor de 10" ELSE PRINT "Menor o igual que 10"
Hemos empleado el signo ">" para ver si una variable es mayor que un cierto valor. Veamos cómo se indican las otras comparaciones posibles:
> Mayor que >= Mayor o igual que < Menor que <= Menor o igual que = Igual a <> Distinto de
Las condiciones se pueden enlazar con AND (y), OR (ó), NOT (no), pero entonces puede ser interesante emplear paréntesis, para que el resultado sea más legible (y para evitar problemas de precedencia de operadores, que no trataremos todavía), por ejemplo:
IF ((a>2) AND (b<>3)) OR (NOT (c>3)) THEN PRINT "Es valido"
1.6 Repitiendo una serie de pasos
La palabra "bucle" es el nombre que se da a una parte del programa que se repite un cierto número de veces. En Basic, esto se consigue con la orden FOR, que vamos a ver directamente con un ejemplo:
10 ' Escribimos un saludo 5 veces 20 FOR i = 1 TO 5 30 PRINT "Hola" 40 PRINT "Como estas?" 50 NEXT i 60 PRINT "Se acabaron las repeticiones"
En español, este FOR se podría traducir como un "Desde", de modo que la línea 20 sería "desde que i valga 1 hasta 5", es decir estamos usando una variable auxiliar, que comenzará valiendo 1, y el trozo de programa se repite lo hará hasta que esa variable i valga 5.
La línea 50 indica el final de la parte que se repite, y hace que se pase al próximo (next) valor de la variable i. Es decir, hace que pase de 1 a 2 y que se vuelvan a repetir las líneas 30 y 40; en la siguiente pasada, i aumenta de 2 a 3, y se vuelven a repetir las líneas 30 y 40; así sucesivamente, hasta que i vale 5, momento en que dejan de repetirse las líneas 30 y 40.
El resultado de este programa será:
Hola Como estas? Hola Como estas? Hola Como estas? Hola Como estas? Hola Como estas? Se acabaron las repeticiones
Es muy frecuente emplear la orden FOR para contar, aprovechando eso de que la variable empieza valiendo 1 y termina valiendo lo que le indiquemos. Por ejemplo, podemos contar del 1 al 8 así:
10 ' Escribimos del 1 al 8 20 FOR n = 1 TO 8 30 PRINT n 40 NEXT n
que escribiría lo siguiente en pantalla:
1 2 3 4 5 6 7 8
O podemos escribir la tabla de multiplicar del 5 así:
10 ' Tabla de multiplicar del 5 20 FOR factor = 1 TO 10 30 PRINT "5 x "; factor; " vale: "; 40 PRINT factor * 5 50 NEXT factor
El resultado de este programa sería:
5 x 1 vale: 5 5 x 2 vale: 10 5 x 3 vale: 15 5 x 4 vale: 20 5 x 5 vale: 25 5 x 6 vale: 30 5 x 7 vale: 35 5 x 8 vale: 40 5 x 9 vale: 45 5 x 10 vale: 50
No necesariamente tenemos que contar de uno en uno. Para ello se emplea la orden STEP (paso, en inglés). Por ejemplo, podemos escribir los número pares del 1 al 20 así:
10 ' Numeros pares del 1 al 20 20 FOR n = 2 TO 20 STEP 2 30 PRINT n 40 NEXT n
O podemos contar "hacia atrás" usando un paso negativo:
10 ' Descontar desde 10 hasta 0 20 FOR x = 10 TO 0 STEP -1 30 PRINT x 40 NEXT x
Podemos incluir un FOR dentro de otro. Por ejemplo, podríamos escribir la tabla de multiplicar completa así:
10 ' Tabla de multiplicar completa 20 FOR tabla = 1 to 10 30 FOR factor = 1 TO 10 40 PRINT tabla; " x "; factor; " vale: "; 50 PRINT tabla * factor 60 NEXT factor 70 PRINT : ' Linea en blanco entre tablas 80 NEXT tabla
En este programa he ido escribiendo un poco más a la derecha lo que dependía de cada FOR, para intentar que resulte más legible. Esto es lo que se conocer como "escritura indentada", y lo usaré con frecuencia a partir del apartado 2.
En este programa también hay otra novedad, en la línea 70: podemos escribir varias órdenes en una misma línea, si las separamos por un símbolo de "dos puntos" ( : ). Si se hace siempre, como costumbre, puede ser contraproducente, porque el programa resulte difícil de leer, pero a veces será interesante para dos órdenes muy relacionadas, o, como en el ejemplo anterior, para añadir un comentario aclarador al final de una orden.
Como curiosidad, en los CPC, si esa segunda orden que hay en una misma línea es un comentario, bastaría empezar con el apóstrofe ( ' ), sin necesidad de usar los dos puntos para separar. Aun así, no es una mala costumbre poner los dos puntos siempre que añadamos otra orden a una línea, incluso sabiendo que en algún caso puntual quizá no fuera totalmente necesario.
El resultado de este programa debería ser algo así:
1 x 1 vale: 1 1 x 2 vale: 2 1 x 3 vale: 3 [... (muchas mas lineas aqui en medio) ...] 9 x 7 vale: 63 9 x 8 vale: 72 9 x 9 vale: 81 9 x 10 vale: 90 10 x 1 vale: 10 10 x 2 vale: 20 10 x 3 vale: 30 10 x 4 vale: 40 10 x 5 vale: 50 10 x 6 vale: 60 10 x 7 vale: 70 10 x 8 vale: 80 10 x 9 vale: 90 10 x 10 vale: 100
En el Basic de los CPC (y en la mayoría de las versiones de Basic) no es necesario poner después de la palabra NEXT el nombre de la variable a la que se refiere, porque el propio intérprete de Basic será capaz de deducirlo:
10 ' Numeros pares del 1 al 20 20 FOR n = 2 TO 20 STEP 2 30 PRINT n 40 NEXT : ' Se sobreentiende que es "n"
Aun así, en programas grandes, puede ser interesante conservar el nombre de la variable, buscando una mayor legibilidad.
Más adelante veremos otras órdenes más sofisticadas para controlar partes del programa que se repitan, como es el caso de WHILE.
1.7 Guardando nuestro programa
Con todo esto ya se puede "empezar a hacer cosas". Pero trabajar y perder el trabajo hecho es desmotivador. Lo razonable es poder guardar el trabajo, especialmente si no es sólo una prueba, sino algo que vamos a utilizar más adelante, o algo que todavía no hemos terminado.
Vamos a ver (por ahora) sólo dos casos, que espero que sean los más frecuentes:
Primer caso: si estás sentado delante de un "CPC de verdad" equipado con unidad de disco (6128 o 664), bastaría con que introdujeras un diskette con suficiente espacio libre y teclearas
SAVE "prueba"
(Nota: recuerda que no hace falta que lo escribas en mayúsculas; yo lo hago para que sea más fácil distinguir las órdenes de lo que no lo son. Por otra parte, en vez de "prueba" podrías escribir cualquier otro nombre, con dos condiciones: que sea entre comillas y que contenga un máximo de ocho letras o números, sin espacios.
Segundo caso: si estás usando un emulador. En ese caso tienes dos opciones: guardarlo en una "imagen de disco", imitando lo anterior, o bien otra opción que a mí me gusta más... algunos emuladores, como el CPCE, permiten guardar "supuestamente en cinta", pero esa falsa cinta corresponde a una carpeta de nuestro disco duro. Eso es una forma MUY sencilla de intercambiar información entre nuestro "ordenador real" y nuestro "cpc virtual". Esto además tiene otra ventaja: las posibilidades de edición del CPC (que veremos más adelante) eran muy avanzadas para su época, pero no hay comparación con los editores actuales. Si sabemos pasar del CPC al PC, podremos introducir rápidamente fuentes que encontremos por Internet, o teclear nuestros fuentes con editores que muestren la sintaxis en colores y que permitan copiar y pegar de forma muy rápida.
Pues vamos allá: contaré lo que habría que hacer en CPCE, pero será fácil de aplicar a otros muchos emuladores. El primer paso es decirle que no queremos usar el cassette de verdad (si es que el emulador lo permite), sino una carpeta del disco duro. En el caso de CPCE, esto se consigue desde el menú "Options", escogiendo "Type Bypass":
Ahora guardaremos en esa "falsa cinta", con una última precaución: el CPC guardaba los fuentes en un formato especial, que no era legible directamente, así que no los podríamos aprovechar desde fuera con facilidad. Pero hay una alternativa: si añadimos ",a" al final de la orden de guardado, se salvará como ASCII puro, que sí podremos editar desde cualquier otro equipo:
|TAPE SAVE "prueba.bas",a
¿Y si queremos cargar un fuente ya existente? Similar, pero con LOAD en vez de SAVE:
|TAPE LOAD "prueba.bas"
O la alternativa más cómoda, que es usar LOAD"", sin indicar nombre de fichero, para que se nos muestre una lista con los ficheros existentes y podamos elegirlo aunque no recordemos su nombre:
|TAPE LOAD ""
(Veremos más detalles sobre |TAPE, LOAD, SAVE y las órdenes relacionadas un poco más adelante)
Si prefieres WinAPE, que es otro de los emuladores más prestigiosos y que también se sigue actualizando con frecuencia, tienes opciones para crear un "supuesto disco" (una imagen de disco, "Disc Image"), desde el menú File, dentro de las opciones Disco A y Disco B ("Drive A:", "Drive B:"). Para grabar en ese disco usaríamos la orden SAVE de Locomotive Basic, pero en este caso NO habría que teclear antes |TAPE.
Además, en ese mismo menú tenemos una interesante opción "Edit Disc", desde la que podremos echar un vistazo al contenido del diskette, borrar ficheros, copiar algún fichero para llevarlo a una carpeta de Windows, o incluso pegar un fichero procedente de Windows:
1.8 El teclado de un CPC
Si estás usando un CPC de verdad, no tendrás problemas para encontrar teclas como la flecha hacia arriba o la barra vertical. En cambio, si lo estás emulando desde un PC o cualquier otro equipo, es fácil que las teclas correspondan a otras que tienen dibujado un símbolo distinto. Aquí tienes una representación del teclado original de un CPC, para que te cueste menos localizar cada símbolo:
Esta es la distribución que suelen usar los emuladores, y que corresponde al teclado original en inglés. Puedes observar que no hay eñe, que el punto y coma y los dos puntos están a la derecha de la L, que el apostrofe (comentarios) se usa con mayúsculas + 7, y que la barra vertical de las órdenes extendidas como |TAPE está junto a la P.
Aun así, puede haber ligeras diferencias de un ordenador anfitrión a otro. Por ejemplo, en mi equipo, la tecla \ no está en la parte derecha de la línea inferior, sino en la izquierda, junto a la Z.
1.9 Un primer ejercicio propuesto
Con lo que hemos visto hay suficiente para hacer programas sencillos, así que un primer reto podría ser éste:
Crear un juego simple de adivinar números. En la línea 10 del programa habrá un número prefijado, entre el 1 y el 100, que el usuario tendrá un máximo de 6 intentos para adivinar. En cada intento se le dirá si se ha quedado corto, si se ha pasado o si ha acertado (si acierta, terminará la partida, aunque le quedaran todavía intentos).