Capítulo 12. Programación

La orden «echo» debe utilizarse con cuidado ya que su implementación cambia entre la orden interna y la externa.

	Nota
	Ya que la opción «-n» no pertenece realmente a la sintáxis POSIX es aceptada normalmente.

	Sugerencia
	Utilice la orden «printf» en vez de la orden «echo» si necesita incluir secuencias de caracteres en las cadenas de caracteres de salida.

Frecuentemente son utilizados por el intérprete de órdenes parámetros especiales

Lasexpansiones de parámetros fundamentales que debe recordar son las que se muestran.

Aquí, el símbolo «:» en todos estos operadores es realmente opcional.

Cada comando devuelve un estado de salida que puede usarse para expresioneos condicionales.

	Nota
	En el contexto del intérprete de órdenes «0« es equivalente a «verdadero«, mientras que en contexto de una condición en C «0« significa «falso«.

	Nota
	«[» es el equivalente a la orden test, la cual detemina la expresión condicional de sus parámetros hasta«]».

Algunas expresiones condicionales que es importate recordar son las que se muestran.

if [ conditional_expression ]; then
 if_success_run_this_command
else
 if_not_success_run_this_command
fi

Aquí se añade «|| true» para asegurarnos de que el archivo de órdenes no finaliza en esta línea si el intérprete de órdenes se llama con la bandera «-e».

Los operadores aritméticos de comparación de enteros en la expresión original son «-eq», «-ne», «-lt», «-le», «-gt» y «-ge».

Existen diferentes bucles en el intérprete de órdenes POSIX.

	Sugerencia
	La iteración sobre números como la del lenguaje C puede realizarse con la utilización de seq(1) como un generador de «foo1 foo2 …».

	Sugerencia
	Consulta Sección 9.4.9, “Repetición de una orden sobre archivos”.

Algunas variables del entorno populares para el símbolo del sistema del shell normal pueden no estar disponibles en el entorno de ejecución de su script.

El shell procesa un script aproximadamente como la siguiente secuencia.

Las comillas simples no tienen efecto dentro de comillas dobles.

Si ejecuta «set -x» en el intérprete de órdenes o lo llama con la opción «-x» hace que se impriman todas las órdenes ejecutadas. Esto puede ser muy útil para la depuración.

Para hacer los archivos de órdenes tan portables como sea posible entre sistemas Debian, es una buena idea limitar las utilidades a aquellos que son proporcionados por los paquetes esenciales.

La mayoría de los intérpretes ofrecen funciones básicas de comprobación sintáctica y rastreo de código.

El script de shell se puede mejorar para crear un programa GUI atractivo. El truco es usar uno de los llamados programas de diálogo en lugar de una interacción ligera usando los comandosecho y read.

Aquí hay un ejemplo del programa GUI para demostrar lo fácil que es sólo con un script de shell.

Este script usa zenity para seleccionar un archivo (predeterminado /etc/motd) y mostrarlo.

Los programas archivadores GUI pueden ampliarse para realizar algunas acciones populares en archivos seleccionados utilizando paquetes de extensión adicionales. También pueden realizar acciones personalizadas muy específicas añadiendo sus scripts específicos.

Para procesar los datos, sh necesita generar subprocesos que ejecuten cut, grep, sed, etc., es lento. Por otro lado, perl tiene capacidades internas para procesar datos, y es rápido. Así que muchos scripts de mantenimiento del sistema en Debian usan perl.

Pensemos en seguir un fragmento de la secuencia de comandos AWK de una sola línea y sus equivalentes en Perl.

awk '($2=="1957") { print $3 }' |

Esto es equivalente a cualquiera de las siguientes líneas.

perl -ne '@f=split; if ($f[1] eq "1957") { print "$f[2]\n"}' |

perl -ne 'if ((@f=split)[1] eq "1957") { print "$f[2]\n"}' |

perl -ne '@f=split; print $f[2] if ( $f[1]==1957 )' |

perl -lane 'print $F[2] if $F[1] eq "1957"' |

perl -lane 'print$F[2]if$F[1]eq+1957' |

El último es retorcido. Utiliza algunas de las funcionalidades avanzadas de Perl.

Esta flexibilidad es el punto fuerte de Perl. Al mismo tiempo, esto nos permite crear códigos crípticos y enredados. Así que ten cuidado.

Se puede crear un ejecutable «ejecutable_de_ejemplo» utilizando la biblioteca «libm» mediante este sencillo ejemplo.

$ cat > example.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); /* prevent buffer overflow */
        y[10] = '\0'; /* fill to make sure string ends with '\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í, se necesita «-lm» para enlazar la biblioteca «/usr/lib/libm.so» del paquete libc6 para utilizar la función sqrt(3). La biblioteca real está ubicada en «/lib/» con el nombre de archivo «libm.so.6», el cual es un enlace simbólico a «libm-2.7.so».

Mire el último elemento de la salida. Tiene incluso más de 10 caracteres a pesar de tener «%10s».

La utilización de operaciones de punteros sin comprobar los límites, como ocurre con sprintf(3) y strcpy(3), no se utilizan para evitar el desbordamiento del buffer que puede provocar problemas desconocidos. En su lugar se utilizan snprintf(3) y strncpy(3).

Puede encontrar un tutorial de bison(1) en «info bison».

Puede que sea necesario que proporcione su propio «main()» y «yyerror()». El método «main()» invoca «yyparse()» el cual invoca «yylex()», que normalmente se crea con Flex.

He aquí un ejemplo para crear un sencillo programa de calculadora de terminal.

Vamos a crear example.y:

/* calculator source for bison */
%{
#include <stdio.h>
extern int yylex(void);
extern int yyerror(char *);
%}

/* declare tokens */
%token NUMBER
%token OP_ADD OP_SUB OP_MUL OP_RGT OP_LFT OP_EQU

%%
calc:
 | calc exp OP_EQU    { printf("Y: RESULT = %d\n", $2); }
 ;

exp: factor
 | exp OP_ADD factor  { $$ = $1 + $3; }
 | exp OP_SUB factor  { $$ = $1 - $3; }
 ;

factor: term
 | factor OP_MUL term { $$ = $1 * $3; }
 ;

term: NUMBER
 | OP_LFT exp OP_RGT  { $$ = $2; }
  ;
%%

int main(int argc, char **argv)
{
  yyparse();
}

int yyerror(char *s)
{
  fprintf(stderr, "error: '%s'\n", s);
}

Vamos a crear example.l:

/* calculator source for flex */
%{
#include "example.tab.h"
%}

%%
[0-9]+ { printf("L: NUMBER = %s\n", yytext); yylval = atoi(yytext); return NUMBER; }
"+"    { printf("L: OP_ADD\n"); return OP_ADD; }
"-"    { printf("L: OP_SUB\n"); return OP_SUB; }
"*"    { printf("L: OP_MUL\n"); return OP_MUL; }
"("    { printf("L: OP_LFT\n"); return OP_LFT; }
")"    { printf("L: OP_RGT\n"); return OP_RGT; }
"="    { printf("L: OP_EQU\n"); return OP_EQU; }
"exit" { printf("L: exit\n");   return YYEOF; } /* YYEOF = 0 */
.      { /* ignore all other */ }
%%

A continuación, ejecute lo siguiente desde el símbolo del sistema para probar esto:

$ bison -d example.y
$ flex example.l
$ gcc -lfl example.tab.c lex.yy.c -o example
$ ./example
1 + 2 * ( 3 + 1 ) =
L: NUMBER = 1
L: OP_ADD
L: NUMBER = 2
L: OP_MUL
L: OP_LFT
L: NUMBER = 3
L: OP_ADD
L: NUMBER = 1
L: OP_RGT
L: OP_EQU
Y: RESULT = 9

exit
L: exit

Cuando encuentre un programas que no funciona, es una buena idea al informar del error añadir información sobre las trazas de su ejecución.

El backtrace se puede obtener mediante gdb(1) usando uno de los siguientes enfoques:

Utilice como se muestra ldd(1) para determinar las bibliotecas de las que depende un programa.

$ ldd /usr/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(1) funcione en un entorno `chroot` las bibliotecas siguientes deben estar disponibles en dicho entorno.

Si el programa GNOME preview1 ha recibido un error de las X se puede ver el mensaje como se muestra.

The program 'preview1' received an X Window System error.

En este caso, puede intentar ejecutar el programa con «--sync», y poner un punto de ruptura en la función «gdk_x_error» con el fin de obtener trazas.

Existen varias herramientas de detección de fugas de memoria en Debian.

Usted puede desemsamblar código binario con objdump(1) como se muestra.

$  objdump -m i386 -b binary -D /usr/lib/grub/x86_64-pc/stage1

	Nota
	gdb(1) puede ser utilizado para desemsamblar el código de forma interactiva.

Ejecute «make -p -f/dev/null»para ver las reglas internas automática.

El sistema de creación del software ha ido evolucionando: