Repaso de C: control de flujo

En C las instrucciones o proposiciones se terminan con ; . Las instrucciones se pueden agrupar con { … } para dar lugar a proposiciones compuestas o bloques.

Las instrucciones de control de flujo son las que permiten tomar decisiones y controlar por dónde fluye la ejecución del programa. En el caso de C son:

  • if – else if – else.
  • switch.
  • while.
  • for.
  • do – while.
  • break y continue.
  • goto y etiquetas.

Lo más simple es ver un ejemplo de cada tipo:

if – else if – else:

La instrucción if evalúa una condición y, si se cumple, ejecuta el bloque que sigue. Este bloque puede ser simple, en cuyo caso no hacen falta llaves, o compuesto:

En caso de que no se cumpla la condición, tenemos la rama else opcional, que también puede tener un bloque simple o compuesto:

Y si se quieren evaluar varias condiciones seguidas, tenemos else if:

switch:

La instrucción switch es similar al if – else if – else, es decir, también vale para decisiones múltiples. La principal diferencia es que, en vez de evaluar una expresión arbitraria y decidir si es cierta (!= 0) o falsa (== 0), como el if, compara la expresión, normalmente una variable, con un conjunto limitado de valores constantes.

Por ejemplo, la instrucción switch:

es básicamente equivalente a if (a == 0) {…} else if (a == 1) {…} else if (a == 2) {…} else {…}.

Sí hay un matiz importante, y es que en un if – else if – else sólo se ejecuta una de las ramas. Sin embargo, en un switch se evalúan y ejecutan todas las ramas case a partir de la coincidencia, salvo que de forma explícita se decida salir del switch con un break. La instrucción break también se utiliza para salir de bucles while, for y do – while.

while:

La instrucción while sirve para hacer bucles. La condición de terminación del bucle se evalúa primero, y el bucle se ejecuta hasta que deja de cumplirse:

Cuando el cuerpo del while es una proposición simple también se pueden obviar las llaves. Esto es una norma general de todas las instrucciones de control de flujo.

for:

La instrucción for también vale para implementar bucles. Es un poco más compleja que while, porque tiene una inicialización, una condición de terminación del bucle, y una expresión que se ejecuta al final de cada iteración, y que típicamente se utiliza para incrementar o decrementar un contador.

Lo bueno del for es que todo lo que controla el bucle, la inicialización, la condición de terminación / continuación, y el cambio de una iteración a la siguiente, están claros y en el mismo sitio.

do – while:

El do – while es el tercer tipo de bucle en C. A diferencia del while, primero se ejecuta el cuerpo el mismo, y luego se comprueba la condición. Por tanto, un do – while tiene sentido cuando el bucle tiene que ejecutarse al menos una vez:

Hay bucles, sin embargo, que tienen que ejecutarse 0 o más veces, en función del valor de una variable. Para estos es mejor un while.

break y continue:

En todos los tipos de bucles cabe la opción de salir del mismo. Esto se hace con la instrucción break, que ya se presentó con el switch.

Igualmente, también cabe la opción de saltar a la siguiente iteración, lo cual se hace con la instrucción continue. Esto no tiene sentido en un switch:

goto y etiquetas:

Por último, C soporta etiquetas y goto. Las etiquetas son como las etiquetas de ensamblador: sirven para marcar posiciones en el código. Se nombran como las variables (letras, números y algunos símbolos), pero tienen que terminar con : .

Por su parte, el goto es una instrucción que hace saltar la ejecución a una etiqueta. El goto y la etiqueta tienen que estar en la misma función:

En general, el goto está desaconsejado, porque todo lo que se puede escribir con goto se puede también escribir sin él, resultando más fácil de entender y mantener.


Código de ejemplo: control_flujo

Repaso de C: operadores y expresiones

Operadores y operandos:

Como en el caso de las variables, todo programador tiene una idea intuitiva de qué es un operador: es un signo u operación que relaciona unos operandos (variables o constantes) para devolver un valor.

En C, como en otros lenguajes, hay muchos tipos de operadores:

  • Operadores aritméticos: Sirven para realizar operaciones aritméticas. Son +, -, *, / y % (resto de la división entera). No hay exponenciación.
  • Operadores de relación: Sirven para comparar. Son >, >=, <, <=, == y !=. No se debe confundir la igualdad (==) con la asignación (=).
  • Operadores lógicos: Sirven para realizar operaciones lógicas o booleanas, es decir, && (AND), || (OR) y ! (NOT). En C no existe el tipo boolean, así que se toma 1 como true (realmente distinto de 0) y 0 como false.
  • Operadores de incremento y decremento: Son ++ y –, y sirven para incrementar o decrementar una variable. Lo curioso es que pueden usarse como prefijo o sufijo, hablándose de preincremento, postincremento, etc. En la versión prefijo primero se incrementa o decrementa y luego se devuelve el valor; en la versión sufijo primero se devuelve el valor y luego se incrementa o decrementa.
  • Operadores de manejo de bits: Son & (AND), | (OR), ^ (OR exclusivo), << (desplazamiento a la izquierda), >> (desplazamiento a la derecha) y ~ (complemento a uno o negación). Como se puede ver, C es de alto nivel, pero no tanto, porque se puede operar directamente con bits.
  • Operadores de asignación: El operador de asignación por excelencia es el =, que asigna un valor a una variable. Pero hay más, porque la mayoría de operadores binarios (+, -, *, /, %, …) tienen también un operador de asignación asociado (+=, -=, *=, /=, %=, …). Por ejemplo, la asignación i = i +2 también puede ponerse como i += 2.

Hay más operadores, como los que tienen que ver con estructuras (. y ->), con arrays ([]), con direcciones y punteros (* y &), con funciones (paréntesis), con conversión de tipos o “casting”, sizeof para obtener el tamaño de una variable, etc. Todos estos operadores se verán más adelante.

Lo que sí es bastante complejo son las reglas de precedencia y asociación de los operadores de C (extracto del libro de Kernighan & Ritchie):

Expresiones:

Las expresiones son un tipo especial de instrucción que devuelven un valor. Por ejemplo, todas las operaciones vistas anteriormente (aritméticas, de relación, booleanas, de manejo de bits, etc.) conforman expresiones, porque devuelven un valor.

En particular, las asignaciones no sólo almacenan un valor en una variable; además, devuelven ese valor para hacer más cosas con él, si se quiere. Por este motivo se pueden hacer cosas como i = j = 0. Esto no sólo asigna 0 a la variable j, sino que además devuelve el valor 0, que se asigna a la variable i. Es decir, la asignación j = 0 es, además, una expresión.

Hay un tipo especial de expresión que es la expresión condicional. Ésta verifica una condición y, en función del resultado, devuelve un valor u otro. Se expresa con el operador ternario ? : . Por ejemplo, (a > b) ? a : b devuelve a si a > b y b en caso contrario.


Código de ejemplo: operadores

Repaso de C: variables, tipos, constantes y declaraciones

Variables:

Todo programador tiene una idea intuitiva de qué es una variable: un trocito de memoria que guarda un valor. Las variables tienen:

  • Una dirección de memoria.
  • Un nombre.
  • Un valor, que puede cambiar, por eso se llama variable.
  • Un tipo.

En C, los nombres de las variables tienen que empezar por una letra, y pueden contener letras, algunos símbolos y números. Por supuesto, el nombre no puede ser una palabra reservada del lenguaje. Las mayúsculas y las minúsculas se consideran diferentes. Las variables se suelen nombrar con minúsculas y las constantes simbólicas con mayúsculas.

Tipos de datos:

Las variables tienen un tipo, que define el conjunto de valores que pueden tomar. Los tipos de datos pueden ser básicos o estructurados.

Los tipos básicos son los más sencillos, los que aporta el lenguaje de forma directa. En el caso de C son:

  • char.
  • int.
  • float (no soportado en cc65).
  • double (no soportado en cc65).

Estos tipos básicos se pueden modificar con los calificadores:

  • short y long.
  • signed y unsigned.

El primero hace referencia al tamaño en bytes, y el segundo al carácter con signo / sin signo.

Una curiosidad de C es que no fija el tamaño en bytes de sus tipos básicos o primitivos. Sólo fija que un short tiene que ser menor que un int, que tiene que ser menor que un long. Esto ha dificultado su portabilidad entre máquinas.

Constantes y constantes simbólicas:

Las constantes –o valores constantes– son valores fijos que se utilizan en inicializaciones, expresiones, llamadas a funciones, etc. Las constantes también tienen un tipo, que puede ser el natural a partir de su sintaxis o se puede forzar mediante sufijos. Lo mejor es ver ejemplos:

  • 1234 es una constante de tipo int.
  • 123456789L es una constante de tipo long.
  • 123.4 es una constante de tipo double.
  • ‘A’ es una constante de tipo char.
  • “programa” es una constante de tipo array de char (cadena).
  • Etc.

Las constantes de tipo int se pueden expresar en decimal, en octal empezando por 0, o en hexadecimal empezando por 0x.

Los caracteres especiales se pueden representar mediante secuencias de escape. Por ejemplo, la nueva línea se puede representar con \n, la barra invertida con \\, etc. También se puede usar \xHH, donde HH es el valor ASCII en hexadecimal.

Con la instrucción del preprocesador #define es posible definir constantes simbólicas, es decir, nombres que equivalen a un valor fijo. Por ejemplo, #define SPRITES_NUM 8 hace que el nombre SPRITES_NUM equivalga a 8.

También es posible definir enumeraciones, por ejemplo:

enum meses {ENE=1, FEB, MAR, ABR, MAY, JUN, JUL, AGO, SEP, OCT, NOV, DIC}

lo cual equivale a definir ENE = 1, FEB = 2, MAR = 3, etc.

Declaraciones:

Para poder usar una variable, antes hay que declararla. Al declararla se indica:

  • Su tipo.
  • Su nombre.
  • Y una inicialización opcional.

Por ejemplo:

  • int contador = 0;
  • char car = ‘a’;

En función de donde se declaren, las variables pueden ser locales a una función o globales al programa (en C se llaman variables “externas”).

Las variables locales, si no se inicializan, contienen basura. Y si están inicializadas, se inicializan en cada ejecución de la función (salvo que se declaren static).

Las variables globales se inicializan sólo una vez antes de iniciarse la ejecución del programa. Se inicializan a 0 salvo que tengan una inicialización explícita.

En una declaración se puede usar el calificador const para indicar que una variable no cambia su valor. Sería una variable constante, si vale la paradoja. También se puede usar const en los parámetros de las funciones.


Código de ejemplo: variables

Repaso rápido del lenguaje de programación C

Llegados a este punto, y de cara a desarrollar un posible proyecto en C para el C64, lo suyo sería repasar de forma breve, aunque sistemática, el lenguaje de programación C.

Y la biblia de C ya sabéis cual es, el libro escrito hace décadas por los diseñadores del lenguaje (Brian Kernighan y Dennis Ritchie). Este libro ha tenido varias ediciones según ha ido evolucionando el lenguaje y, en particular, por su proceso de estandarización en ANSI:

Siguiendo un poco la estructura de este libro, los aspectos principales a revisar serían:

  • Variables.
  • Tipos de datos.
  • Constantes.
  • Declaraciones.
  • Operadores.
  • Expresiones.
  • Control de flujo.
  • Funciones.
  • Estructura de un programa C.
  • Preprocesador.
  • Punteros.
  • Arrays.
  • Estructuras.
  • Uniones.
  • Typedef.
  • Librerías estándar.

Por supuesto, el lenguaje C tiene muchos más aspectos, pero lo anterior es lo fundamental. Sólo eso ya dará para varias entradas.

Un libro interesante de programación retro en C

A lo largo de este blog ya hemos mencionado, al menos en un par de ocasiones, la página web https://8bitworkshop.com/, relativa a la programación retro de diferentes máquinas de 8 bits. Pues bien, vinculados a esa página web hay varios libros que se puede ver en la dirección:

https://8bitworkshop.com/docs/books/index.html

De todos ellos, el que me parece más interesante es el titulado “Making 8-bit arcade games in C”, de Steven Hugg:

Como indica su título, está dedicado a la programación en C de juegos para máquinas de 8 bits.

Es importante destacar que el libro no trata específicamente el C64. Sí trata otras plataformas de los 80 como Midway 8080, VIC Dual, Galaxian / Scramble, Atari y Williams. Se trata de plataformas hardware específicas para juegos de tipo arcade.

De hecho, el libro toca un poco de todo:

  • Conceptos básicos de microprocesadores.
  • Conceptos y ejemplos de programación en C.
  • Plataformas de hardware como las mencionadas.
  • Y la programación de diferentes proyectos o juegos.

El libro va saltando de una temática a otra a lo largo de sus 31 capítulos y 220 páginas, pero yo diría que el hilo conductor principal son las diferentes plataformas y cómo fueron evolucionando con el paso del tiempo.

En definitiva, un libro interesante y que guarda relación con lo que venimos tratando aquí últimamente.

Desarrollo de una librería de sonido en C

Igual que hemos hecho con los sprites, se podrían desarrollar librerías en C para trabajar en modo bitmap, modo bitmap multicolor, definir y activar juegos de caracteres personalizados, hacer scroll, etc. Algunas de estas librerías ya estarían parcialmente cubiertas por otras propias de cc65, como TGI; otras no.

Sea como fuere, la otra gran librería que podemos hacer es una librería de sonido en C, y a esto es a lo que vamos a dedicar esta entrada.

Nuevamente, si nos inspiramos en la librería en ensamblador del Volumen II:

https://programacionretroc64.files.wordpress.com/2019/11/lib-v2.zip

y, más concretamente, en el fichero “LibSonido.asm”, vemos que tiene rutinas para:

  • Inicializar una imagen del SID.
  • Transferir la imagen del SID (al SID, claro).
  • Fijar el volumen.
  • Fijar la frecuencia de una voz.
  • Fijar la forma de onda de una voz.
  • Fijar el ADSR de una voz (attack – decay – sustain – release).
  • Fijar el ancho de pulso de una voz, en caso de que la forma de onda sea cuadrada.
  • Configurar un filtro sobre una voz.
  • Activar una voz.
  • Desactivar una voz.
  • Pasar de octava y nota a frecuencia.
  • Introducir un retardo.

Pues bien, todo esto perfectamente puede hacerse en C. Es más, es mucho más cómodo usarlo mediante una librería (pareja de ficheros sonido.h y sonido.c) que conociendo y manejando las estructuras de datos que cc65 define en _sid.h:

Vamos a ello:

Fichero de cabecera sonido.h:

El fichero de cabecera tiene una primera parte de definición de constantes que es así:

Es decir, aparte de controlar si el fichero ya está incluido con __SONIDO_H, define constantes para el tamaño del SID (25 registros de sólo escritura; 29 en total), para las tres voces (que ahora vamos a numerar 0, 1 y 2), para las formas de onda y para los tipos de filtro. También define el tipo byte.

A partir de ahí, incluye prototipos para las funciones de interés:

No vamos a repetir aquí las funciones, porque en el fondo son las mismas que las rutinas que ya se han enumerado para la librería en ensamblador.

Sí interesa recordar que, al ser el SID en su mayoría registros de sólo escritura, salvo los cuatro últimos ($d419 – $d41c), que son de sólo lectura, aplicaremos la técnica de trabajar sobre una imagen del SID (un array de 25 posiciones, uno por cada registro de sólo escritura) y copiar o transferir esa imagen al SID cuando se quiera configurar éste. De este modo será posible conocer y modificar el estado del SID a partir de su imagen.

Fichero de implementación sonido.c:

El fichero que implementa la librería empieza con esta apariencia:

Es decir, primero incluye el header file sonido.h (con “…” para que no se busque en cc65\include, sino en el mismo directorio que sonido.c) y algunas librerías estándar. Después recoge tres tablas de interés:

  • La tabla sonido_imagen_sid[] es la imagen del SID. Esta es la tabla que vamos a configurar con las diferentes funciones y, llegado el momento, vamos a transferir o copiar al SID.
  • La tabla sonido_offset_voces[] nos da el offset de los registros de cada voz ($00, $07 y $0e respectivamente) dentro del mapa de memoria del SID.
  • La tabla sonido_frecuencias_oct7[] nos da las frecuencias correspondientes a las 12 notas de la octava 7, y que nos permite calcular las frecuencias de esas mismas notas en otras octavas (0…6).

A partir de ahí, vienen las implementaciones de las diferentes funciones. E, igual que en el caso de la librería de sprites, no vamos a revisarlas todas, sino alguna seleccionada:

Por ejemplo, para la función sonido_fija_volumen():

  • Recibe el volumen en un byte, aunque sólo ocupa un nibble.
  • Se queda con el nibble bajo mediante un AND (volumen & 0x0F).
  • Toma la posición 0x18 = 24 de la imagen del SID, le hace un OR con el volumen (sonido_imagen_sid[0x18] | volumen), y lo vuelve a guardar en la posición 0x18.

Esto último, es decir, el tomar la posición y hacerle un OR, lo podemos hacer porque estamos trabajando con una imagen del SID. Directamente contra el SID no sería posible hacerlo, porque esos registros son de sólo escritura.

Ya sólo nos quedaría transferir la imagen al SID para que el cambio de volumen fuera efectivo.

Por otro lado, la función sonido_fija_frecuencia() hace cosas parecidas, por ejemplo un AND (frecuencia & 0x00FF) para quedarse con el byte low o menos significativo de la frecuencia, y un desplazamiento de 8 bits a la derecha (frecuencia >> 8) para quedarse con el byte high o más significativo.

Todo esto demuestra que C es un lenguaje de “alto nivel”, pero no mucho, ya que tiene operadores como &, |, >> y muchos otros que permiten operar con bits de forma similar al ensamblador.

Programa de ejemplo:

Para el programa de ejemplo nuevamente nos vamos a basar en uno ya conocido, concretamente el programa 53 del Volumen I:

Este programa, tanto la versión en ensamblador como la versión en C, tiene una tabla de cuatro entradas, siendo cada entrada:

  • La octava y la nota de la voz 0.
  • La octava y la nota de la voz 1.
  • La octava y la nota de la voz 2.
  • La duración y el volumen, que son comunes a las tres voces.

Y para que la tabla con la melodía ocupe lo menos posible, octavas y notas se codifican en el mismo byte, a razón de un nibble cada una, al igual que la duración y el volumen.

Por tanto, lo que tiene que hacer el programa es inicializar las voces con su forma de onda y ADSR y, luego, reproducir la melodía. Para esto último:

  • Lee un byte de la tabla, separa octava y nota, calcula la frecuencia, y configura la voz 0 con esa frecuencia.
  • Idem para la voz 1.
  • Idem para la voz 2.
  • Lee un byte de la tabla, separa duración y volumen, y configura el volumen para las tres voces.
  • Activa las tres voces y transfiere la imagen al SID. Hasta este punto el SID no ha cambiado.
  • Espera la duración de la nota.
  • Y repite todo lo anterior hasta que termine la melodía, lo cual se señaliza con el byte $ff, que no es un byte válido pues el C64 no soporta ni $0f = 15 octavas ni 15 notas por octava.
  • Para terminar, desactiva las tres voces y vuelve a transferir la imagen al SID. Esto último –desactivar las voces– se puede hacer en cada iteración del bucle, es decir, de una nota a la siguiente, pero si se hace sólo al final del mismo la reproducción queda como más fluida.

Y como el programa es largo, aunque esencialmente es un bucle, sólo vamos a ver en detalle algunas de sus funciones más representativas. Por ejemplo, la función configura_frecuencia() es así:

Es decir, recibe como parámetros la pareja (octava, nota) y la voz, que salen de la tabla con la melodía, y separa el nibble alto (octava) del nibble bajo (nota), imprime ambos con printf(), obtiene la frecuencia asociada con sonido_obten_frecuencia(), también la imprime, y fija esa frecuencia para la voz en cuestión.

Por su parte, configura_volumen() es parecida:

Es decir, recibe la pareja (duración, volumen), separa el nibble alto (duración) del nibble bajo (volumen), imprime ambos con printf(), y fija el volumen con sonido_fija_volumen(). Aquí no interviene la voz porque el volumen es común para todas.

Si compilamos y ejecutamos el programa el resultado es así, aparte de escuchar una bonita canción:

Los datos que se muestran en cada fila son la voz, la octava, la nota y la frecuencia. Esto para las tres voces (numeradas ahora como 0, 1 y 2), y luego la duración y el volumen.


Código de ejemplo: sonido