Se trata de un tip bastante sencillo que permite que cuando hagamos clic en enlaces tipo mailto:juanito@putico.com se abra una pestaña en el Firefox con los campos necesarios para enviar un correo vía GMail.

Lo primero es descargar este script, guardarlo en tu home y darle permisos de ejecución:

Ahora debemos ejecutar Aplicaciones Preferidas:

Estando allí, vas a la sección Lector de correo y seleccionas Personalizar; luego, en la caja de texto Campo colocas: “/home/usuario/gmail.sh %s” (sin comillas ) reemplazando “usuario” por el nombre de tu usuario:

El contenido del script, por si te interesa es el siguiente:

#!/bin/sh
firefox -remote "openurl(https://mail.google.com/mail?view=cm&tf=0&to=`echo $1 | sed 's/mailto://'`,new-tab)"

Lo que hace es abrir una nueva pestaña del Firefox en la URL que utiliza Gmail para enviar correos, y usando el comando sed acomoda la variable to de la petición GET de acuerdo a la dirección de correo del destinatario.

este script

Nota: este es un artículo que escribí hace mucho tiempo, y que decidí rescatar y actualizar un poco. Si se dan cuenta habla sobre RCS y CVS en vez de SVN y GIT, pero bueno, a alguien le servirá. Pueden descargar la versión PDF con todos los artículos incluidos.

Este artículo pretende orientar un poco acerca de lo que es la programación en C++ sobre linux. Esto NO es un tutorial de referencia de C++, si lo que buscas es eso puedes buscar en el google que hay bastantes. Posiblemente ya hayas programado en C++ sobre Windows, y has utilizado algún compilador como el C++ Builder de Borland, el Visual Studio de Microsoft o en el mejor de los casos DevC++.

Ok, esto es un buen comienzo. Pero lo que aquí vamos a ver es: qué nos proporciona Linux para programar en C++. Como sabes en Linux las cosas ya no son tan fáciles, pero tampoco difíciles; de hecho C++ es famoso gracias a Linux, son como uña y mugre. La cuestión es que nos centraremos en la programación desde la consola. Si lo tuyo no es la consola puedes echarle un vistazo a la sección que trata sobre Anjuta, que es un IDE para C++ en Linux, pero te recomiendo que leas todo el artículo, te aseguro que te servirá.

Vamos a tratar los siguientes temas (y talvez algunos más):

• Editores
• Compiladores
• Bibliotecas y enlace
• Creación de archivos ejecutables con make
• Depuración con gdb
• Control de versiones con RCS y CVS
• Creación de documentación para el comando man
• Anjuta, un IDE para Linux

Esta es realmente la base de la programación en C++: cruda, sin vestimentos, tal como es.

Descargar el tutorial completo en PDF

Este es un libro bastante bueno acerca de la Programación en Linux, teniendo en cuenta que Linux es el kernel (que no el sistema) de la mayoría de sistemas operativos GNU.

En el libro se expone el API y se explica el funcionamiento del kernel Linux. Acerca al desarrollador al mundo de la programación bajo Linux, explica detalladamente cómo funcionan los procesos internamente, habla acerca de las señales, sistema de archivos, manejo de entradas y salidas, gestión de memoria, terminales POSIX, comunicación mediante pipes (tuberías), administración, etc.

La verdad está bastante completo, y es de lectura impresindible para desarrolladores y para los curiosos que desean aprender como funciona internamente su sistema.

Descargar version en PDF

Ya hace un tiempo que escribí un manual de programación de C++ sobre Linux; esta vez Pablo Garaizar ha hecho un tutorial de referencia aún más completo acerca de este tema tan importante e interesante. En él se explican varios aspectos que circundan la programación en C sobre Linux, como el uso del gcc, make, librerías, debugging, etc.

Para descargar el archivo en PDF o en ODT, ve directamente a la página del autor.

Diagramas y SeudoEsquemas para implementar los Microcontroladores PIC16X84 en circuitos reales o protoboards + Programas en ASM y C

¡¡¡Put0 título tan largo que me he inventado xD!!! Nada, decir que obviamente los programas no los he inventado yo, sino que son la recopilación de los “ejemplos práticos” más usados. Los he sacado de unos cuantos libros cuyo nombre no me sé (en realidad son unas fotocopias que encontré por casualidad). Y aclarar que los dibujos los hice yo en Visio, y que talvez tengan uno que otro fallo, la verdad es que me costó un huevo hacer esos put0s dibujos; en fín, si encontrais algún fallo me lo comunicas por privado. Sino conoceis como es este rollo de los Microcontroladores PIC, podeis hecharle un vistazo a este post: Introducción a microcontroladores PIC [simulando nuestro programas en ASM y C] (no te demoras sino 20 o 30 minutillos leyéndolo).

SeudoEsquema de Montaje

Descripción: Lee el número binario introducido mediante 3 interruptores conectados a la puerta A, luego suma 2 unidades a ese valor y visualiza el resultado mediante 4 diodos led conectados a la puerta B.

Programa en Assembler:

;—————————————————————————-
LIST P=16C84 ;Comando que indica el PIC usado
RADIX HEX ;Los valores se representar n en hexadecimal
;—————————————————————————-
PUERTAA EQU 0X05 ;La etiqueta “PUERTAA” queda identificada con
;la dirección 0×05, que si corresponde con el
;banco 0 es el valor de PUERTAA y si es del
;banco 1 con el de TRISA.
PUERTAB EQU 0X06 ;Equivalencia de la etiqueta PUERTAB
ESTADO EQU 0X03 ;Estado corresponde con el valor 0×03.
W EQU 0 ;Identifica W con el valor 0.
;—————————————————————————-
ORG 0 ;Comando que indica al Ensamblador la
;dirección de la memeoria donde se
;situar la instrución siguiente
;—————————————————————————-
bsf ESTADO,5 ;Pone a 1 el bit 5 de ESTADO para direccionar
;la p gina 1 de la memoria de datos.
movlw 0xff ;W <– FF(Hex) movwf PUERTAA ;W –> TRISA
movlw 0×00 ;W <– 0 movwf PUERTAB ;W –> TRISB (Las líneas de PB salidas)
bcf ESTADO,5 ;Pone a 0 el bit 5 de ESTADO pasando a
;acceder al banco 0. inicio movf PUERTAA,W ;W <– PUERTAA. Se introduce el valor binario ;de los interruptores. addlw 2 ;W <– W + 2 movwf PUERTAB ;W –> PUERTAB. El valor de W sale por las
;líneas de PB a los led.
goto inicio ;Salta a la instrucción precedida por la
;etiqueta de inicio.
END

Programa en C:

#INCLUDE <16c84.h>
void main(void)
{
int valor; /* Valor temporal */
int * p_puertaa= 0×05; /* Puntero a PuertaA */
int * p_puertab= 0×06; /* Puntero a PuertaB */ SET_TRIS_A (0xff); /* 0xff –> TRISA */
SET_TRIS_B (0×00); /* 0×00 –> TRISB */
do
{
valor = * p_puertaa;/* PuertaA –> valor */
valor += 2; /* se incrementa valor en 2 */
*p_puertab = valor; /* valor –> puertaB */
}while(true); /* Bucle infinito */
}

Esquema de Montaje

Descripción: Muestra por cinco diodos led en la puerta B la entrada que proporcionan cinco interruptores en la puerta A.

Programa en Assembler:

LIST p=16c84 ; Se usa el PIC16C84
RADIX hex ; Se emplea el sistema de numeración hexadecimal; ZONA DE ETIQUETAS———————————————————————–
W EQU 0 ; Cuando el destino es W, d = 0
F EQU 1 ; Cuando el destino es el registro f, d = 1
PUERTAA EQU 0×05 ; La Puerta A (datos) ocupa la dirección 5 del
; banco 0 y el registro de configuración la
; dirección 5 del banco 1
PUERTAB EQU 0×06 ; La misma etiqueta para el registro de datos y el
; de configuración de la Puerta B
ESTADO EQU 0×03 ; El registro Estado ocupa dirección 3 de los dos bancos

; COMIENZO DEL PROGRAMA —————————————————————–

ORG 0 ; El programa comienza en la dirección 0 (Vector Reset)
goto inicio ; Se salta a la etiqueta “inicio”
ORG 5 ; Se asigna la dirección 5 a la siguiente instrucción

inicio bsf ESTADO,5 ; Pone a 1 el bit 5 de Estado. Acceso al banco 1.
clrf PUERTAB ; Se configuran como salidas las líneas de la Puerta B
movlw 0xff ; El registro W se carga con unos
movwf PUERTAA ; Se configuran como entradas las líneas de la Puerta A
bcf ESTADO,5 ; Pone a 0 el bit 5 de Estado. Acceso al banco 0.
bucle movf PUERTAA,W; Carga el registro de datos de Puerta A en W
comf PUERTAA,W ; Complementa a 1 la entrada y la deposita en W
movwf PUERTAB ; El contenido de W se deposita en el registro de datos de
; la Puerta B
goto bucle ; Se crea un bucle cerrado e infinito

END ; Fin del programa

Programa en C:

#include <16c84.h>
#byte puertaa = 05 /* Posición de la puerta A */
#byte puertab = 06 /* Posición de la puerta B */
void main( void )
{
int temp;
set_tris_a( 0xFF ); /* Puerta A configurada para entrada */
set_tris_b( 0×00 ); /* Puerta B configurada para salida */
do
{
/* La variable temporal es necesaria porque */
temp = ~puertaa; /* la complementación se traduce en dos pasos: */
puertab = temp; /* a) Copia de puertaa en temp */
}
/* b) Complementación de temp */
/* De no hacerlo así los LED parpadearían */
while( TRUE );/* Repetir ininterrumpidamente */
}

Esquema de Montaje

Descripción: Hace un conteo desde 0 hasta 0x5f y muestra en las patitas RB.

Programa en Assembler:

;—————————————————————————-
LIST P=16C84
RADIX HEX
;—————————————————————————- W EQU 0×00 ; Comienzo del campo de etiquetas.
F EQU 0×01
PUERTAB EQU 0×06
ESTADO EQU 0×03
CONTA EQU 0x0C

;—————————————————————————-

ORG 0 ; El programa comienza en la dirección 0 y
goto inicio ; salta a la dirección 5 para sobrepasar
ORG 5 ; el vector de interrupción.

;—————————————————————————-

inicio bsf ESTADO,5 ; Seleciona el banco 1
movlw 0×00 ; Se configura PuertaB como salida
movwf PUERTAB
bcf ESTADO,5 ; Selección del banco 0

;—————————————————————————-

clrf CONTA ; CONTA = 0
bucle1 incf CONTA,F ; CONTA + 1 –> CONTA
movf CONTA,W ; CONTA se carga en W
movwf PUERTAB ; W se carga en el registro de datos PB
movlw 0x5f ; W <– 0x5f subwf CONTA,W ; CONTA – W –> W
btfss ESTADO,2 ; Explora Z y si vale 1 se produce “brinco”
goto bucle1 ; Si Z = 0 se vuelve a bucle1

bucle2 goto bucle2 ; si Z = 1 se produce un bucle infinito
end

Programa en C:

#include <16c84.h> /* Tipo de PIC a usar */
#byte puertab=0×06
#byte conta=0x0C
void main(void)
{
set_tris_b(0×00); /* Configura la PB como salida */
for (conta=0;conta<=0x5f;++conta) /* Bucle que incrementa CONTA de 0 */ puertab=conta; /* a 0x5f */ }

SeudoEsquema de Montaje

Descripción: Programa que ilustra cómo realizar una temporización sin emplear interrupciones.

Programa en Assembler:

LIST P=16C84
RADIX HEX
; ———————————————————————— PUERTAA EQU 0×06
OPTION EQU 0×01
ESTADO EQU 0×03
TMR EQU 0×01

; ————————————————————————

ORG 0 ; Inicio del programa en
; dirección 0

; ————————————————————————

bsf ESTADO,5 ; Banco 1
movlw b 1101 0110 ; Valor a cargar en
; OPTION
movwf OPTION
movlw 0×00
movwf PUERTAB ; La Puerta B salida
bcf ESTADO,5 ; Banco 0
clrf PUERTAB ; Las líneas de salida
; de PB a 0

parpa bsf PUERTAB,7 ; Enciende el led RB7 = 1
call retardo ; Llamada a subrutina de
; RETARDO
bcf PUERTAB,7 ; Apaga el led, RB7 = 0
call retardo
goto parpa

retardo clrf TMR0 ; TMR0 = 0 y empieza su
; incremento

explora btfss TMR0,4; TMR0<4> = 1?
goto explora ; No ha llegado TMR0 a 16d
return ; Ha llegado TMR0 al
; valor 16d y retorna
; al programa principal

END

Programa en C:

#include <16c84.h>
#use delay( clock = 1000000 ) /* Especifica reloj de 1 MHz */
#byte puertab = 06 /* Dirección de la puerta B */
void main( void )
{
set_tris_b( 0×00 );
puertab = 0;
do
{
delay_us( 8700 ); /* Crea un bucle de espera de 8700 microsegundos */
bit_set(puertab,7); /* Enciende el LED */
delay_us(8700); /* Espera */
bit_clear(puertab,7);/* Apaga el LED */
}while(true); /* Repetir siempre */
}

SeudoEsquema de Montaje

Descripción: Refleja el estado de dos interruptores situados en RA0 y RA1 en RB0 y RB1 mientras hace parpadear un diodo en la línea RB7.

Programa en Assembler:

;—————————————————————————- LIST P=16C84
RADIX HEX

;—————————————————————————-

W EQU 0
F EQU 1
TMR_OPT EQU 0×01 ; TMRO en banco 0 OPTION en banco 1
ESTADO EQU 0×03
PUERTAA EQU 0×05 ; PA en banco 0 TRISA en banco1
PUERTAB EQU 0×06 ; PB en banco 0 TRISB en banco1
INTCON EQU 0x0B ;
CONTA EQU 0×10 ; Contador auxiliar

;—————————————————————————-

ORG 0 ; Vector de Reset
goto inicio

ORG 4 ; Vector de Interrupción
goto inter ; Salta a comienzo de rutina de interrupción
ORG 5

inicio bsf ESTADO,5 ; Selección del banco 1
clrf PUERTAB ; Configura PUERTA B como salida

movlw b’00000011′ ; Configura RA0, RA1 como entradas
movwf PUERTAA

movlw b’00000111′
movwf TMR_OPT

bcf ESTADO,5 ; Banco 0

movlw b’10100000′ ; Se permite interrupción del
movwf INTCON ; TMR0 y la globla (GIE)

movlw 0×10
movwf CONTA ; Se carga CONTA con 16 decimal

movlw 0x0c
movwf TMR_OPT ; Se carga TMR0 con 12 decimal

bucle btfsc PUERTAA,0 ; Explora RA0 y brinco si vale 0
goto ra0_1 ; salta a RA0_1
bcf PUERTAB,0 ; Si RA0 = 0 sa saca por RB0 un 0
goto ra1x ; A explorar RA1

ra0_1 bsf PUERTAB,0 ; Si RA0 = 1 se saca por RB0 un 1

ra1x btfsc PUERTAA,1 ; Examina ra1 y brinco si es 0
goto ra1_1 ; Salta si RA1 = 1
bcf PUERTAB,1 ; Si RA1 = 0, RB1 = 0

goto bucle2
ra1_1 bsf PUERTAB,1 ; Si RA1 = 1 , RB1 = 1
bucle2 goto bucle ; Bucle indefinido, se sale por la interupción

;—————————————————————————-

inter decfsz CONTA,1 ; RSI. Decrementa CONTA y brinco si vale 0
goto seguir

conta_0 movlw 0×10 ; Si CONTA = 0 se carga
movwf CONTA

btfsc PUERTAB,7 ; Si RB7 = 0, brinco
goto rb7_1
bsf PUERTAB,7 ; Si RB7 = 0, se invierte
goto seguir

rb7_1 bcf PUERTAB,7 ; Si RB7 = 1 , se invierte

seguir movlw b’10100000′ ; Se restaura INTCON por desactivar las
movwf INTCON ; interrupciones el procesador
movlw 0x0c
movwf TMR_OPT ; Se recarga TMR0 con 12
retfie

end

Programa en C:

#include <16c84.h> /* Selección del PIC a usar */
#use delay(clock= 4000000) /* Reloj de 4 MHz */
#BYTE puertab = 6
#define maximo 16 /* Constante: maximo = 16 */
byte conta;
/*————————————————————————–*/
/* SERVICIO DE LA INTERRUPCIóN */
#INT_RTCC /* Interrupción por desvordamiento del timer*/
clock_isr()
{
short valor;
short novalor;
valor = bit_test(puertab,7); /* El bit valor es igual al contenido */
/* de RB7 */ novalor = !valor;
if (–conta==0)
{
output_bit (PIN_B7,novalor); /* Voltea RB7 */
delay_us (5);
conta = maximo;
}
}

/* PROGRAMA PRINCIPAL */
main()
{
short ra0,ra1;

set_tris_b(0×00); /* Se inicializa PB */
conta=maximo;
set_rtcc(0); /* Se inicializa el timer a cero */

setup_counters(rtcc_internal,rtcc_div_256);

enable_interrupts(rtcc_zero); /* Se permite int del tmr0 */

enable_interrupts(GLOBAL); /* Se activa GIE */

/* Rutina de control de los leds e interruptores: */
do
{
ra0 = input(PIN_A0);
ra1 = input(PIN_A1);

output_bit (PIN_B0,ra0);
output_bit (PIN_B1,ra1);
}
while(true); /* Bucle infinito */
}

SeudoEsquema de Montaje

Descripción: Programa que visualiza un número del 1 al 7 en un display de siete segmentos en la puerta B dependiendo del valor binario de tres interruptores situados en la puerta A.

Programa en Assembler:

LIST P=16C84
RADIX HEX w EQU 0
f EQU 1
PCL EQU 02
PUERTAA EQU 05
PUERTAB EQU 06
ESTADO EQU 03
VALOR EQU 12 ; Registro auxiliar

; RUTINA PRINCIPAL: Lectura de los interruptores y c lculo del valor a visualizar

ORG 0
goto inicio
ORG 5 ; Para saltar el Vector de
; Interrupción

inicio bsf ESTADO,5 ; Selección del banco 1
clrw
movwf PUERTAB ; Puerta B salida
movlw 0xff
movwf PUERTAA ; puerta A entrada
bcf ESTADO,5 ; Selección banco 0
explora movf PUERTAA,w ; Se cargan los
; interruptores en W
movwf VALOR ; Se usa un registro auxiliar
comf VALOR,f ; Invertir los niveles de interuptores
clrw
btfss VALOR,0 ; Si RA0 = 1, brinca
goto bit_1 ; Salta a explorar el bit_1
addlw 0×01 ; Si RA0 =1, se suma
bit_1 btfss VALOR,1; Si RA1 = 1, brinca
goto bit_2 ; Salta a explorar el bit_2
addlw 0×02 ; Si RA1 = 1, se suman 2
bit_2 btfss VALOR,2; Si RA2 = 1, brinca
goto visual ; Salta al módulo del display
addlw 0×04 ; Si RA2 0 1, se suman 4
visual call display ; Salta al módulo del display

; DISPLAY: Rutina de visualización del acumulador en el display de 7 segmentos

movwf PUERTAB ; Al retornar de la subrutina
; el valor de W se saca por la
; Puerta B
bucle goto bucle ; bucle infinito

; TABLA DE CONVERSION———————————————————

display addwf PCL,f ; pcl + W -> W
; El pcl se incrementa con el
; valor de W proporcionando un
; salto
retlw 0x3F ; Retorna con el valor del
; código del 0
retlw 0×06 ; Retorna con el código del 1
retlw 0x5b ; Retorna con el código del 2
retlw 0x4f ; Retorna con el código del 3
retlw 0×66 ; Retorna con el código del 4
retlw 0x6d ; Retorna con el código del 5
retlw 0x7d ; Retorna con el código del 6
retlw 0×07 ; Retorna con el código del 7

END

Programa en C:

#include <16c84.h>
#byte puertaa = 05 /* Posición de la puerta A */
#byte puertab = 06 /* Posición de la puerta B */
void main( void )
{
int temp = 0, tabla[8]={ 0x3F, 0×06, 0x5B, 0x4F, 0×66, 0x6D, 0x7D, 0×07 };
int indice = 0;
set_tris_a( 0xFF ); /* Puerta A configurada para entrada */
set_tris_b( 0×00 ); /* Puerta B configurada para salida */
temp = ~puertaa; /* Se complementa la entrada de PA */
if ( bit_test( temp, 0 ) ) indice += 1;
if ( bit_test( temp, 1 ) ) indice += 2;
if ( bit_test( temp, 2 ) ) indice += 4;
puertab = tabla[indice];
}

• Control de un dispositivo desde dos puntos: Se desea controlar una lámpara, en este caso un diodo LED desde dos interruptores, de forma que cuando los dos interruptores están abiertos el LED está apagado. A partir de esta situación, cada vez que cambie el estado de un interruptor, el estado del LED bascula (si está apagado se enciende y viceversa)
• Semáforo programabe: Se simula un semáforo con 3 diodos LED. Se dispone de 2 interruptores que según la combinación que adopten originan una secuencia de encendido de las luces del semáforo.
• Dado electrónico: Este programa simula el juego del dado. Un dado típico tiene 6 caras, en cada una de las cuales viene dibujado un número del 1 al 6. Cada vez que se presiona un pulsador se produce un número aleatorio entre 1 y 6, el cual se visualiza en un display de 7 segmentos.
• Temporizador programable: Con 3 microrruptores se selecciona un valor entre el 0 y el 7 (binario), que representa un tiempo en segundos y que ser visualizado por el display de 7 segmentos. Durante el tiempo que dura la temporización un LED rojo permanece activado, así como un zumbador. Al finalizar se desactivan ambos elementos y el display se pone a 0.
• Alarma: Se tienen 3 detectores digitales, cada uno de los cuales provocar la activación de un LED, diferente en cada caso. Uno de los detectores ser un optoacoplador y los otros 2 se simularán mediante 2 microrruptores. El programa consiste en poner en marcha un zumbador cuando la alarma salte por causa de la activación de cualquiera de los detectores. También se enciende el LED correspondiente al detector. La alarma sólo funcionará cuando el microrruptor I1 de conexión esté a nivel alto.
• Ejemplo tomado de Internet: (Autor: David Tait, david.tait@man.ac.uk) Este programa ilumina una serie de leds en secuencia principio-fin-principio (algo así como las luces del “El Coche Fantástico).
• Manejo del WatchDog (perro guardián): El objetivo de este programa es mostrar en la práctica el funcionamiento del Watchdog en el PIC 16c84. El programa entra en un bucle infinito del que sale tras cumplirse la temporización asiganada al watchdog, que en este caso ser n 36 ms, es decir 2 veces la temporización nominal.

Me pillo en un post de cheatmaster un muy buen videotutorial de C++ hecho en Flash, muy recomendado si estás empenzando en C/C++… lo puedes ver aquí:
http://lnx.googlewrite.com/cpp/wimpy.swf

Algunos tutoriales de Programación de Pics…

• Introducción a microcontroladores PIC [simulando nuestro programas en ASM y C]
• Programación de Microcontroladores PIC16X84 [Diagramas de montaje + Programas]
• Grabando nuestros programas en ASM y C en los PIC’s

Espero les sirva!!!

Como ya debes saber, lo primero que necesitamos para programar es un editor de texto. Uno de los primeros resultados del proyecto GNU fue el editor emacs, y los editores estuvieron entre los primeros programas que se portaron a Linux.

Pero vamos a centrar nuestra atención en el editor vim, el cual es básicamente una interfaz basada en pantallas escrita con base en ex (otro editor muy antiguo).

En la mayoría de los distros de Linux encontrarás el editor vim. Aunque muchas personas piensan que vim es enigmático y difícil de utilizar, por lo general es porque nos acostumbramos al bloc de notas de Windows, emacs (en modo gráfico) y/o a los IDE’s (a lo fácil); sin embargo, vim tiene muchas ventajas con respecto a otros editores:

• Está disponible en prácticamente en todos los sistemas UNIX y Linux.
• Necesita menos recursos de sistema que emacs, y por consecuencia se ejecuta aunque el sistema no esté funcionando completamente.
• No es tan personalizable como el emacs, por lo que sus implementaciones se comportan casi de la misma manera.

Puedes utilizar cualquier otro editor de texto, aunque te recomiendo que domines los fundamentos del vim. Para comenzar puedes leerte este pequeño (muy pequeño) artículo acerca del vim.

ctags y etags

Al codificar un programa grande en C++, talvez sea necesario dividir las clases y métodos en archivos fuente separados. Pero después, al depurar el programa, puede resultar tediosa la tarea de navegar entre archivos. Por ejemplo, talvez esté editando el archivo A y en él haya una invocación a un método que se encuentre en otro fichero, talvez el B. Los programas ctags y etags generan archivos índice o “tag”, que vi y emacs pueden utilizar para ayudarlo a navegar por sus archivos fuente.

ctags genera marcas para vim, pero se puede configurar para que lo haga para emacs. etags genera marcas para emacs, pero se puede configurar para que lo haga para vim.

Vamos a ver un ejemplo del ctag con vim. Para ello escribimos el siguiente código en un archivo llamado HolaPrincipal.cpp:

//HolaPrincipal.cpp
#include<iostream>
using namespace std;
void Saludar(int i);
int main(int argc, char * argv[])
{
for(int i=0; i<5; i++)
{
Saludar(i);
cout<<endl;
}
}

y lo siguiente en Saludar.cpp:

//Saludar.cpp
#include<iostream>
using namespace std;
void Saludar(int i)
{
cout<<"["<<i<<"] elhackerr00lz";
}

Ahora vamos al directorio donde tenemos los dos archivos y escribimos el comando:

ctags *.cpp

Hemos creado el nuevo archivo tags. Ahora vamos a probarlo, para ello abrimos el archivo HolaPrincipal.cpp (vim HolaPrincipal.cpp); y usando las flechitas de dirección colocamos el cursor sobre la palabra Saludar. Oprime Ctrl+], y verás que el editor abre automáticamente el archivo que contiene la función (Saludar.cpp) y coloca el cursor al inicio de la misma.

Como he dicho anteriormente solo centraremos la atención al vim, para el emacs puedes manejar tanto el ctags como el etags. Utiliza la información en línea para ver como se utiliza.

El compilador C de GNU se llama gcc y puede compilar C, C++ y Objective-C. El compilador de C se apega al estándar ANSI, por lo que es fácil de portar un programa C ANSI a Linux.

Cómo compilar con gcc

El compilador GNU se invoca con el comando gcc. De manera predeterminada este comando preprocesará, compilará y en enlazará un programa de C. Existen muchas opciones para el gcc, y entre ellas existen controles que permiten ejecutar solo alguna fase de la secuencia preproceso/compilación/enlace.

El siguiente ejemplo sencillo es un programa en C que simula el lanzamiento de un dado n veces, y luego imprime el número de veces que sale cada una de sus caras. Nota: El ejemplo lo saqué de un libro de C, espero no me demanden.

Crea el archivo juego.c:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int tirarDado(void);

int main(int argc, char * argv[])
{
int i, iIter, dado[6];

if(argc<2)
{
printf("Uso: %s n\n",argv[0]);
return 1;
}
iIter = atoi(argv[1]);
memset(dado, 0, sizeof(dado));
for(i=0; i<iIter; i++)
{
dado[tirarDado() - 1]++;
}
printf("%d tiradas\n",iIter);
printf("\tCara\tTiradas\n");
for(i=0; i<6; i++)
{
printf("\t%d : \t%d\n",i+1, dado[i]);
}
}

Y el archivo tirador.c:

#include<stdlib.h>
int tirarDado(void)
{
return (rand()%6+1);
}

Podríamos utilizar un solo comando para compilar y crear el programa ejecutable:

gcc -o juego juego.c tirador.c

Puede ver que -o indica el nombre del archivo de salida (el ejecutable). gcc sabe que los archivos con la extensión *.c son archivos de C y los compila como tales. Sino especifica un nombre de archivo de salida, gcc creará predeterminadamente el archivo a.out.

Ahora veamos otra manera de compilar nuestro programa: haciéndolo por módulos (por separado):

gcc -c juego.c
gcc -c tirador.c
gcc -o juego juego.o tirador.o

En este caso indicamos al compilador, con la opción -c, que primero el archivo juego.c, luego el archivo tirador.c. Y por último le indicamos que cree el archivo binario ejecutable, utilizando los dos archivos objeto (resultados de la compilación): juego.o y tirador.o.

Cómo compilar con g++

El comando g++ nos permite compilar archivos de C++. Aunque gcc puede compilar programas de C++, no hace automáticamente todos los enlaces requeridos con las bibliotecas de clases. Necesita usar g++ para esto. Por ello es recomendable que utilices g++ si estás utilizando C++.

Ahora vamos a compilar la versión C++ de nuestro programa de los dados; el archivo juego.cpp:

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
int tirarDado(void);
int main(int argc, char * argv[])
{
int i, iIter, dado[6];
if(argc<2)
{
cout<<"Uso: "<<argv[0]<<"n\n";
return 1;
}
iIter = atoi(argv[1]);
memset(dado, 0, sizeof(dado));
for(i=0; i<iIter; i++)
{
dado[tirarDado() - 1]++;
}
cout<<iIter<<" tiradas\n";
cout<<"\tCara\tTiradas\n";
for(i=0; i<6; i++)
{
cout<<"\t"<<i+1<<" :\t"<<dado[i]<<endl;
}
}

El archivo tirador.cpp:

#include<stdlib.h>
int tirarDado(void)
{
return (rand()%6+1);
}

La compilación en g++ es muy similar a gcc en casi todos los aspectos. Para compilar con un solo comando utiliza:

g++ -o juego juego.cpp tirador.cpp

Y para compilar por módulos:

g++ -c juego.cpp
g++ -c tirador.cpp
g++ -o juego juego.o tirador.o

ELF
Cuando se compila un programa, se genera un archivo objeto, y cuando se enlaza el programa, se crea un archivo binario ejecutable. El enlazador debe entender el formato de los archivos objeto, y como el sistema operativo debe cargar y ejecutar el programa ejecutable, también debe entender este formato.
Ya vio que el archivo ejecutable por defecto se llama a.out. Hace un tiempo, el formato de los archivos objeto y los archivos ejecutables se conocía como a.out. Este formato es muy antiguo y contiene bastantes defectos. El formato actual, utilizado por los sistemas UNIX y Linux se conoce como ELF (Formato Ejecutable y de Enlace). ELF es mucho más versátil que a.out, y se presta muy bien para crear bibliotecas compartidas (librerías dinámicas).

Puede saber cual es el formato de un archivo utilizando el comando file, por ej.:

file juego tirador.o /usr/bin/apt-get
juego: ELF 32-bit LSB executable, Intel 80386…
tirador.o: ELF 32-bit LSB relocatable, Intel 80386…
/usr/bin/apt-get: ELF 32-bit LSB executable, Intel 80386…

A veces, varios programas necesitan hacer las mismas cosas, como E/S por ejemplo. Hace ya bastante tiempo se desarrolló el concepto de biblioteca (o librería) para adaptar esto. Las funciones se colocan en un archivo, y luego, cada vez que se crea un programa, este extrae de la biblioteca las funciones que necesita.

En su momento, esto fue un gran avance, pero tenía varias desventajas. Los ejecutables se hacen más grandes ya que cada uno de ellos incrusta código copiado de las bibliotecas. Si se encuentra un error en la biblioteca o se agrega una característica, el ejecutable no hace uso de ella a menos que se vuelva a crear.

La solución a esto son las bibliotecas compartidas (o librerías dinámicas). El mecanismo de las bibliotecas compartidas esta fuera del alcance de este artículo. Solo veremos como crearlas y utilizarlas.

Regresemos al programa del dado que hicimos en C. Este programa tiene dos archivos fuente. Supongamos que nuestra función tirarDado (del archivo tirador.c) nos es muy útil, no solo en nuestro programa, sino en muchos otros programas que utilicen dados. Podemos pensar entonces en colocar dicha función en una biblioteca para que otros programas puedan usarla.

Primero necesitamos crear la biblioteca compartida. Para ello compilamos el archivo que contiene la función así:

gcc -fPIC -c tirador.c

Ahora lo convertimos en una biblioteca compartida llamada libtirar.so.1.0:

gcc -shared -Wl,-soname,libtirar.so.1 -o libtirar.so.1.0 tirador.o

Por último crearemos un enlace para libtirar.so, para que el programa en ejecución no necesite mantener un registro de la información de versión en el nombre de la biblioteca compartida:

ln -s libtirar.so.1.0 libtirar.so.1
ln -s libtirar.so.1 libtirar.so

