Fundamentos de Ordenadores 2

Curso 2010-11

Práctica 4

• Argumentos de un programa
• Ejercicio 1: Imprimir los argumentos del programa
• Ejercicio 2: Palíndromo
• Ejercicio 3: Subrutina de impresión de argumentos de un programa
• Ejercicio 4: Subrutinas de manejo de caracteres

Cuando se escribe y ejecuta un programa en ensamblador, en realidad el código se ejecuta como una subrutina interna de un programa externo. El nombre de esta subrutina es main (así se indica su punto de entrada), y por eso se utiliza ésta como punto de arranque de un programa. Esta rutina, como todas, tiene la posibilidad de recibir parámetros del programa que lo invoca, que en este caso es el propio usuario. Estos parámetros se introducen directamente a través de la línea de comandos.

Supongamos un fichero con nombre printargs.s del que se obtiene el ejecutable printargs. Para ejecutar el programa simplemente se ha de escribir su nombre en el intérprete de comandos. Si a continuación del nombre se escriben una serie de strings separados por espacios, estos strings se pueden acceder desde dentro de la rutina main. Si por ejemplo se introduce la línea:

	unix> printargs argumento1 argumento2 argumento3
      

La forma en que se almacenan estos strings es un array cuyos elementos son sus direcciones de comienzo. En el ejemplo, el primer componente del array es la dirección del string que representa el nombre del programa, el segundo sería la dirección de argumento1 y así sucesivamente. Si ejecutamos el código main, en la primera instrucción, la dirección base del array de strings se encuentra en la posición 8(%esp) (Nótese el nivel de indirección). Este array tiene la particularidad adicional de que en su última posición se ha puesto una dirección de memoria con valor cero, para así poder deducir su tamaño.

La siguiente figura ilustra cómo recibe los parámetros el main y cómo se almacenan en memoria.

Escribir el programa printargs.s que atraviese este array utilizando el modo de direccionamiento base + índice escalado e imprima todos y cada uno de los argumentos que encuentre hasta que se tope con una posición que contiene la dirección cero que denota el final de los argumentos.

A continuación se proponen algunas pruebas para comprobar el funcionamiento del programa:

unix> printargs arg1 arg2 arg3
Arg[0] = printargs
Arg[1] = arg1
Arg[2] = arg2
Arg[3] = arg3
unix> printargs
Arg[0] = printargs
unix> printargs arg1
Arg[0] = printargs
Arg[1] = arg1
unix> printargs as%d%d%d%d%d%d%s%s%s%s%s%s
Arg[0] = printargs
Arg[1] = as%d%d%d%d%d%d%s%s%s%s%s%s
unix>
    
      

Modificar el programa anterior para que después de imprimir todos los argumentos, los imprima así:

unix> printargs arg1 arg2 arg3
Arg[0] = printargs
Arg[1] = arg1
Arg[2] = arg2
Arg[3] = arg3

printargs arg1 arg2 arg3
printargs arg1 arg2 
printargs arg1 
printargs 

unix> printargs
Arg[0] = printargs

printargs

unix> printargs arg1
Arg[0] = printargs
Arg[1] = arg1

printargs arg1
printargs 

unix> printargs as%d%d%d%d%d%d%s%s%s%s%s%s
Arg[0] = printargs
Arg[1] = as%d%d%d%d%d%d%s%s%s%s%s%s

printargs as%d%d%d%d%d%d%s%s%s%s%s%s
printargs

unix>
    
      

Un palíndromo es una palabra o frase que se lee igual de izquierda a derecha que de derecha a izquierda. P. ej.: anilina; dábale arroz a la zorra el abad; amo la pacífica paloma...

Se pide: Escribir un programa llamado palindromo.s que revise los argumentos que se le pasan por la línea de comandos, comprobando si cada uno de ellos es un palíndromo e imprimiendo el mensaje correpondiente por pantalla. (Se consideran los argumentos independientes entre sí)

Por ejemplo:

  unix$ palindromo anilina ordenador ana
  'anilina' es un palindromo
  'ordenador' no es un palindromo
  'ana' es un palindromo
  unix$
  

En el fichero impresion.s codificar la subrutina impresionParam que recibe una dirección de memoria en %eax. Esta dirección de memoria es la dirección a partir de la cual comienza un array de direcciones de cadenas que se han de imprimir. Este array finaliza con un cero, que es el que nos indica que se ha terminado.
Así si queremos imprimir N cadenas, tendremos en memoria:

Dirección	Contenido
EAX	@cadena0
EAX+4	@cadena1
EAX+8	@cadena2
...	...
EAX+4*(N-2)	@cadenaN-2
EAX+4*(N-1)	@cadenaN-1
EAX+4*N	0

Importante: No está almacenado en ninguna parte el número N.

En el fichero impresion.s la cabecera tendrá las siguientes declaraciones (y sólo estas):

.data
formato1:
        .string "%s"
finLinea:
        .string "\n"
.text
.global impresionParam

Para probar el correcto funcionamiento, se recomienda hacer un programa de pruebas aparte, en un fichero llamado prueba.s (es en este fichero donde estará el main).

Para compilarlo:

gcc -o programa prueba.s impresion.s

Se pide modificar las subrutinas de la práctica anterior para que trabajen directamente con los argumentos recibidos en el main. Para ello cada una de las subrutinas debe convertirse en una función main que trabaje con los argumentos recibidos por línea de comandos.

Apartado 1: identificación del tipo de carácter

Escriba un programa que reciba un carácter por línea de comando y escriba por pantalla:

• Minúscula Si es una letra minúscula
• Mayúscula Si es una letra mayúscula
• No Alfabético Si es un carácter no alfabético

Apartado 2: convertir minúsculas en mayúsculas

Escriba un programa que convierta la cadena recibida por parámetro a mayúsculas. escribiendo el resultado por pantalla.

Apartado 3: comparación de caracteres

Se debe realizar un programa que reciba como argumento 2 caracteres. Debe comprar dichos caracteres e indicar su orden alfabético escribiendo por pantalla:

• Iguales si los dos caracteres son iguales
• Menor si el primer caracter está antes (alfabéticamente) que el segundo carácter
• Mayor si el primer caracter está después (alfabéticamente) que el segundo carácter