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”.

Algumas variáveis de ambiente populares para a linha de comandos normal da shell podem não estar disponíveis no ambiente de execução do seu 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.

A maioria dos intérpretes oferece funcionalidades básicas de verificação da sintaxe e de rastreio do código.

O script shell pode ser melhorado para criar um programa GUI atrativo. O truque é usar um dos chamados programas de diálogo em vez de uma interação monótona usando comandos echo e read.

Aqui está um exemplo de um programa GUI para demonstrar como é fácil apenas com um script de shell.

Este script usa zenity para selecionar um ficheiro (por defeito /etc/motd) e mostrá-lo.

Os programas de arquivamento GUI podem ser alargados para executar algumas ações populares em ficheiros selecionados utilizando pacotes de extensão adicionais. Também podem ser feitos para executar ações personalizadas muito específicas, adicionando os seus scripts específicos.

Para processar dados, sh precisa gerar sub-processos executando cut, grep, sed, etc., e é lento. Por outro lado, o perl tem capacidades internas para processar dados, e é rápido. Por isso muitos scripts de manutenção do sistema na Debian usam perl.

Vamos pensar no seguinte trecho de script AWK de uma linha e seus equivalentes em 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.

Esta flexibilidade é o ponto forte do Perl. Ao mesmo tempo, isto permite-nos criar códigos crípticos e emaranhados. Por isso, é preciso ter cuidado.

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.

Aqui está um exemplo para criar um programa simples de calculadora de terminal.

Vamos criar 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 criar, 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 */ }
%%

Em seguida, execute o seguinte a partir do prompt do shell para tentar isso:

$ 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 uma falha num programa, é uma boa ideia enviar um relatório de bug com informação de rastreio copiada-e-colada.

O backtrace pode ser obtido pelo gdb(1) utilizando uma das seguintes abordagens:

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.

O sistema de construção de software tem vindo a evoluir: