Kapitel 12. Programmering

De flesta tolkar erbjuder grundläggande funktioner för syntaxkontroll och kodspårning.

Shell-skriptet kan förbättras för att skapa ett attraktivt GUI-program. Tricket är att använda något av de s.k. dialogprogrammen istället för tråkig interaktion med echo och read-kommandon.

Här är ett exempel på ett GUI-program som visar hur enkelt det är att bara använda ett skalskript.

Detta skript använder zenity för att välja en fil (standard /etc/motd) och visa den.

GUI-filprogram kan utökas för att utföra vissa populära åtgärder på utvalda filer med hjälp av ytterligare tilläggspaket. De kan också göras för att utföra mycket specifika anpassade åtgärder genom att lägga till dina specifika skript.

För att bearbeta data måste sh skapa underprocesser som kör cut, grep, sed, etc. och är långsamma. Å andra sidan har perl interna funktioner för att bearbeta data och är snabb. Så många systemunderhållsskript på Debian använder perl.

Låt oss tänka på följande one-liner AWK-skriptutdrag och dess motsvarigheter i Perl.

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

Detta är likvärdigt med någon av följande rader.

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

Den sista är en gåta. Den utnyttjade följande Perl-funktioner.

Denna flexibilitet är styrkan i Perl. Samtidigt gör det att vi kan skapa kryptiska och trassliga koder. Så var försiktig.

Ett enkelt exempel ".c" kan kompileras med ett bibliotek "libm" till en körbar fil "run_example" på följande sätt.

$ 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

Här behövs "-lm" för att länka biblioteket "/usr/lib/libm.so" från libc6-paketet för sqrt(3). Det faktiska biblioteket finns i "/lib/" med filnamnet "libm.so.6", som är en symlänk till "libm-2.7.so".

Titta på den sista parametern i utdatatexten. Det finns mer än 10 tecken trots att "%10s" har angetts.

Användningen av funktioner för pekarminnesoperationer utan gränskontroller, t.ex. sprintf(3) och strcpy(3), avråds för att förhindra buffer overflow-exploateringar som utnyttjar ovanstående överskridningseffekter. Använd istället snprintf(3) och strncpy(3).

Handledning för bison(1) finns i "info bison".

Du måste tillhandahålla dina egna "main()" och "yyerror()". "main()"anropar "yyparse()" som anropar "yylex()", vanligtvis skapat med Flex.

Här följer ett exempel på hur du skapar ett enkelt kalkylatorprogram för terminalen.

Låt oss skapa exempel.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);
}

Låt oss skapa, exempel.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 */ }
%%

Kör sedan följande från shellprompten för att prova detta:

$ 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

När du stöter på programkrasch är det en bra idé att rapportera felrapport med klippt och klistrat backtrace-information.

Bakspårningen kan hämtas av gdb(1) med hjälp av något av följande tillvägagångssätt:

Använd ldd(1) för att ta reda på hur beroende ett program är av bibliotek enligt följande.

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

För att ls(1) ska fungera i en `chroot`-miljö måste ovanstående bibliotek finnas tillgängliga i din `chroot`-miljö.

Om ett GNOME-program preview1 har fått ett X-fel, bör du se ett meddelande enligt följande.

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

Om så är fallet kan du prova att köra programmet med "--sync" och bryta på funktionen "gdk_x_error" för att få en backtrace.

Det finns flera verktyg för att upptäcka minnesläckor i Debian.

Du kan demontera binär kod med objdump(1) på följande sätt.

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

	Notera
	gdb(1) kan användas för att plocka isär kod interaktivt.

Kör "make -p -f/dev/null" för att se automatiska interna regler.

Systemet för programvaruutveckling har utvecklats: