Kapitel 12. Programmierung

Der Befehl "echo" muss mit Vorsicht verwendet werden, da seine Implementierung sich zwischen Shell-Builtins und externen Befehlen unterscheidet:

	Anmerkung
	Obwohl die Option "-n" nicht wirklich der POSIX-Syntax entspricht, ist sie grundsätzlich akzeptiert.

	Tipp
	Nutzen Sie den "printf"-Befehl statt "echo", wenn Sie Escape-Sequenzen in auszugebenen Zeichenketten einbetten möchten.

Einige spezielle Shell-Parameter werden oft in Shell-Skripten verwendet:

Grundlegende Parameterauswertungen, die Sie sich einprägen sollten:

Hierbei ist der Doppelpunkt ":" in allen Operatoren optional:

Jeder Befehl gibt einen Beendigungs-Status (Exit-Status) zurück, der für einen bedingten Ausdruck verwendet werden kann:

	Anmerkung
	"0" im Kontext eines bedingten Ausdrucks für die Shell bedeutet "Wahr", während "0" im Kontext eines bedingten Ausdrucks für ein C-Programm "Falsch" bedeutet.

	Anmerkung
	"[" ist das Äquivalent des test-Befehls; Argumente bis zum "]" werden als bedingter Ausdruck gewertet.

Grundlegende Ausdrucksformen für bedingte Ausdrücke, die Sie sich einprägen sollten:

if [ conditional_expression ]; then
 if_success_run_this_command
else
 if_not_success_run_this_command
fi

Hierbei ist das "|| true" am Ende erforderlich, um sicherzustellen, dass das Shell-Skript sich bei dieser Zeile nicht fälschlicherweise beendet, wenn die Shell mit der "-e"-Option aufgerufen wird.

Arithmetische Ganzzahlvergleicher in bedingten Ausdrücken sind "-eq", "-ne", "-lt", "-le", "-gt" und "-ge".

Es gibt mehrere Ausdrucksweisen für Schleifen, die in POSIX-Shells genutzt werden können:

	Tipp
	Die der C-Sprache ähnliche nummerische Wiederholung (Iteration) kann realisiert werden, indem seq(1) für die Erzeugung der "foo1 foo2 …"-Liste genutzt wird.

	Tipp
	Lesen Sie auch Abschnitt 9.4.9, „Einen Befehl wiederholt mit einer Schleife über verschiedene Dateien ausführen“.

Einige populäre Umgebungsvariablen für den normalen Shell-Befehlsprompt könnten in der Ausführungsumgebung Ihres Skriptes nicht verfügbar ein.

Die Shell verarbeitet ein Skript im Prinzip in der folgenden Abfolge:

Einfache Anführungszeichen innerhalb von doppelten Anführungszeichen haben keine Wirkung.

Das Ausführen von "set -x" in der Shell oder das Aufrufen einer Shell mit der Option "-x" veranlasst die Shell, alle ausgeführten Befehle auch auf dem Bildschirm auszugeben. Dies ist sehr nützlich zur Fehlersuche.

Um Ihr Shell-Programm innerhalb des Debian-Systems möglichst weit portierbar zu machen, ist es eine gute Idee, die zu nutzenden Hilfsprogramme auf diejenigen einzuschränken, welche durch die essential-Pakete bereitgestellt werden:

Die meisten Interpreter bieten eine grundlegende Syntaxprüfung und Funktionalitäten zur Code-Nachverfolgung.

Ein Shell-Skript kann aufgewertet werden, um ein attraktives GUI-Programm zu erzeugen. Der Trick ist, eines der sogenannten Dialog-Programme zu verwenden, statt der stumpfen Interaktion über echo- und read-Befehle.

Hier ein Beispiel für ein GUI-Programm, um zu demonstrieren, wie einfach es sein kann mit nur einem Shell-Skript.

Dieses Skript nutzt zenity, um eine Datei auszuwählen (Standardvorwahl ist /etc/motd) und sie anzuzeigen.

Grafische Dateimanager können erweitert werden, um einige populäre Aktionen für ausgewählte Dateien ausführen zu können; dazu müssen eventuell zusätzliche Erweiterunspakete installiert werden. Auch können spezielle eigene Aktionen ausführt werden, indem Sie selbst erstellte Skripte hinzufügen.

Um Prozessdaten zu verarbeiten, muss sh Unterprozesse generieren, um cut, grep, sed usw. aufrufen zu können; und es ist langsam. Auf der anderen Seite enthält perl interne Funktionalitäten zur Verarbeitung von Prozessdaten, und es ist schnell. Daher nutzen viele Wartungsskripte in Debian perl.

Denken wir an folgendes einzeilige AWK-Skript und sein Äquivalent in Perl:

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

Es ist äquivalent zu jeder der folgenden Zeilen:

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

Das letzte ist eine Knobelaufgabe. Es nutzt die Vorteile folgender Perl-Funktionen:

Diese Flexibilität ist die Stärke von Perl. Gleichzeitig erlaubt sie aber auch die Erstellung von kryptischem und verwinkeltem Code. Seien Sie vorsichtig.

Hier ein einfaches Beispiel zum Kompilieren von "example.c" mit der Bibliothek "libm" in eine ausführbare Datei "run_example":

$ 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

Hierbei wird "-lm" benötigt, um die Bibliothek "/usr/lib/libm.so" aus dem libc6-Paket für sqrt(3) zu verlinken. Die eigentliche Bibliothek liegt in "/lib/" und hat den Dateinamen "libm.so.6", was ein symbolischer Link auf "libm-2.7.so" ist.

Schauen Sie sich den letzten Parameter im ausgegebenen Text an. Dort werden mehr als 10 Zeichen ausgegeben, obwohl "%10s" angegeben wurde.

Die Verwendung von Funktionen, die Zeiger auf Speicherbereiche ohne Bereichsüberprüfung nutzen (wie sprintf(3) und strcpy(3)), wird missbilligt, um das Ausnutzen von Pufferüberläufen zu verhindern, die obige Überlaufeffekte in Gang bringen. Verwenden Sie stattdessen snprintf(3) und strncpy(3).

Eine Einführung zu bison(1) finden Sie in "info bison".

Sie müssen Ihre eigenen "main()"- und "yyerror()"-Funktionen bereitstellen. "main()" ruft "yyparse()" auf, das wiederum "yylex()" aufruft, was gewöhnlich von FleX erzeugt wird.

Here is an example to create a simple terminal calculator program.

Let's create 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);
}

Let's create, 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 */ }
%%

Then execute as follows from the shell prompt to try this:

$ 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

Wenn Sie einen Programmabsturz erlitten haben, ist es eine gute Idee, einen Fehlerbericht einzureichen und an diesen zusätzliche Backtrace-Informationen (Daten zur Rückverfolgung von Vorgängen in Programmen zwecks Fehleranalyse) anzuhängen, die Sie mittels Kopieren-und-Einfügen erhalten.

Solche Backtrace-Informationen lassen sich mittels gdb(1) über einen der folgenden Ansätze gewinnen:

Verwenden Sie ldd(1) wie hier, um zu ermitteln, von welchen Bibliotheken ein Programm abhängt:

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

Damit ls(1) in einer "chroot"-Umgebung funktioniert, müssen die obigen Bibliotheken in der "chroot"-Umgebung vorhanden sein.

Wenn ein GNOME-Programm preview1 einen X-Fehler empfangen hat, sollten Sie eine Meldung wie diese sehen:

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

Sollte dies der Fall sein, können Sie versuchen, das Programm mit der Option "--sync" zu starten und einen Haltepunkt für die Funktion "gdk_x_error" zu setzen, um einen Backtrace zu bekommen.

Es gibt verschiedene Werkzeuge zur Erkennung von Speicherlecks in Debian:

Sie können Binär-Code wie folgt mit objdump(1) disassemblieren:

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

	Anmerkung
	gdb(1) kann verwendet werden, um Code interaktiv zu disassemblieren.

Führen Sie "make -p -f/dev/null" aus, um alle internen automatischen Regeln zu sehen.

Das Software-Bausystem hat sich weiterentwickelt: