Capitolo 12. Programmazione

Il comando "echo" deve essere usato con le precauzioni seguenti dato che la sua implementazione è diversa negli svariati comandi interni della shell ed esterni.

	Nota
	Sebbene l'opzione "-n" non faccia veramente parte della sintassi POSIX, è generalmente accettata.

	Suggerimento
	Se è necessario inserire sequenze di escape nella stringa in output, usare il comando "printf" al posto del comando "echo".

Negli script di shell vengono spesso usati parametri speciali.

Le nozioni base da ricordare riguardanti la espansione dei parametri sono le seguenti.

I due punti ":" in tutti gli operatori nell'elenco precedente sono di fatto opzionali.

Ogni comando restituisce uno stato di uscita che può essere usato in costrutti condizionali.

	Nota
	"0" nel contesto condizionale della shell significa "Vero", mentre "0" nel contesto condizionale in C significa "Falso".

	Nota
	"[" è l'equivalente del comando "test che valuta i propri argomenti sino a "]" come un'espressione condizionale.

Le espressioni condizionali di base che è bene ricordare sono le seguenti.

if [ conditional_expression ]; then
 if_success_run_this_command
else
 if_not_success_run_this_command
fi

In questo caso il "|| true" finale era necessario per assicurare che lo script non termini accidentalmente a tale riga quando la shell è invocata con l'opzione "-e".

Gli operatori aritmetici di comparazione di interi nelle espressioni condizionali sono "-eq", "-ne", "-lt", "-le", "-gt" e "-ge".

Ci sono diverse espressioni per cicli usabili nella shell POSIX.

	Suggerimento
	L'iterazione numerica in stile linguaggio C può essere realizzata usando seq(1) come "pippo1 pippo2 …"

	Suggerimento
	Vedere Sezione 9.4.9, «Ripetere un comando su diversi file».

Alcune popolari variabili d'ambiente per il normale prompt dei comandi della shell possono non essere disponibili nell'ambiente di esecuzione di uno script utente.

A grandi linee la shell elabora uno script nel modo seguente.

Virgolette singole all'interno di virgolette doppie non hanno alcun effetto.

L'esecuzione di "set -x" nella shell o l'invocazione della shell con l'opzione "-x" fanno sì che la shell stampi tutti i comandi eseguiti. Ciò è piuttosto utile per il debug.

Per far sì che il proprio programma di shell sia il più portabile possibile tra i sistemi Debian, è una buona idea limitare i programmi di utilità a quelli forniti dai pacchetti essenziali.

La maggior parte degli interpreti offre un controllo di base della sintassi e funzionalità di tracciamento del codice.

Uno script di shell può essere migliorato per creare un attraente programma GUI. Il trucco è di usare uno dei cosiddetti programmi di dialogo invece di interazioni tristi che usano i comandi echo e read.

Ecco un esempio di programma con GUI per dimostrare come è semplice facile farlo con uno script di shell.

Questo script usa zenity per selezionare un file (in maniera predefinita /etc/motd) e visualizzarlo.

I programmi di gestione di file con GUI possono essere estesi per effettuare alcune azioni comuni su file selezionati usando pacchetti di estensione aggiuntivi. È anche possibile fargli fare azioni personalizzate specifiche aggiungendo script specifici dell'utente.

Per elaborare dati, sh deve generare sottoprocessi che eseguono cut, grep, sed, ecc., ed è lento. D'altro canto, perl ha capacità interne per elaborare i dati, perciò è veloce. Molti script di manutenzione del sistema in Debian usano perl.

Si consideri il seguente pezzetto di script AWK e i suoi equivalenti in Perl.

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

Ciò equivale ad una qualsiasi delle righe seguenti.

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' |

L'ultima è una sorta di indovinello; sfrutta le seguenti caratteristiche di Perl.

La flessibilità è il punto di forza di Perl. Al contempo, ciò permette di creare codici criptici e ingarbugliati. Perciò fare attenzione.

Un semplice esempio "esempio.c" può essere compilato con una libreria "libm" in un eseguibile "eseg_esempio" nel modo seguente.

$ 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

In questo esempio, l'uso di "-lm" è necessario per fare il link alla libreria "/usr/lib/libm.so" nel pacchetto libc6 per sqrt(3). La libreria reale è in "/lib/" con nome file "libm.so.6", che è un collegamento simbolico a "libm-2.7.so".

Si guardi l'ultimo elemento nel testo di output: ci sono più di 10 caratteri anche se è stato specificato "%10s".

L'uso di funzioni che operano su puntatori di memoria senza controlli sui limiti, come sprintf(3) e strcpy(3) è deprecato per prevenire exploit di tipo buffer overflow che sfruttano gli effetti di superamento dei limiti di grandezza dei dati.

Un tutorial per bison(1) viene fornito da "info bison".

È necessario fornire i propri "main()" e "yyerror()". "main()" chiama "yyparse()" che a sua volta chiama "yylex()", solitamente creato con Flex.

Ecco un esempio di come creare un semplice programma per calcolatrice nel terminale.

Creare 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);
}

Creare 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 */ }
%%

Poi eseguire quanto segue dal prompt di shell per testarlo:

$ 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

Quando un programma va in crash, è una buona idea inviare un segnalazione di bug riportando le informazioni di backtrace.

Il backtrace può essere ottenuto da gdb(1) utilizzando uno dei seguenti approcci:

Per scoprire le dipendenze di un programma da librerie, usare ldd(1) nel modo seguente.

$ 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)

Affinché ls(1) funzioni in un ambiente "chroot", le librerie in questione devono essere disponibili nell'ambiente "chroot".

Se un programma gnome preview1 ha ricevuto un errore X, si dovrebbe leggere un messaggio del tipo seguente.

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

Se ciò avviene, si può provare ad eseguire il programma con "--sync" ed interrompere alla funzione "gdk_x_error" per ottenere un backtrace.

In Debian sono disponibili svariati strumenti di rilevazione di memory leak.

Si può disassemblare codice binario con objdump(1) nel modo seguente.

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

	Nota
	Per disassemblare codice in modo interattivo si può usare gdb(1).

Eseguire "make -p -f/dev/null" per vedere le regole interne automatiche.

Il sistema di compilazione del software si sta evolvendo: