miércoles, 1 de febrero de 2012

Programación para Linux Debian

En los siguientes apartados les presentamos las principales herramientas y medios para programar en Linux Debian

Shell

Leer los scripts de shell es la mejor manera de entender cómo funciona un sistema tipo Unix. Aquí, brindo algunos enlaces y recordatorios para la programación del shell. Véase Shell Mistakes para aprender de los errores.

Bash – el intérprete de comandos interactivo estándar de GNU

Referencias para Bash:
  • bash(1)
  • info bash
  • BASH Programming - Introduction HOWTO del LDP como documento introductorio.
  • mc file:///usr/share/doc/bash/examples/ file:///usr/share/doc/bash/
    (Instale el paquete bash-doc para ver archivos de ejemplo)
  • Learning the bash Shell, 2nd edition (O'Reilly)
Pequeño programa de ejemplo (sirve como entrada para el comando newusers): 
     #!/bin/bash
     # (C) Osmu Aoki Sun Aug 26 16:53:55 UTC 2001 Public Domain
     pid=1000;
     while read n1 n2 n3 ; do
     if [ ${n1:0:1} != "#" ]; then
     let pid=$pid+1
     echo ${n1}_${n2}:password:${pid}:${pid}:,,,/home/${n1}_${n2}:/bin/bash
     fi
     done

Intérpretes de comandos POSIX

En Debian diversos paquetes proporcionan un intérprete de comandos POSIX:
  • dash (Sarge)
    • Prioridad: opcional
    • Tamaño de instalación: 176
    • Lejos, el más pequeño y el más rápido; el mejor para el arranque inicial
  • ash (Woody)
    • Prioridad: opcional
    • Tamaño de instalación: 180
    • Pequeño y muy rápido – bueno para el arranque inicial
  • bash
    • Esencial: sí
    • Prioridad: requerido
    • Tamaño de instalación: 580
    • El más grande y más completo – posee diversas extensiones implementadas
  • pdksh
    • Prioridad: opcional
    • Tamaño de instalación: 408
    • Clon del ksh de AT&T
Si desea escribir scripts de shell portables, resulta conveniente escribirlos como script de shell POSIX . Use /bin/sh enlazado con ash o (dash) para comprobar su compatibilidad POSIX. Evite escribir scripts usando la sintaxis propia del bash o del zsh. Por ejemplo, evite usar:
  • if [ foo == bar ] ; then ...
  • diff -u archivo.c{.orig,}
  • mkdir /foo{bar,baz}
La descripción de los intérpretes de comandos en el presente documento se aplica únicamente a aquellos del tipo POSIX y no a csh incluyendo a tcsh.

Parámetros del intérprete de comandos

Diversos parámetros especiales para recordar: 
     $0      = nombre del shell o del script del shell
     $1      = primer argumento
      ...
     $9      = noveno argumento
     $#      = cantidad de parámetros
     "$*"    = "$1 $2 $3 $4 ... $n"
     "$@"    = "$1" "$2" "$3" "$4" ... "$n"
     $?      = estado de salida del comando más reciente
     $$      = PID del script de shell
     $!      = PID del proceso en segundo plano más reciente
Expansiones de parámetros básicas para recordar: 
         Forma       Si var está   Si var 
                     inicializada  no está inicializada
     ${var:-cadena}  $var          cadena
     ${var:+cadena}  cadena        null
     ${var:=cadena}  $var          cadena 
                                   (y ejecute var=cadena)
     ${var:?cadena}  $var          (repite cadena y luego sale)
Aquí, en realidad, los `:' son opcionales para todos los operadores.
  • Con los `:' = el operador comprueba la existencia y la no nulidad.
  • Sin los `:' = el operador comprueba únicamente la existencia.
Sustituciones de parámetros básicas para recordar: 
         Forma       Resultado
     ${var%sufijo}   Elimina el patrón sufijo más pequeño
     ${var%%sufijo}  Elimina el patrón sufijo más grande
     ${var#prefijo}  Elimina el patrón prefijo más pequeño
     ${var##prefijo} Elimina el patrón prefijo más grande

13.2.4 Redireccionamiento del shell

Redireccionamiento básico para recordar (aquí el [n] es un número opcional para especificar el descriptor de archivo): 
     [n]> archivo    Redirige stdout (o n) al archivo.
     [n]>> archivo   Añade stdout (o n) al archivo.
     [n]< archivo    Redirige stdin (o n) desde el archivo.
     [n1]>&n2        Redirige stdout (o n1) a
     n2.
     2> archivo >&2   Redirige stdout y stderr al archivo.
     | comando       Desvía stdout al comando.
     2>&1 | comando   Desvía stderr y stdout comando.
Aquí:
  • stdin: entrada estándar (descriptor de archivo = 0)
  • stdout: salida estándar (descriptor de archivo = 1)
  • stderr: error estándar (descriptor de archivo = 2)
El intérprete de comandos le permite abrir archivos usando el comando propio exec con un descriptor de archivo arbitrario. 
     $ echo Hola >loquesea1
     $ exec 3<loquesea1 4>loquesea2  # abrir archivos
     $ cat <&3 >&4       # redirigir stdin a 3, stdout a 4
     $ exec 3<&- 4>&-    # cerrar archivos
     $ cat loquesea2
     Hola
Aquí n<&- y n>&- significan cerrar el descriptor de archivo n.

Operadores condicionales del shell

Todos los comandos devuelven un estado de salida que se pueden utilizar para expresiones condicionales:
  • Éxito: 0 (Verdadero)
  • Error: 1 - 255 (Falso)
Obsérvese que aquí el valor 0, contrariamente a la convención habitual en otras áreas de la computación, significa "verdadero". Asimismo, `[' es equivalente al comando test, que evalúa sus argumentos hasta `]' como expresión condicional.
Expresiones condicionales básicas para recordar: 
     comando && si_éxito_ejecutar_también_este_comando ||
     verdadero
     comando || si_fracaso_ejecutar_en_cambio_este_comando
     
     if [ expresión_condicional ]; then  
      si_éxito_ejecutar_este_comando
     else
      si_fracaso_ejecutar_este_comando
     fi
En este caso || verdadero se necesita para asegurarse que este script de shell no salga accidentalmente en esta línea al invocar el intérprete de comandos con la opción -e.
Los operadores de comparación de archivos en las expresiones regulares son: 
     -e archivo            Verdadero si archivo existe.
     -d archivo            Verdadero si archivo existe y es un directorio.
     -f archivo            Verdadero si archivo existe y es un archivo normal.
     -w archivo            Verdadero si archivo existe y se puede escribir.
     -x archivo            Verdadero si archivo existe y es ejecutable.
     archivo1 -nt archivo2 Verdadero si archivo1 es más reciente que archivo2 (modificación)
     archivo1 -ot archivo2 Verdadero si archivo1 es más antiguo que archivo2 (modificación)
     archivo1 -ef archivo2 Verdadero si son el mismo dispositivo o tienen igual ínodo.
Los operadores de comparación de cadenas en las expresiones condicionales son: 
          -z str    Verdadero si la longitud de str es igual a cero.
          -n str    Verdadero si la longitud de str es distinta de cero.
     str1 == str2   Verdadero si las str son iguales.
     str1 = str2    Verdadero si las str son iguales.
          (debería usarse "=" en vez de "==" para una extricta compatibilidad POSIX) 
     str1 != str2   Verdadero si las str son distintas.
     str1 <  str2   Verdadero si str1 está antes que str2 (depende del local).
     str1 >  str2   Verdadero si str1 está después que str2 (depende del local).
Los operadores de comparación aritmética entera en las expresiones condicionales son -eq, -ne, -lt, -le, -gt o -ge.

Tratamiento de la línea de comandos

El intérprete de comandos procesa un script de la siguiente manera:
  • separación de símbolos mediante metacaracteres: ESPACIO, TAB, NEWLINE, ;, (, ), <, >, |, &
  • búsqueda de palabras claves si no están entre "..." o '...' (bucle)
  • expansión de alias si no están entre "..." o '...' (bucle)
  • expansión de llaves, A{b|c} -> Ab Ac, si no están entre "..." o '...'
  • expansión de tildes, ~user -> $HOME/$USER, si no están entre "..." o '...'
  • expansión de parámetros, $PARAMETER, si no están entre '...'
  • expansión de sustitución de comandos, $(comando), si no están entre '...'
  • separación en palabras con $IFS si no están entre "..." o '...'
  • expansión de nombres de rutas *?[] si no están entre "..." o '...'
  • búsqueda de comando
    • función
    • comando interno
    • archivo en el $PATH
  • bucle
Las comillas simples dentro de las dobles no tienen ningún efecto.
Al ejecutar set -x en el intérprete de comandos o al invocar este último con la opción -x hará que se muestren todos los comandos ejecutados. Esto resulta bastante práctico para depurar.

Awk

Referencias para Awk:
  • Effective awk Programming, 3rd edition (O'Reilly)
  • Sed & awk, 2nd edition (O'Reilly)
  • mawk(1) y gawk(1)
  • info gawk
Pequeño programa de ejemplo (sirve como entrada para el comando newusers) 
     #!/usr/bin/awk -f
     # Script para crear un archivo que sirva para usar con el comando
     # newusers a partir de un archivo que contiene las IDs y contraseñas de
     # los usuarios de la siguiente manera: nombre apellido contraseña
     # Copyright (c) KMSelf Sat Aug 25 20:47:38 PDT 2001
     # Distribuido bajo GNU GPL v 2 o cualquier versión posterior.
     # Este programa se distribuye SIN NINGUNA GARANTÍA.
     
     BEGIN {
         # Asignar UID, GID iniciales
         if ( ARGC > 2 ) {
             startuid = ARGV[1]
             delete ARGV[1]
         }
         else {
             printf( "Uso: newusers UIDinicial archivo\n" \
               "...donde UIDinicial es el ID del primer usuario " \
               "a agregar y 'archivo' es \n" \
               "un archivo de entrada de la forma: \n"\
               "'nombre apellido contraseña'\n" \
             )
             exit
         }
     
         infile = ARGV[1]
         printf( "Primer UID: %s\n\n", startuid )
     }
     
     /^#/ { next }
     
     {
         ++record
         first = $1
         last = $2
         passwd = $3
         user= substr( tolower( first ), 1, 1 ) tolower( last )
         uid = startuid + record - 1
         gid = uid
         printf( "%s:%s:%d:%d:%s %s,,/home/%s:/bin/bash\n",  \
             user, passwd, uid, gid, first, last, user \
             )
     }
En Debian dos paquetes proveen awk POSIX:
  • mawk
    • Prioridad: requerido
    • Tamaño de instalación: 228
    • Más pequeño y mucho más rápido – útil para una instalación predeterminada
    • Compile-time limits exist
      • NF = 32767
      • sprintf buffer = 1020
  • gawk
    • Prioridad: opcional
    • Tamaño de instalación: 1708
    • Más grande y completo – posee diversas extensiones implementadas
      • System V Release 4 version of UNIX
      • awk de laboratorios Bell
      • específicas de GNU

Perl

Este es él intérprete interpreter on a Unix-like system.
Referencias para Perl:
Pequeño programa de ejemplo (sirve como entrada para el comando newusers) 
     #!/usr/bin/perl
     # (C) Osamu Aoki Sun Aug 26 16:53:55 UTC 2001 Public Domain
     $pid=1000;
     while (<STDIN>) {
             if (/^#/) { next;}
             chop;
             $pid++;
             ($n1, $n2, $n3) = split / /;
             print $n1,"_",$n2,":", $n3, ":",$pid,
                       ":",$pid,",,,/home/",$n1,"_",$n2,":/bin/bash\n"
     }
Instalar el módulo Perl nombre módulo: 
     # perl -MCPAN -e 'install nombre_modulo'

Python

Es un intérprete orientado a objetos muy agradable.
Referencias para Python:
Pequeño programa de ejemplo (sirve como entrada para el comando newusers) 
     #! /usr/bin/env python
     import sys, string
     
     # (C) Osamu Aoki Sun Aug 26 16:53:55 UTC 2001 Public Domain
     # Adaptado del script awk por KMSelf Sat Aug 25 20:47:38 PDT 2001
     # Este programa se distribuye SIN NINGUNA GARANTÍA.
     
     def usages():
         print \
     "Uso:  ", sys.argv[0], " UID_inicial [nombre_archivo]\n" \
     "\tUID_inicial es el ID del primer usuario a agregar.\n" \
     "\tnombre_archivo es el nombre del archivo de entrada.\n" \
     "Si no se especifica, se toma la entrada estándar.\n\n" \
     "Formato del archivo de entrada:\n"\
     "\tnombre apellido contraseña\n"
                     return 1
     
     def parsefile(startuid):
         #
         # filtrado principal
         #
         uid = startuid
         while 1:
             line = infile.readline()
             if not line:
                 break
             if line[0] == '#':
                 continue
             (first, last, passwd) = string.split(string.lower(line))
             # lo anterior falla con un # equivocado de parámetros :-)
             user = first[0] + last
             gid = uid
             lineout = "%s:%s:%d:%d:%s %s,,/home/%s:/bin/bash\n" %  \
                 (user, passwd, uid, gid, first, last, user)
             sys.stdout.write(lineout)
             +uid
     
     if __name__ == '__main__':
         if len(sys.argv) == 1:
             usages()
         else:
             uid = int(sys.argv[1])
             #print "# UID empieza desde: %d\n" % uid
             if len(sys.argv) > 1:
                 infilename   = string.join(sys.argv[2:])
                 infile = open(infilename, 'r')
                 #print "# Leer archivo desde: %s\n\n" % infilename
             else:
                 infile = sys.stdin
             parsefile(uid)

Make

Referencias for Make:
  • info make
  • make(1)
  • Managing Projects with make, 2nd edition (O'Reilly)
Variables automáticas sencillas:
Sintaxis de las reglas: 
     Objetivo: [Prerequisito ... ]
      [TAB] comando1
      [TAB] -comando2         # ignorar errores
      [TAB] @comando3         # evitar repetición
Aquí [TAB] es un TAB. Cada línea es interpretada por el shell antes de la sustitución de variables por parte de make. Utilice la \ al final de la línea para continuar el script. Utilice $$ para escribir el $ para las variables de entorno para un script de shell.
Las reglas implícitas para el objetivo y los prerequisitos se pueden escribir, por ejemplo, así: 
     %: %.c header.h
o, 
     %.o: %.c header.h
En este caso, el objetivo contiene el carácter % (exactamente uno de ellos). El % puede corresponderse con cualquier subcadena no vacía en los nombres de los archivos objetivo actuales. Asimismo, los prerequisitos usan % para mostrar cómo se relaciones sus nombres con el nombre del objetivo actual.
Las reglas de sufijo son una forma obsoleta de definir reglas implícitas para make. Por compatibilidad, aún son admitidas en el make GNU pero, en lo posible, utilice las reglas de patrón equivalentes: 
     antigua regla de sufijo --> nueva regla de patrón
     .c:                     --> %  : %.c
     .c.o:                   --> %.o: %.c
Variables automáticas para las reglas anteriores: 
     foo.o: nuevo1.c nuevo2.c original1.c nuevo3.c
     $@ == foo.o                                  (objetivo)
     $< == nuevo1.c                               (el primero)
     $? == nuevo1.c nuevo2.c nuevo3.c             (los nuevos)
     $^ == nuevo1.c nuevo2.c original1.c nuevo3.c (todos)
     $* == `%' patrón correspondiente al patrón objetivo.
Referencia de las variables: 
     foo1 := bar    # Expansión única
     foo2  = bar    # Expansión recursiva
     foo3 += bar    # Añade
     SRCS := $(wildcard *.c)
     OBJS := $(foo:c=o)
     OBJS := $(foo:%.c=%.o) 
     OBJS := $(patsubst %.c,%.o,$(foo)) 
     DIRS  = $(dir directory/filename.ext) # Extrae "directory"
     $(notdir NAMES...), $(basename NAMES...), $(suffix NAMES...) ...
Ejecute make -p -f/dev/null para ver las reglas automáticas internas.

13.7 C

Preparación: 
     # apt-get install glibc-doc manpages-dev libc6-dev gcc
Referencias para C:

13.7.1 Programa sencillo en C (gcc)

Un simple ejemplo example.c para compilar con la biblioteca libm y obtener el ejecutable run_example: 
     $ cat > exemple.c << EOF 
     #include <stdio.h>
     #include <math.h>
     #include <string.h>
     
     int main(int argc, char **argv, char **envp){
         double x;
         char y[11];
         x=sqrt(argc+7.5);
         strncpy(y, argv[0], 10); /* evita el desbordamiento del búfer */
         y[10] = '\0'; /* para asegurar que la cadena termine con un '\0' */
         printf("%5i, %5.3f, %10s, %10s\n", argc, x, y, argv[1]);
         return 0;
     }
     EOF
     $ gcc -Wall -g -o run_example example.c -lm
     $ ./run_example
         1, 2.915, ./run_exam,     (null)
     $ ./run_example, 1234567890qwerty
         2, 3.082, ./run_exam, 1234567890qwerty
Aquí, -lm se necesita para enlazar la biblioteca libm y poder así usar sqrt(). La biblioteca actual se encuentra en el directorio /lib con el nombre libm.so.6 que es un enlace lógico a libm-2.1.3.so.
Observe el último parámetro del texto de salida. Existen más de 10 caracteres a pesar de haber especificado %10s.
El uso de funciones que efectuan operaciones con punteros sin verificar sus limítes, tales como sprintf y strcpy, es censurado pues no evita las vulnerabilidades que surgen por desbordamiento de búfer. Utilice, en cambio, snprintf y strncpy.

Depurar

Depurando con gdb

Preparación: 
     # apt-get install gdb
Referencias para gdb:
Utilice gdb para depurar un programa compilado con la opción -g. Muchos de los comandos se pueden abreviar. La expansión del tabulador funciona de igual manera que en el shell. 
     $ gdb programa
     (gdb) b 1                # coloca un punto de ruptura en la línea 1
     (gdb) run arg1 arg2 arg3 # ejecuta programa
     (gdb) next               # va a la siguiente línea
     ...
     (gdb) step               # avanza un paso
     ...
     (gdb) p parm             # imprime parámetro 
     ...
     (gdb) p parm=12          # inicializa el valor del parámetro en 12
Para depurar dentro de Emacs, diríjase a Resumen de los comandos del editor (Emacs, Vim), Sección 11.3.4.
En un sistema Debian, la mayoría de los símbolos de depuración han sido eliminados. Para que gdb resulte útil para depurar paquetes Debian, es necesario volver a construir dichos paquetes siguiendo los siguientes pasos:
  • Edite debian/control para volcar el paquete version.
  • Verifique los scripts de creación y asegúrese usar CFLAGS=-g -Wall para compilar los binarios.
  • Exporte DEB_BUILD_OPTIONS=nostrip,noopt para crear el paquete Debian.
Véase Policy 10.1 para mayor información.

Verificar dependencias con bibliotecas

Utilice ldd para averiguar las dependencias de un programa con respecto a las bibliotecas: 
     $ ldd /bin/ls
             librt.so.1 => /lib/librt.so.1 (0x4001e000)
             libc.so.6 => /lib/libc.so.6 (0x40030000)
             libpthread.so.0 => /lib/libpthread.so.0 (0x40153000)
             /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
Para que ls funcione en un entorno chroot, deben esta disponibles las mencionadas bibliotecas.
Pueden también resultar útiles los siguientes comandos.
  • strace: rastrea las señales y llamadas al sistema
  • ltrace: rastrea las llamadas a las bibliotecas

Depurar con herramientas de detección de fugas de memoria

Existen diversas herramientas de detección de fugas de memoria disponibles en Debian.
  • njamd
  • valgrind
  • dmalloc
  • electric-fence
  • memprof
  • memwatch (el paquete no existe, obténgalo de memwatch.)
  • mpatrol
  • leaktracer
  • libgc6
  • Insure++ de Parasoft. (propietario, commercial for fee)

Flex – un Lex mejorado

flex es un generador de analizadores sintácticos muy veloz.
Referencias para flex:
  • info flex (tutorial)
  • flex(1)
Necesita proporcionar su propia main() y yywrap(), o su programa.l se vería así al compilar sin la biblioteca (yywrap es una macro; %option main activa en forma implícita a %option noyywrap): 
     %option main
     %%
     .|\n    ECHO ;
     %%
Alternativamente, puede compilar con la opción -lfl del enlazador al final de la línea de comando de cc (como ATT-Lex con -ll). En este caso no se necesita la %option.

Bison – un Yacc mejorado

En Debian diversos paquetes proporcionan un generador de analizadores LALR compatible con Yacc:
  • bison: generador de analizador LALR GNU
  • byacc: el generador de analizador LALR de Berkeley
  • btyacc: generador de analizador con backtracking basado en byacc
Referencias para bison:
  • info bison (tutorial)
  • bison(1)
Necesita proporcionar su propia main() y yyerror(). main() llama a yyparse() que llama a yylex() que ha sido generalmente creada con FleX. 
     %%
     
     %%

Autoconf

autoconf es una herramienta para crear scripts de shell que automáticamente configuran los paquetes con código fuente para adaptarlos a distintos tipos de sistemas tipo UNIX que utilizan el sistema de compilación GNU.
autoconf crea el script de configuración configure. configure crea automáticamente un Makefile y un Makefile.am personalizados.

Compilar e instalar un programa

Debian no toca los archivos situados en /usr/local/ (véase En apoyo a la diversidad, Sección 2.5). Por lo tanto, si compila un programa a partir de sus fuentes, instálelo en /usr/local/ de modo que no interfiera con Debian. 
     $ cd src
     $ ./configure --prefix=/usr/local
     $ make
     $ make install # esto ubica los archivos en el sistema

Desinstalar un programa

SI cuenta con los fuentes, SI éstos utilizan autoconf/automake y SI puede recordar cómo lo configuró: 
     $ ./configure todas-las-opciones-que-eligió
     # make uninstall
Alternativamente, si está absolutamente sequro que el proceso de instalación ubicó todos los archivos únicamente en /usr/local/ y que no hay nada importante allí, puede borrar todo su contenido haciendo: 
     # find /usr/local -type f -print0 | xargs -0 rm -f
Si no está seguro dónde fueron instalados los archivos, considere el uso de checkinstall que permite desinstalaciones limpias.

Web

Se pueden crear páginas web dinámicas interactivas sencillas de la siguiente forma:
  • Las peticiones son mostradas en el navegador del usuario usando formularios HTML.
  • Al llenar y pulsar en las entradas del formulario se envia una URL con parámetros codificados [55] desde el navegador al servidor web. Por ejemplo:
    • http://www.loquesea.dom/cgi-bin/program.pl?VAR1=VAL1&VAR2=VAL2&VAR3=VAL3
    • http://www.loquesea.dom/cgi-bin/program.py?VAR1=VAL1&VAR2=VAL2&VAR3=VAL3
    • http://www.loquesea.dom/program.php?VAR1=VAL1&VAR2=VAL2&VAR3=VAL3
  • El programa CGI (cualquiera de program.*) en el servidor web recibirá los parámetros descodificados "VAR1=VAL1 VAR2=VAL2 VAR3=VAL3" como contenido de la variable de entorno "QUERY_STRING" y se ejecutará.
  • La stdout del programa CGI se enviará al navegador web y se presentará como una página web dinámica interactiva.
Por cuestiones de seguridad no cree artesalmente nuevos artificios para analizar parámetros CGI. Existen módulos para ellos en Perl (véase Perl, Sección 13.4) y Python (véase Python, Sección 13.5). PHP viene con esta funcionalidad. Cuando se necesita almacenamiento de datos del lado del cliente se utilizan cookies. Cuando se necesita procesar datos del lado del cliente, frecuentemente se utiliza javascript.
Si se busca "CGI tutorial" en Google escribiendo la URL http://www.google.com/search?hl=en&ie=UTF-8&q=CGI+tutorial directamente en el navegador es una buena manera de ver el script CGI del servidor Google en acción.

13.9 Preparación de documentos

13.9.1 Tratamiento de texto roff

Tradicionalmente, roff es el sistema de tratamiento de texto principal de Unix.
Véase roff(7), groff(7), groff(1), grotty(1), troff(1), groff_mdoc(7), groff_man(7), groff_ms(7), groff_me(7), groff_mm(7) e "info groff".
Existe un buen tutorial sobre macros -me. Si tiene groff (1.18 o posterior), busque file:///usr/share/doc/groff/meintro.me.gz y haga lo siguiente: 
     $ zcat file:///usr/share/doc/groff/meintro.me.gz | \
          groff -Tascii -me - | less -R
Lo que sigue creará un archivo de texto: 
     $ zcat file:///usr/share/doc/groff/meintro.me.gz | \
         GROFF_NO_SGR=1 groff -Tascii -me - | col -b -x > meintro.txt
Para imprimir use la salida PostScript. 
     $ groff -Tps meintro.txt | lpr
     $ groff -Tps meintro.txt | mpage -2 | lpr

SGML

Preparación: 
     # apt-get install debiandoc-sgml debiandoc-sgml-doc
Referencias de debiandoc-sgml:
  • file:///usr/share/doc/debiandoc-sgml-doc
  • debiandoc-sgml(1)
  • DocBook: The Definitive Guide, de Walsh y Muellner, (O'Reilly) (paquete docbook-defguide)
SGML permite la creación de múltiples formatos de un mismo documento. Un sistema SGML sencillo es Debiandoc que es el que se usó aquí. Este requiere de pequeñas adaptaciones en los archivos de texto originales para los siguientes caracteres:
  • "<" --> &lt;
  • ">" --> &gt;
  • " " --> &nbsp; (espacio sin ruptura)
  • "&" --> &amp;
  • "%" --> &percnt;
  • "©" --> &copy;
  • "–" --> &ndash;
  • "—" --> &mdash;
Para marcar una sección como comentario, escriba: 
     <!-- El tema empieza aquí ... -->
Para marcar una sección que necesita modificarse, escriba: 
     <![ %FIXME [ El tema empieza aquí ... ]]>
En SGML, la primer definición de una entidad gana. Por ejemplo: 
     <!entity % qref "INCLUDE">
     <![ %qref [ <!entity param "Datos 1"> ]]>
     <!entity param "Datos 2">
     &param;
Esto finaliza como "Datos 1". Si en la primer línea figurara "IGNORE" en vez de "INCLUDE" finalizaría como "Datos 2" (la segunda línea es una sentencia condicional). Asimismo, las frases que se repiten se pueden definir de antemano separadas del contexto. 
     <!entity esto "mi">
     Hola &esto; amigo.
     Este es &esto; libro.
Esto resulta en lo siguiente: 
     Hola mi amigo.
     Este es mi libro.
Vea el pequeño ejemplo en SGML sample.sgml en los ejemplos.
Cuando los documentos SGML aumentan de tamaño TeX, que es utilizado como interfaz del procesador de texto.

TeX/LaTeX

Preparación: 
     # tasksel # seleccionar Miscelánea  --> Entorno TeX/LaTeX
Referencias para LaTeX:
  • The teTeX HOWTO: The Linux-teTeX Local Guide
  • tex(1)
  • latex(1)
  • The TeXbook, de Donald E. Knuth, (Addison-Wesley) [56]
  • LaTeX - A Document Preparation System, de Leslie Lamport, (Addison-Wesley)
  • The LaTeX Companion, de Goossens, Mittelbach, Samarin, (Addison-Wesley)
Éste es el entorno más poderoso para la composición de documentos. Muchos procesadores SGML lo utilizan como su procesador de texto. Lyx proporcionado por lyx, lyx-xforms o lyx-qt y GNU TeXmacs, proporcionado por el paquete texmacs, ofrecen un entorno de edición WYSIWYG agradable para LaTeX mientras que muchos utilizan a Emacs y Vim como editores de los archivos fuente.
Existen diversos recursos disponibles en Internet:
Cuando los documentos SGML aumentan de tamaño TeX puede, a veces, provocar errores. Debe incrementar el tamaño del repositorio en /etc/texmf/texmf.cnf (o mejor editar /etc/texmf/texmf.d/95NonPath y ejecutar update-texmf) para solucionarlo.

Programación ilustrada

En vez de escribir código que contenga documentación, el programador ilustrado escribe documentación que contiene código. Este enfoque asegura una buena documentación del programa.
Para más información sobre programación ilustrada, véase Literate Programming.

Noweb

Preparación: 
     # apt-get install nowebm
Referencias para Noweb:
Esta herramienta de la programación ilustrada del tipo WEB es mucho más sencilla ya que provee extensibilidad e independencia de lenguaje. [57] Cuando se invoca noweb, escribe el código fuente del programa en los archivos mencionados en el archivo noweb y crea un archivo TeX para la composición de la documentación.
El paquete Debian ifupdown es un buen ejemplo. 
     $ apt-get source ifupdown
     $ cd ifupdown*
     $ make ifupdown.pdf ifupdown.ps

Doxygen

Preparación: 
     # apt-get install doxygen doxygen-doc doxygen-gui
Referencias para Doxygen (¡creado por doxygen!):
Puede generar documentación HTML, RTF, páginas de manual Unix, PostScript y PDF (usando LaTeX) para C++, C, Java, IDL y, con en cierto grado, para programas en PHP y C#. Doxygen es compatible con JavaDoc (1.1), Qt-Doc, KDOC y fue específicamente diseñado para ser usado en proyecto que utilizan el conjunto de herramientas Qt de Troll Tech. Al crear incluye gráficos de dependencia, diagramas de colaboración y gráficos jerárquicos incluso para programas no documentados. La salida es similar a la de la documentación Qt.

Creación de paquetes Debian

Preparación: 
     # apt-get install debian-policy developers-reference \
             maint-guide dh-make debhelper
     # apt-get install packaging-manual # en el caso de Potato
Referencias para la creación de paquetes:


  • Guía para Nuevos Encargados de Debian (tutorial)
  • dh-make(1)
  • Referencia para los Desarrolladores de Debian (práctico)
  • Manual de Normativa de Debian (oficial)
  • Manual para la creación de paquetes (Potato)

Empaquetar un único binario

Método rápido para empaquetar un único binario por Joey Hess. 
     # mkdir -p mi_pqt/usr/bin mi_pqt/DEBIAN
     # cp binario mi_pqt/usr/bin
     # cat > mi_pqt/DEBIAN/control
     Package: mi_paquete
     Version: 1
     Architecture: i386
     Maintainer: Joey Hess <joeyh@debian.org>     
     Description: mi pequeño paquete
     No espere demasiado.
     ^D
     # dpkg-deb -b mi_pqt
 
Fuentes: debian.org , documentación
Publicado por en

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)