Ahora que tenemos la biblioteca, debemos crear el programa principal para que enlace con esa biblioteca en tiempo de ejecución, en lugar de incluir el código dentro del ejecutable:

gcc -o juego juego.c -L. -ltirar

La opción -L. le indica al compilador que busque bibliotecas en el directorio actual, y la opción -ltirar le indica que busque una biblioteca llamada libtirar.so.

Al ejecutar el programa, el sistema operativo cargará dinámicamente la biblioteca correcta, pero tiene que saber donde buscarla. Si la biblioteca no se encuentra en un lugar estándar (/usr/lib por ejemplo), puede asignar una variable de entorno para que le indique en dónde localizar bibliotecas adicionales:

export LD_LIBRARY_PATH=/home/usuario/mislibrerias

Por último, para ver qué librerías usa un programa, utilice el comando ldd:

ldd juego
libtirar.so.1 =>/mnt/hda1/home/casidiablo/juegolibrerias/libtirar.so.1 (0×40018000)
libc.so.6 => /lib/libc.so.6 (0×40029000)
/lib/ld-linux.so.2 =>/lib/ld-linux.so.2 (0×40000000)

Otro ejemplo de bibliotecas… crear una biblioteca estática

A diferencia de las bibliotecas compartidas, al momento de compilar bibliotecas estáticas, se incluyen en el programa las rutinas que utiliza de la biblioteca; en otras palabras las rutinas están insertas en el programa sin la posibilidad de ser utilizados por otro programa. Nuestra demostración se basará en la construcción de una biblioteca estática; dentro de nuestra biblioteca incluiremos un procedimiento que imprimirá un mensaje en pantalla el que será pasado por parámetro y una función que nos entrega en cálculo del factorial de un numero dado (pasado por parámetro); para que luego estas rutinas sean llamadas desde un programa de ejemplo.

El proceso para crear bibliotecas estáticas es escribir el código fuente, compilar a código objeto el fuente y crear la biblioteca con los archivos objetos. A continuación procederemos a escribir nuestras rutinas que serán incluidas en la biblioteca, los archivo de las rutinas serán factorial.c e imprimir.c

//imprimir.c
#include<stdio.h>
void imprimir_en_pantalla(const char* mensaje)
{
printf("%s",mensaje);
}

//factorial.c
#include<stdio.h>
long factorial(long numero)
{
if(numero>0)
return numero * factorial(numero-1);
else return 1;
}

Ahora compilaremos estos archivos fuente y los convertiremos en código objeto utilizando gcc:

gcc -c imprimir.c factorial.c

Esto creará los archivos objeto (imprimir.o y factorial.o). El siguiente paso será crear nuestra biblioteca estática con estos archivos de código objeto; a la biblioteca la llamaremos libejemploestatica.a:

ar rsc libejemploestatica.a imprimir.o factorial.o

El comando ar creará nuestra biblioteca (opcion c), introducirá los archivos objeto al archivo creado (opción r) y por último creará un índice de los módulos (opción s), esto último permite que el linker (ld) al momento de compilar (ld es llamado por gcc) no tenga que leerse toda la biblioteca completa ya que se agregan los índices y descripción de los módulos. El proceso de crear el índice de los módulos también se pude realizar con ranlib.

//miprograma.c
#include<stdio.h>
#include "libejemploestatica.h"
int main()
{
printf("Programa de ejemplo de utilizacion de biblioteca\n");
imprimir_en_pantalla("Vamos a calcular un factorial\n");
printf("El valor del factorial de 4 es: %i\n",factorial(4));
}

Ahora nos falta crear nuestro archivo de cabecera (header), que son los que tienen terminación .h, en este archivo se incluirán las llamadas a las rutinas de la biblioteca y es una manera elegante porque también puedes incluir estas llamadas en el programa que las vas utilizar. El archivo de cabecera libejemploestatica.h tendrá el siguiente contenido:

extern void imprimir_en_pantalla(const char*);
extern long fatorial(long);

No es necesario que el archivo de cabecera y biblioteca sean iguales antes de la extensión. Ahora crearemos el archivo ejecutable en base a nuestro programa principal (miprograma.c), el cual utilizará la biblioteca que hemos creado. Para ello debemos compilarlo utilizando la biblioteca:

gcc -o programa_ejecutable miprograma.c -L. -lejemploestatica

Con la opción -L indicamos donde se encuentra nuestro archivo de cabecera, como en este se encuentra en el mismo directorio utilizamos el punto (-L.). Con la opción -l indicamos el nombre de la librería. Fíjate que no es necesario colocar el nombre completo (libejemploestatica) ya que gcc asume que los nombre de bibliotecas empiezan con el prefijo “lib”. Ahora ya tendremos el archivo ejecutable listo para correr nuestro programa:

$ ./programa_ejecutable
Programa de ejemplo de utilizacion de biblioteca
Vamos a calcular un factorial
El valor del factorial de 4 es: 24