Algoritmos y Programación en Pascal

C.2. Desarrollo completo de un programa en Turbo Pascal 515
Figura C.4.
A continuación recompilamos el programa y, al ejecutarlo, el depurador
asume el control del programa.
Para ejecutar el programa paso a paso, sin entrar en las llamadas a la función,
elegimos la opción [F10] [Run] [Step over] o simplemente pulsamos repetidamente
[F8], viendo cómo las líneas del programa se van iluminando y ejecutando
sucesivamente. La pantalla alterna entre la ventana de edición y la de salida.
Podemos ver que las llamadas recursivas a la función se resuelven en un solo
paso.
Para ejecutar paso a paso, pero entrando en las llamadas a subprogramas,
elegimos la opción [F10] [Run] [Trace into] o pulsamos repetidamente [F7],
viendo cómo las líneas de la función se iluminan al irse ejecutando. En el ejemplo
del factorial, la función se repite varias veces debido a las llamadas recursivas.
Hay que tener cuidado y no pasarse del final del programa, ya que en tal caso se
vuelve a comenzar.
La ejecución paso a paso tiene su complemento perfecto con la inspección de
constantes, variables y parámetros, que nos permitirá examinar los valores que
tienen estos objetos tras la ejecución de cada instrucción. Para ello hay que abrir
una ventana de inspección llamada Watches, en la que, en nuestro ejemplo,
colocaremos los identificadores n y num. Hacemos [F10] [Debug] [Watch], con
lo que se abre la ventana, y después [F10] [Debug] [Add Watch] o simplemente
[Ctrl]+[F7], lo que permite introducir los identificadores que se deseen.
Si se ejecuta el programa paso a paso, se verán los valores adoptados en cada
momento por los objetos incluidos en la ventana de inspección. En el ejemplo,
al comenzar el programa tanto n como num son etiquetados como identificadores
desconocidos (Unknown identifier), para cambiar posteriormente, adoptando
n el valor introducido por el usuario, y reduciéndose num en cada llamada recursiva.
En la figura C.4 vemos la apariencia de la ventana Watches en un punto
intermedio del proceso, donde las sucesivas llamadas recursivas han ido reduciendo
el valor del argumento de la función hasta alcanzar el caso base.