En este capítulo se examinará la compilación de programas de código
fuente en tres lenguajes de alto nivel: "C", FORTRAN y COBOL. En la
segunda parte del capítulo se analizará el mantenedor de archivos y
bibliotecas. El archivo permite crear una biblioteca de módulos de
objetos. Estos archivos son utilizados por el editor de enlaces.
2.1 "C": Programa de ejemplo con un archivo principal y dos funciones en
un solo archivo
Basándose en las opciones de la línea de comandos, cc compila, ensambla
y carga programas de código fuente en lenguaje C. También puede
ensamblar y cargar programas fuente en lenguaje ensamblador o
simplemente cargar programas de objetos.
+===============================================================+
| Command Format: cc [options] file-list |
| |
| (See Appendix E for a complete list of options) |
+===============================================================+
Al utilizar la utilidad cc, se observan las siguientes convenciones:
1. Un nombre de archivo con la extensión .c indica un código fuente
en lenguaje C.
2. Un nombre de archivo con la extensión .s indica un código fuente
en lenguaje ensamblador.
3. Un nombre de archivo con la extensión .o indica un código objeto.
La utilidad cc tomará su entrada del archivo o archivos que especifique
en la línea de comandos. A menos que utilice la opción -o, almacenará el
programa ejecutable en un fichero denominado a.out.
Código fuente de programa en lenguaje C de ejemplo:
Sin ninguna opción, cc acepta código fuente en C y programas en lenguaje
ensamblador que siguen las convenciones descritas anteriormente.
Compilará, ensamblará y cargará estos programas para producir un
ejecutable llamado a.out. La utilidad cc coloca el código objeto en
archivos con el mismo nombre de archivo base (todo lo que está antes del
punto) que el código fuente, pero con una extensión de nombre de archivo
o. a.out significa salida en ensamblador. Este es el valor
predeterminado.
Sesión de muestra:
+---------------------------------------------------------------+
| $cc hola.c |
| $a.out |
| Hola desde main! |
| Llamando a funcion1! |
| |
| Hola desde funcion1! |
| |
| Volviendo desde funcion1! |
| |
| Llamando desde funcion2! |
| |
| Hola desde funcion2! |
| |
| Volviendo desde funcion2! |
| |
| Eso es todo! |
| $ |
+---------------------------------------------------------------+
NOTA: El archivo a.out creado por la utilidad cc tiene los siguientes
permisos:
usuario: lectura, escritura y ejecución
grupo: lectura y ejecución
otros: lectura y ejecución
No es necesario que cambie los permisos mediante el comando chmod, ya
que la utilidad cc establece los permisos de ejecución por usted.
2.3 "C": cambio de nombre del módulo ejecutable
Puede cambiar el nombre del módulo ejecutable mediante el comando mv.
Los permisos del archivo serán los mismos que antes de cambiar el nombre
del archivo.
Sesión de muestra:
+---------------------------------------------------------------+
| $mv a.out hola |
| $hola |
| Hola desde main! |
| Llamando a funcion1! |
| |
| Hola desde funcion1! |
| |
| Volviendo desde funcion1! |
| |
| Llamando desde funcion2! |
| |
| Hola desde funcion2! |
| |
| Volviendo desde funcion2! |
| |
| Eso es todo! |
| $ |
+---------------------------------------------------------------+
2.4 "C": Dar un nombre al archivo de salida
Es posible enviar la salida a un archivo que usted especifique en lugar
de hacerlo a a.out, recurriendo al siguiente comando:
+===============================================================+
| Command Format: cc -o output source |
| |
| output - the name of the executable file |
| |
| source - the name of the C source code file |
+===============================================================+
La opción -o le indica a cc que le indique al editor de enlaces que
utilice el nombre especificado para la salida en lugar del nombre
predeterminado a.out.
NOTA: No es necesario que la opción -o aparezca después del comando cc.
El nombre de archivo que aparece después de -o es el nombre del archivo
de salida. Por ejemplo, cc source -o output es lo mismo que cc -o output
source.
Sesión de muestra:
+---------------------------------------------------------------+
| $cc -o hola.c |
| $hola |
| Hola desde main! |
| Llamando a funcion1! |
| |
| Hola desde funcion1! |
| |
| Volviendo desde funcion1! |
| |
| Llamando desde funcion2! |
| |
| Hola desde funcion2! |
| |
| Volviendo desde funcion2! |
| |
| Eso es todo! |
| $ |
+---------------------------------------------------------------+
2.5 "C": Generar un listado de ensamblado
Esta opción hace que cc compile programas en C y deje los programas
fuente en lenguaje ensamblador correspondientes en un archivo con
extensiones de nombre de archivo .s.
+===============================================================+
| Command Format: cc -S hello.c |
| |
| -S = Compile only |
+===============================================================+
2.6 "C": Main y dos funciones en forma de tres archivos fuente separados
Este es el mismo programa en C que hemos visto antes, excepto que ahora
está en tres archivos en lugar de uno como antes. Los tres archivos son
main.c, funct1.c y funct2.c.
2.7 "C": compilación pero no producción de un módulo ejecutable
Si se utiliza el programa anterior, el siguiente comando compilará pero
no producirá un módulo ejecutable.
+===============================================================+
| Command Format: cc -c main.c funct1.c funct2.c |
| |
| -c = Compile, but do not load object files. This option |
| causes cc to compile and/or assemble source code |
| programs and leave the corresponding object programs |
| in files with filename extensions of .o. |
+===============================================================+
La opción -c hace que el sistema de compilación suprima la fase de
edición de enlaces. Esto produce uno o varios archivos de objeto, en
este ejemplo (main.o funct1.o funct2.o), que se pueden editar mediante
enlaces en un momento posterior con el comando cc sin opciones.
