Capítulo 12. Programação

O comando "echo" tem de ser usado com os seguintes cuidados porque a implementação dele difere entre o integrado na shell e os comandos externos.

	Nota
	Apesar da opção "-n" não ser realmente sintaxe POSIX, geralmente é aceite.

	Dica
	Use o comando "printf" em vez do comando "echo" se precisar de embeber sequências de escape na cadeia de saída.

Parâmetros de shell especiais são frequentemente usados no script shell.

As expansões de parâmetro básicas a lembrar são as seguintes.

Aqui, o símbolo ortográfico dois pontos ":" em todas estas operações é na realidade opcional.

Cada comando retorna um estado de saída que pode ser usado para expressões condicionais.

	Nota
	"0" no contexto condicional da shell significa "Verdadeiro", enquanto "0" no contexto condicional de C significa "Falso".

	Nota
	"[" é o equivalente do comando test, o qual avalia os seus argumentos até ao "]" como uma expressão condicional.

Os idiomas condicionais básicos a lembrar são os seguintes.

if [ conditional_expression ]; then
 if_success_run_this_command
else
 if_not_success_run_this_command
fi

Aqui o "|| true" final foi necessário para assegurar que estes script de shell não termina acidentalmente nesta linha quando a shell é invocada com a flag "-e".

Os operadores de comparação Aritmética de inteiros na expressão regular são "-eq", "-ne", "-lt", "-le", "-gt" e "-ge".

Existem vários idiomas de ciclo para usar na shell POSIX.

	Dica
	A interacção numérica tipo linguagem C pode ser realizada a usar seq(1) como o gerador de "foo1 foo2 …".

	Dica
	Veja Secção 9.4.9, “Repetir um ciclo de comandos sobre ficheiros”.

Some popular environment variables for the normal shell command prompt may not be available under the execution environment of your script.

A shell processa um script rudemente como a seguinte sequência.

Citações singulares (') dentro de aspas não têm efeito.

Executar "set -x" na shell ou invocar a shell com a opção "-x" faz a shell escrever todos os comandos executados. Isto é muito útil para depuração.

De modo a tornar o seu programa de shell o mais portável possível entre os sistemas Debian, é uma boa ideia limitar os programas utilitários àqueles disponibilizados pelos pacotes essenciais.

Most interpreters offer basic syntax check and code tracing functionalities.

The shell script can be improved to create an attractive GUI program. The trick is to use one of so-called dialog programs instead of dull interaction using echo and read commands.

Here is an example of GUI program to demonstrate how easy it is just with a shell script.

This script uses zenity to select a file (default /etc/motd) and display it.

GUI filer programs can be extended to perform some popular actions on selected files using additional extension packages. They can also made to perform very specific custom actions by adding your specific scripts.

In order to process data, sh needs to spawn sub-process running cut, grep, sed, etc., and is slow. On the other hand, perl has internal capabilities to process data, and is fast. So many system maintenance scripts on Debian use perl.

Let's think following one-liner AWK script snippet and its equivalents in Perl.

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

Isto é equivalente a qualquer uma das seguintes linhas.

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

Este último é um enigma. Aproveitei-me das seguintes funcionalidades do Perl.

This flexibility is the strength of Perl. At the same time, this allows us to create cryptic and tangled codes. So be careful.

Um simples exemplo, "example.c" pode ser compilado com uma biblioteca "libm" num executável "run_example" com o seguinte.

$ 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

Aqui, o "-lm" é necessário para ligar a biblioteca "/usr/lib/libm.so" do pacote libc6 para o sqrt(3). A biblioteca real está em "/lib/" com o nome de ficheiro "libm.so.6", o qual é uma ligação simbólica para "libm-2.7.so".

Olhe ao último parâmetro no texto resultante. Existem mais de 10 caracteres mesmo com "%10s" especificado.

O uso de funções de operação de memória de ponteiro sem verificações de limites como em sprintf(3) e strcpy(3), está descontinuado para prevenir exploits de sobrelotação do buffer que influenciam os efeitos de transbordo em cima. Em vez disso, use snprintf(3) e strncpy(3).

O tutorial para o bison(1) encontra-se em "info bison".

Tem de disponibilizar as suas próprias chamadas "main()" e "yyerror()". "main()" chama "yyparse()" que chama "yylex()", geralmente criada com Flex.

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

Quando encontrar um crash num programa, é uma boa ideia enviar um relatório de bug com informação de backtrace copiada-e-colada.

The backtrace can be obtained by gdb(1) using one of the following approaches:

Use o ldd(1) para encontrar uma dependência de um programa em bibliotecas com o seguinte.

$ 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 o ls(1) funcione num ambiente 'chroot', as bibliotecas em cima têm de estar disponíveis no seu ambiente 'chroot'.

Se o programa do GNOME preview1 recebeu um erro do X, deverá ver a mensagem que a seguir.

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

Neste caso, pode tentar correr o programa com "--sync" e quebrar a função "gdk_x_error" de modo a obter um backtrace.

Aqui estão várias ferramentas de detecção de fugas de memória em Debian.

Pode desassemblar código binário com o objdump(1) com o seguinte.

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

	Nota
	O gdb(1) pode ser usado para desmontar (desassemblar) código interativamente.

Corra "make -p -f/dev/null" para ver as regras internas automáticas.

The software build system has been evolving: