Universidad Autónoma Metropolitana

Universidad Autónoma Metropolitana - Azcapotzalco
Utilización del Sistema Operativo Unix
Prof. Hugo Moncayo López
Tabla de Contenido
6.5.1
6.5.2
6.5.3
1. Introducción........................................
Leer y salvar archivos............
Sustituciones globales...........
Variables de vi.....................
2. Entrada al sistema...............................
7. Uso del compilador de Lenguaje C....
3. Salir del sistema..................................
7.1 Compilación simple.....................
7.2 Sólo compilación..........................
7.3 Generación de un ejecutable con
varios objetos.........................................
4. Comandos varios................................
4.1 Sistema de ayudas........................
4.2 Sistema de archivos......................
4.2.1 ls Lista contenido de un
directorio...........................................
4.2.2 mkdir crear un
directorio...............
4.2.3 cd Cambiar el
directorio actual........
4.2.4 rmdir Elimina un
directorio...........................................
4.2.5 rm Elimina archivos............
4.2.6 mv Mover archivos..............
4.2.7 Tips........................................
8. Depuración de un programa................
8.1 Establecer puntos de interrupción
8.2 Inicio de la ejecución...................
8.3 Revisar el contenido de las
variables.................................................
8.4 Ejecución paso a paso (sin entrar
a las funciones).......................................
8.5 Ejecución paso a paso (entrando
a las funciones).......................................
8.6 Detección de puntos de falla........
8.7 Manual de referencia de gdb........
9. Ejecución del programa......................
5. Desarrollo de programas.....................
9.1 Lectura de datos de un archivo....
9.2 Escritura de resultados en un
archivo....................................................
9.3 Impresión de programas y
resultados...............................................
9.4 Preparación para impresión..........
6. Uso del editor vi..................................
6.1 Inicio de vi...................................
6.2 Modos de operación de vi............
6.3 Comandos de pantalla..................
6.3.1 Corrimientos de la pantalla....
6.3.2 Movimientos del cursor.........
6.4 Pasar a modo de entrada de texto.
6.4.1 Modificación de texto............
6.4.2 Copia y pegado......................
6.4.3 Comandos miscelaneos.........
6.5 Comandos de línea de comandos.
1
10.
Utilería make...................................
11.
Utilería tar........................................
12.
Compresión de archivos..................
programa ejecutable .
1.Introducción
3.Salir del sistema
Esta guía está elaborada para que los alumnos del
curso de Introducción a la programación que por
primera vez se enfrentan a la necesidad de
desarrollar programas en Lenguaje C en el
ambiente UNIX tengan a la mano los principales
comandos para manejar archivos en su cuenta,
editar sus programas fuentes y datos, compilar y
depurar sus programas e imprimir sus resultados.
Esta guía no es un manual de referencia.
Para salir del sistema, a una petición del sistema
se responde con la combinación Ctrl-d y retorno.
4.Comandos varios
A continuación se presentan algunos comandos de
uso común que son los más necesarios para
utilizar el sistema operativo.
Unix es un sistema operativo multiusuario. Esto
significa que varias personas pueden usar la
computadora concurrentemente desde terminales
interactivas o desde computadoras personales
conectadas a la red.
4.1Sistema de ayudas
Para obtener en la pantalla el manual de un
comando se usa el comando man. Esto nos
permite la consulta de la documentación de
cualquier comando. ejemplo:
En estas notas el texto que escribe la computadora
se presenta en caracteres courier normal y la
respuesta del usuario se presenta en courier en
negritas.
$ man vi
2.Entrada al sistema
Con el comando anterior se presenta en la pantalla
el manual del comando vi (editor de textos).
Cuando se prende la terminal aparece una petición
(“prompt”) del sistema a la que se responde con la
clave del usuario:
En la pantalla aparece la primera página.
comando que acepta man son:
login: alpa326
espacio
delete
Ctrl-B
A continuación aparece la petición de la
contraseña del usuario:
Los
Avanza una página
Salir de man
Retrocede una página
Con el comando man se pueden consultar también
las fucniones de la bilbioteca estándar del
Lenguaje C como:
password: x32jh88a
Al teclear la clave del usuario y la contraseña se
deben
teclear
exactamente
como
se
proporcionaron estos datos, respetando las
mayúsculas y las minúsculas. No se deben hacer
correcciones.
El sistema proporciona tres
oportunidades para introducir estos datos.
$ man printf
4.2Sistema de archivos
El sistema de archivos de UNIX es una estructura
arbolada de directorios en donde el directorio raíz
es:
Cuando se han introducido correctamente la clave
y contraseña el sistema proporciona un mensaje
de bienvenida y al fina presenta una petición para
que usuario comience a introducir comandos.
/
$
cada nivel puede tener archivos y directorios.
En este momento el usuario puede teclear el
nombre de un comando o el nombre de un
Una trayectoria es una cadena de nombres de
directorios separados por diagonales y puede
terminar con el nombre de un directorio o un
2
archivo.
$ cd /usr/lib
Si una trayectoria empieza con diagonal, la
trayectoria se toma a partir del directorio raíz o
principal del sistema de archivos.
establece como directorio actual el directorio lib
que se encuentra en el directorio usr que se
encuentra en el directorio raíz.
/usr/include/system
Si la trayectoria empieza con un nombre, entonces
parte del directorio actual.
4.2.4rmdir Elimina un directorio
proyecto/fuentes
Para eliminar un directorio el directorio debe estar
vacío.
4.2.1ls Lista contenido de un directorio
$ rmdir prueba
Listar el contenido del directorio actual
Elimina el directorio prueba que se encuentra en
el directorio actual.
$ ls
Listar el contenido
incluyendo sus detalles
del
directorio
4.2.5rm Elimina archivos
actual
Este comando nos permite eliminar uno o varios
archivos. Ejemplos:
$ ls -l
Elimina todos los archivos objeto del directorio
actual
Listar el contenido de un directorio con
trayectoria a partir del directorio raíz, incluyendo
sus detalles
$ rm *.o
$ ls -l /usr/include/system
Elimina el archivo listado.lst que se encuentra en
el directorio reportes que a la vez se encuentra en
el directorio actual.
Listar los nombres de los programas C que se
encuentran el directorio fuentes.
$ rm reportes/listado.lst
$ ls fuentes/*.c
4.2.6mv Mover archivos
4.2.2mkdir crear un directorio
Este comando nos permite cambiar de directorio
uno o varios archivos o directorios. Ejemplos:
Crear un directorio en el directorio actual
Mover el archivo lista.lst que se encuentra en el
directorio actual al directorio reportes con el
nombre datos.lst
$ mkdir fuentes
Se crea el directorio fuentes en el directorio
actual.
$ mv lista.lst reportes/datos.lst
Mover el archivo listado.lst al directorio reportes
con el mismo nombre. (cuando el origen es un
archivo y el destino es un directorio el archivo se
mueve a ese directorio con el mismo nombre)
4.2.3cd Cambiar el directorio actual
Cambiar al directorio fuentes que se encuentra en
el directorio actual.
$ mv listado.lst reportes
$ cd fuentes
Cuando el origen y el destino son ambos
directorios, el directorio origen se mueve con todo
su contenido al directorio destino. En el siguiente
Cambia al directorio fuentes que se encuentra en
el directorio actual.
3
ejemplo se mueve todo el directorio fuentes con
su contenido al directorio proyecto_terminal
e).-
Preparar con el editor los datos de prueba.
f).-
Probar el programa. Si el programa no
funciona como esperamos, entonces se
revisa y se realizan las correcciones.
g).-
Si se dificulta encontrar los errores del
programa se puede realizar una corrida de
depuración usando el depurador gdb. Este
programa permite ejecutar paso a paso el
programa y conocer y modificar el valor de
las variables.
h).-
Si después de todo esto no se localizan los
errores del programa se puede acudir a
asesoría con el profesor o el ayudante.
$ mv fuentes proyecto_terminal
El comando mv se puede usar para cambiar de
nombre a un archivo. Esto se logra si el archivo
destino se encuentra en el mismo directorio que el
archivo fuente. En el siguiente ejemplo el archivo
a.out se le cambia el nombre por mi_editor:
$ mv a.out mi_editor
4.2.7Tips
Para poder repetir la ejecución de los comandos
anteriores en el sistema acordeon, es necesario
ejecutar el siguiente comando:
$
6.Uso del editor vi
set -o vi
El editor vi es un editor de pantalla, es decir, nos
permite ver una página del archivo que estamos
editando. Aunque existen otros editores bajo el
sistema operativo Unix es conveniente estar
familiarizado con vi porque es el que siempre
encontramos disponible en todos los sistemas
UNIX.
Después de esto, cada vez que se desea volver a
ejecutar algún comando previo se teclea ESC-k.
Cada ves que tecleamos ESC-k la pantalla nos
muestra el comando anterior. En la línea de
comandos podemos hacer modificaciones
utilizando los comandos del editor vi (ver 6).
5.Desarrollo de programas
El editor vi es muy poderoso pero no es nada
amigable, ya que no proporciona ningún tipo de
ayudas interactivas, ni cuenta con interfaces
modernas como menús ni cuadros de diálogo.
Para usarlo cómodamente es necesario memorizar
sus comandos.
El desarrollo de un programa consiste
básicamente en editar el programa fuente con
algún editor como vi o pico. El programa se
compila con el comando g++ con lo que se genera
el programa ejecutable y finalmente se ejecuta
tecleando como comando el nombre del programa
ejecutable.
En este documento sólo se describen las funciones
más usuales.
Para una mayor información
consulte el manual de vi.
Los pasos para el desarrollo de programas son los
siguientes:
a).-
Desarrollar el algoritmo usando una
herramienta como español estructurado.
b).-
Codificar el programa en un lenguaje de
programación como C o C++.
6.1Inicio de vi
El vi debe trabajar con una variedad de terminales
y para que opere correctamente es necesario
pasarle el modelo de terminal con el que vamos a
trabajar. Esto se hace definiendo una variable de
ambiente con los siguiente comandos:
c).-
Editar los archivos que contienen el
programa con un editor como vi o pico.
$ TERM=vt100
$ export TERN
d).-
Compilar el programa con el compilador
gcc o g++ (para C o C++ respectivamente)
y eliminar los errores que reporta el
compilador.
en el ejemplo anterior se definió para vi como
terminal el modelo vt100 que es el más usual y
que también es el adecuado cuando usamos un
emulador de terminal en una PC.
4
Para verificar el modelo de terminal definido en la
variable de ambiente TERM se ejecuta el
comando:
$ echo $TERM
^d
^e
^b
^u
^y
Para iniciar el editor vi se ejecuta el siguiente
comando:
6.3.2Movimientos del cursor
$ vi tarea.c
h
j
k
l
$
0
%
Con el comando anterior se inicia la edición del
archivo tarea.c el cual si no existe se crea y si ya
existe se permite modificar.
6.2Modos de operación de vi
vi opera en tres modos diferentes: a).- modo
comando de pantalla, modo de entrada y modo
comando de línea. Al iniciar vi se encuentra en
modo de comando de pantalla.
^
nl
B
E
nG
En modo de comando de pantalla cualquier
carácter que teclee el usuario se tratará de
interpretar como comando; en este modo no se
ven los comandos que tecleamos, solamente
percibimos su efecto.
Retrocede el cursor
Siguiente línea
Línea anterior
Adelante
Final de la línea
Principio de la línea
Mover el cursor al paréntesis, corchete o
llave que cierra el actual.
Ir al siguiente carácter no espacio
Colocar el cursor en la columna n
Retroceder una palabra
Avanzar una palabra
Ir a la línea n
6.4Pasar a modo de entrada de texto
Con estos comandos se pasa de modo comando de
pantalla a modo de entrada, es decir, el sistema
permitirá que se introduzcan caracteres que se
incorporarán al archivo en el punto en que se
encuentra el cursor. En todos estos comandos el
cursor se coloca en cierta posición y el sistema
queda listo para inserción de texto en el archivo.
Cuando el modo de entrada se encuentra activo
los caracteres que tecleamos se agregan al archivo
en el punto en donde se encuentra el cursor.
En el modo de comando de línea, el cursor se
coloca en la última línea de la pantalla y nos
permite teclear un comando en esta línea, el
comando se ejecuta cuando oprimimos “entrar”.
vi no nos da ninguna indicación para saber si nos
encontramos en modo de comando de pantalla o
modo de entrada.
i
I
A
a
o
O
En donde esta el cursor
Al principio de la línea
Al final de la línea
Antes del cursor
Agrega una nueva línea debajo del cursor
Agrega nueva línea antes del cursor
Para dar por terminado el modo de entrada y
regresar a modo de comando de pantalla se
oprime la tecla de ESC.
6.3Comandos de pantalla
La mayoría de los comandos de pantalla son de
una sola letra y pueden ser precedidos de un
número que indica cuantas veces se va a repetir el
comando. Por ejemplo el comando dd borra la
línea en donde se encuentra el cursor; si deseamos
borrar cinco líneas a partir del cursos tecleamos
5dd. En ningún momento vemos los símbolos
que constituyen el comando.
6.4.1Modificación de texto
x
Elimina el carácter en la posición del
cursor.
r
Reemplaza el carácter de la posición
del cursor. En seguida debemos
teclear el carácter que reemplaza.
R
Inicia reemplazo de texto.
A
continuación, el texto que tecleamos
sustituye al que existe en el archivo.
C
Reemplaza el texto desde el cursor
hasta el final de la línea con el nuevo
6.3.1Corrimientos de la pantalla
^f
Avanza media página
Avanza una línea
Retrocede una página
Retrocede media página
Retrocede una línea
Avanza una página
5
D
S
dd
J
texto.
Elimina el texto desde el cursor hasta
el final de la línea.
Elimina el texto de la línea actual y
permite la entrada de nuevo texto.
Elimina la línea en donde esta el
cursor.
Pega la línea actual a la siguiente.
de textos con expresiones regulares y otra serie de
facilidades (ver el manual de ex).
Para ejecutar un comando de ex debemos estar en
modo de comando de pantalla. vi reconoce que se
trata de un comando de línea por el primer
carácter, usualmente dos puntos “:” o una
diagonal “/”.
6.4.2Copia y pegado
6.5.1Leer y salvar archivos
Copiar y pegar significa copiar el contenido de
algunas líneas de texto en un buffer para después
insertarlas en otro lugar del archivo o en otro
archivo. vi cuenta con un buffer anónimo y con
buffers con nombre. El buffer anónimo solamente
se usa cuando la operación de pegado se realiza
inmediatamente después de la operación de
copiado.
:w
:w arch
:wq
:q!
:e arch
Uso del buffer anónimo
nY
p
Se copian en el buffer anónimo n
líneas a partir de la posición del
cursor.
Las líneas contenidas en el buffer
anónimo se insertan por debajo de la
línea en donde se encuentra el cursor.
:e!
6.5.2Sustituciones globales
:s/cad1/cad2/
Uso de los buffer con nombre
n”bY
n”bp
Se salva el archivo en el mismo
archivo que se abrió al iniciar su
edición.
El archivo editado se salva el archivo
“arch”.
El archivo se salva y salimos de vi.
Salimos de vi sin salvar el archivo (se
pierden todos los cambios)
Se carga para editar el archivo “arch”.
Si el archivo que se estaba editando
no se ha salvado no se realiza la
operación.
Igual que el comando anterior pero
las modificaciones del archivo que se
estaba editando se pierden.
Sustituye la primera ocurrencia de la cadena
“cad1” por la cadena “cad2” en la línea actual.
Se copian en el buffer b n líneas a
partir de la línea en donde se
encuentra el cursor. b Puede ser
cualquier letra. La información
permanece en el buffer hasta que
salimos de vi o hasta que
introducimos otro contenido en el
mismo buffer.
Las líneas contenidas en el buffer b
se insertan por debajo de la línea en
la que encuentra el cursor.
:s/cad1/cad2/g
Similar al anterior pero sustituye todas las
ocurrencias de la cadena “cad1” por la cadena
“cad2”.
:12,25s/cad1/cad2/g
6.4.3Comandos miscelaneos
Lo mismo que el comando anterior pero la
sustitución se realiza en las líneas 12 a 25 del
archivo.
^G
:1,$s/cad1/cad2/g
Lista en la última línea de la pantalla
el nombre del archivo que estamos
editando y el número de la línea en la
que se encuentra el cursor.
Lo mismo que el comando anterior pero la
sustitución se lleva a cabo en todas las líneas del
archivo.
6.5Comandos de línea de comandos
6.5.3Variables de vi
El editor vi tiene capacidad de ejecutar los
comandos del editor ex. Estos comandos nos
permiten realizar cambios globales, localizaciones
vi maneja una serie de variables internas que le
permiten al usuario controlar su funcionamiento.
6
Por ejemplo el manejo de la auto sangrado,
colocación de tabuladores, embellecimiento del
programa, etc. En particular resulta muy útil que
vi numere las líneas en la pantalla. Esto nos
facilita encontrar los errores que nos reporta el
compilador, ya que éste nos proporciona el
número de la línea en donde ocurrió el error. Para
que vi presente los números de las líneas se
ejecuta el siguiente comando:
$ gcc ordena.c -o ordena
Todas las compilaciones en este curso vamos a
usar esta opción. Al detectar un nombre de
archivo con terminación .c el compilador procede
a compilar ese archivo. El switch -o le indica al
sistema que el módulo ejecutable se llamará
ordena (sin terminación), si la compilación tiene
éxito el ejecutable quedará con este nombre.
:set number
7.2Sólo compilación
Revise el manual de vi para conocer otras
opciones.
Para que el compilador no intente generar un
módulo ejecutable se usa el swuitch -c. De esta
manera podemos realizar una compilación para
generar un módulo objeto. Ejemplo:
7.Uso del compilador de Lenguaje C
En Unix existe un solo comando para compilar y
encadenar programas, se trata del comando gcc.
El comando cc procesa una variedad de tipos de
archivos, los distingue por su terminación. Para el
propósito de nuestro curso nos interesan los
siguientes tipos de archivos:
.c
.o
.a
.cc
$ gcc -c lect.c -o lect.o
Con el comando anterior se compila el módulo
fuente lect.c y se genera el objeto lect.o
7.3Generación de un ejecutable con varios
objetos
Son los módulos fuente escritos en
lenguaje C.
Debemos crear los
módulos C con esta terminación.
Son los módulos objeto resultantes de
la compilación de un módulo fuente.
Un módulo objeto no puede ser
ejecutado, este debe combinarse con
otros módulos objetos y módulos de
librería para generar un módulo
ejecutable.
Es la terminación que se da a las
librerías. Las librerías nos sirven
para almacenar módulos objetos de
uso común.
Programas fuente escritos en C++.
Para ligar varios objetos se usa un comando como
sigue:
$ gcc ordena.o lectura.o -o ordena
Con el comando anterior los módulos objeto
ordena.o y lectura.o se combinan con módulos
de las librerías estándar para crear el ejecutable
ordena.
8.Depuración de un programa
El depurador gdb se utiliza para detectar errores
de ejecución. Nos permite ejecutar un programa
instrucción por instrucción y revisar el valor de las
variables.
En Unix los módulos ejecutables no tienen que
tener una terminación particular. Para los fines de
nuestro curso los módulos ejecutables no tendrán
ninguna terminación.
Para depurar un programa con gdb el programa se
debe compilar con la opción -g como se muestra a
continuación:
7.1Compilación simple
Se tiene un solo módulo fuente y se desea generar
un módulo ejecutable. Si nuestro programa fuente
se llama ordena.c para compilarlo y obtener el
ejecutable deberemos proporcionar el siguiente
comando:
$ gcc -g ordena.c -o ordena
Una vez compilado se inicia la ejecución
mediante gdb de la siguiente forma:
$ gdb ordena
7
ejecuta.
Una vez iniciado gdb podemos listar las
instrucciones del programa con el comando l.
(gdb) n
(gdb) l
8.5Ejecución paso a paso (entrando a las
funciones)
Sólo se teclea la letra ele.
El comando s es similar a n, sin embargo, cuando
en la línea que se ejecuta se invoca una función
gdb nos muestra la primera instrucción de la
función invocada.
8.1Establecer puntos de interrupción
Antes de iniciar la ejecución del programa
debemos establecer uno o varios puntos de
interrupción (break point) con el comando b.
(gdb) s
(gdb) b 17
8.6Detección de puntos de falla
Con el comando anterior gdb establece un punto
de interrupción en la línea 17. Es posible
establecer tantos puntos de interrupción como se
desee. Cuando la ejecución del programa llegue a
un punto de interrupción gdb detiene la ejecución
antes de ejecutar la instrucción de esa línea y nos
permite revisar los valores de las variables.
Cuando un programa compilado con la opción –g
aborta por algún error (división entre cero, falla de
segmento, etc.) y genera un vaciado de memoria
(core dump) se invoca el depurador con un
comando similar a:
$ gdb ordena core
8.2Inicio de la ejecución
Como se puede observar, el primer argumento es
el archivo ejecutable y el segundo argumento es el
archivo que contiene el vaciado de memoria. El
depurador nos mostrará la línea que produjo el
problema y podemos analizar la pila del sistema
para conocer la ruta por donde se llegó al
problema. por ejemplo:
Para iniciar la ejecución del programa se utiliza el
comando r.
(gdb) r
Con esto se inicia la ejecución del programa hasta
llegar a un punto de interrupción o terminar la
ejecución del programa.
(gdb) bt
Para conocer el valor de las variables se utiliza el
comando p.
Nos muestra todos los llamados a funciones que
nos llevaron al punto de falla del programa. Por
cada nivel de llamado en la fila se encuentra un
contexto de ejecución (frame) que nos dice el
nombre de la función y los valores de los
argumentos. Con el comando:
(gbd) p k
(gdb) f n
Con el comando anterior se lista el valor de la
variable k.
Podemos situarnos en el contexto número n para
poder listar los valores de las variables locales y
cualquier otra información disponible desde ese
contexto de ejecución.
8.3Revisar el contenido de las variables
8.4Ejecución paso a paso (sin entrar a las
funciones)
Los comandos bt y f se pueden invocar en
cualquier otro momento.
Para ejecutar una instrucción a la vez se utiliza el
comando n. Con este comando no se entra a las
funciones que son invocadas desde la línea que se
8.7Manual de referencia de gdb
8
El manual de referencia de gdb se encuentra en la
dirección:
$ imprime ordena.c
http://w4.lns.cornell.edu/public/COMP/info/gdb/gdb_toc.html
9.4Preparación para impresión
También se puede buscar en internet usando las
palabras GNU y gdb.
En el momento de imprimir los programas fuente
es conveniente darles un formato adecuado. Para
esto se utiliza el comando pr. El comando pr lee
los archivos que se le indican y genera un listado
con las características que se especifican mediante
los parámetros de ejecución.
9.Ejecución del programa
Para ejecutar un programa se emplea como
comando el nombre del archivo ejecutable
generado con el compilador. Por ejemplo:
Ejemplo 1:
$ ordena
9.1Lectura de datos de un archivo
$ pr -n ordena.c >listado
$ imprime listado
Si se desea leer los datos de un archivo que se
encuentra en el disco podemos usar el
redireccionamiento de la entrada estándar como
sigue:
En el ejemplo el archivo ordena.c se formatea
agregando números de línea y se almacena en el
archivo listado. El segundo comando envía el
archivo listado a la impresora.
$ ordena <numeros.dat
Ejemplo 2:
En este ejemplo los datos del programa ordena se
van a leer del archivo numeros.dat. Este archivo
se puede preparar con editor vi, igual en la misma
forma en que se prepara un programa fuente.
$ pr -n *.h *.c >listado
$ imprime listado
En este ejemplo todos los archivos con
terminación .h y con terminación .c se numeran y
se graban en el archivo listado. El segundo
comando envía el archivo listado a la impresora.
9.2Escritura de resultados en un archivo
Si se desea que los resultados se escriban en un
archivo del disco se usa el redireccionamiento de
la salida estándar:
10.Utilería make
El programa make de unix se utiliza para compilar
programas que se encuentran divididos en varios
módulos fuente.
Además de facilitar la
compilación, minimiza el tiempo requerido para
este proceso, ya que solamente recompila los
módulos que han tenido alguna modificación.
$ ordena >listado
Los resultados se almacenarán en el archivo
listado. Este archivo se puede ver con el editor vi
o se puede enviar a la impresora.
Nota. Los dos redireccionamientos se pueden
usar simultáneamente como se muestra a
continuación:
$ ordena <datos.dat
Para utilizar el comando make es necesario crear
un archivo de instrucciones (script) con el que se
guía a make respecto a como se lleva a cabo la
compilación. El archivo de instrucciones se crea
con cualquier editor de textos como el vi.
>listado
9.3Impresión de programas y resultados
Supongamos que tenemos un programa que consta
de varios módulos como se muestra a
continuación:
Para imprimir un archivo de texto en la impresora
del sistema se emplea el comando imprime en la
siguiente forma:
calcula.cpp
9
el archivo se llama de otra manera como
proyecto.mak, entonces es necesario realizar la
siguiente invocación.
#include “avl.h”
#include “calcula.h”
. . .
main()
{
. . .
}
$ make –f proyecto.mak
En el ejemplo anterior existen dos clases de líneas
que llamaremos reglas y comandos. Las reglas
contiene el nombre de un archivo objetivo seguido
de dos puntos y seguido de la lista de los archivos
de los que depende. Así en la primera línea se
especifica que el archivo calcula depende de los
archivos calcula.o y avl.o. La segunda línea
contiene el comando que genera el archivo
calcula o sea una invocación a g++ para que se
realice la liga de los dos módulos objetos. Los
comandos para generar los archivos empiezan con
un tabulador.
avl.cpp
#include “avl.h”
double *Avl::Avl {
. . .
};
Como puede apreciarse, el programa calcula se
encuentra dividido en dos módulos. El primero
contiene el programa principal e invoca a las
fucniones de la clase Avl que se encuentran
definidas en el módulo avl.cpp. Para realizar esta
compilación es necesario hacer dos compilaciones
y una edición de encadenamiento (link). Además
se deben aplicar las siguientes reglas:
En general un archivo make está formado por
instrucciones de generación. Una instrucción de
generación tiene una regla de dependencia seguida
por uno o varios comandos Unix. Las reglas
empiezan en la columna 1 y los comandos se
inician con un tabulador. En un archivo make es
posible invocar cualquier comando válido Unix
aunque por lo gneral solamente utilicemos
llamadas al compilador.
1).- Cada que cambie alguno de los archivos
calcula.cpp, calcula.h o avl.h es
recompilar calcula.cpp para generar
calcula.o.
2).- Cada que cambie el archivo avl.cpp o
avl.h es necesario recompilar avl.cpp
para generar el archivo avl.o.
Uso de macros
En un archivo make podemos definir macros de la
siguiente manera:
3).- Cada que cambie el archivo avl.o o
calcula.o es necesario ejecuatar el link
para generar el archivo ejecutable
calcula.
OBJS = avl.o calcula.o
Posteriormente podemos hacer referencia al valor
de la macro en cualquier parte del archivo como
se muestra a continuación:
Esto se logra con una archivo makefile con el
siguiente contenido:
g++ $(OBJS)
calcula: calcula.o avl.o
g++ calcula.o avl.o –o calcula
calcula.o: calcula.cpp calcula.h avl.h
g++ calcula.cpp –o calcula.o
avl.o: avl.cpp avl.h
g++ avl.cpp –o avl.o
11.Utilería tar
El programa tar tiene la capacidad de agrupar un
conjunto de directorios y archivos en un paquete
(tarfile).
El mismo programa se usa para
desempacar la información y reconstruir la
estructura de directorios y archivos originales.
Para compilar el programa unicamente se debe
invocar al comando make como se muestra a
continuación:
$ make
En este curso, los archivos de cada tarea deberán
estar contenidos en un directorio con el nombre
tarea1, tarea2, Etc. El directorio deberá contener
exclusivamente los archivos necesarios para
compilar y ejecutar los programas necesarios.
Si no se proporcionan argumentos al comando
make, este comando busca el archivo llamdo
Makefile o makefile para hacer la compilación. Si
10
Este directorio podrá tener subdirectorios.
Para empacar la tarea que se encuentra en el
directorio tarea5 se utilizará el siguiente comando:
12.Compresión de archivos
Los programas compress y uncompress se utilizan
para comprimir y restaurar archivos.
La
compresión puede ahorrar una cantidad
importante de espacio de almacenamiento.
$ tar cf tarea5.tar tarea5
En este caso cf son las opciones. La c indica que
se va a crear un nuevo paquete y la f significa que
el paquete va a se un archivo (por omisión sería
una cinta magnética). tarea5.tar es el archivo que
va a contener el paquete y tarea5 es el nombre del
directorio que corresponde a la tarea número
cinco.
Supongamos que deseamos comprimir un paquete
que contiene todos los archivos de la tarea cinco y
que se encuentran en el archivo tarea5.tar. Para
esto se usa el siguiente comando:
$ compress tarea5.tar
Es posible revisar el contenido de un paquete. En
este caso se emplea el comando:
El comando compress sustituye el archivo original
por el archivo comprimido tarea5.tar.Z.
$ tar tf tarea5.tar
Si nuevamente desseamos descomprimir el
archivo tarea5.tar.Z podemos usar el siguiente
comando:
Para reconstruir la estructura de directorios
almacenados en un paquete nos colocamos en el
directorio a partir del cual deseamos reconstruir la
estructura de directorios y usamos un comando
como el siguiente:
$ uncompress tarea5.tar.Z
En este caso el archivo comprimido se sustituye
por el archivo original.
$ tar xf tarea5.tar
11
Índice
login...................................................................... 2
ls 3
make....................................................................10
man....................................................................... 2
mkdir.................................................................. 3
Modificación de texto........................................... 6
modo de comando............................................... 5
modo de entrada..................................................5
Modos de operación de vi..................................... 5
Movimientos del cursor........................................ 5
mv......................................................................... 3
Pasar a modo de entrada de texto..........................5
password............................................................... 2
Preparación para impresión.................................. 9
Revisar el contenido de las variables.................... 8
rm......................................................................... 3
rmdir.................................................................... 3
Salir del sistema.................................................... 2
Sistema de archivos.............................................. 2
Sólo compilación.................................................. 7
Sustituciones globales...........................................6
tar........................................................................ 11
trayectoria............................................................. 3
Uso del editor vi....................................................4
cd..........................................................................3
clave del usuario................................................... 2
Codificar el programa........................................... 4
Comandos de línea de comandos..........................6
Comandos de pantalla........................................... 5
Compilación simple.............................................. 7
Compresión de archivos......................................11
Copia y pegado..................................................... 6
Corrimientos de la pantalla................................... 5
Depuración de un programa..................................8
Desarrollar el algoritmo........................................ 4
Desarrollo de programas.......................................4
Detección de puntos de falla................................. 8
directorios............................................................. 2
Editar.....................................................................4
Ejecución paso a paso........................................... 8
Ejecución paso a paso (entrando a las funciones).8
Entrada al sistema................................................. 2
Escritura de resultados en un archivo................... 9
Establecer puntos de interrupción.........................8
Generación de un ejecutable con varios objetos... 8
Impresión de programas y resultados................... 9
Inicio de la ejecución............................................ 8
Leer y salvar archivos........................................... 6
12
13