113. Um pouco de programação

113.1 Roteiros para Shell: Arquivos .BAT com Esteróides

Se você usava arquivos .BAT para criar atalhos para longas linhas de comando (eu usei muito), pode fazer isso inserindo linhas de apelido apropriadas (veja exemplo acima) em profile ou .profile. Mas, se seus .BATs eram mais complicados, você vai adorar a linguagem de roteiros do interpretador de comandos: é tão poderosa quanto QBasic, se não for mais. Tem variáveis, estruturas como while, for, case, if... then... else, e vários outros recursos: pode ser uma boa alternativa a uma linguagem de programação "de verdade".

Para escrever um roteiro---o equivalente a um arquivo .BAT no DOS---tudo o --> --que você tem a fazer é escrever um arquivo ASCII contendo as instruções, --> --gravá-lo, e torná-lo executável com o comando chmod +x --> --<scriptfile>. Para executá-lo, digite o nome do arquivo.

Um aviso: o editor do sistema chama-se vi, e na minha experiência a maioria dos novos usuários acha-o muito difícil de usar. Eu não vou explicar como usá-lo, porque eu não gosto do vi e não o uso. Aqui basta dizer que:

• para inserir texto, digite `i' e depois o seu texto;
• para apagar caracteres, digite <ESC> e depois `x';
• para sair do vi sem salvar, digite <ESC> e depois :q!
• para salvar e sair, digite <ESC> e depois :wq.

Um bom editor para iniciantes é o joe: executando-o como jstar, você obterá as mesmas associações de teclas que o editor do DOS. jed no modo WordStar ou IDE é melhor ainda. Consulte a Seção Onde Encontrar Aplicativos para saber onde pegar esses editores.

Escrever roteiros do bash é um assunto tão vasto que preencheria um livro, e eu não me aprofundarei mais nesse tópico. Eu só darei um exemplo de script de shell, do qual você poderá extrair algumas regras básicas:

#!/bin/sh
# sample.sh
# Isto é um comentário
# não mude a primeira linha, ela precisa estar lá
echo "O sistema é: `uname -a`" # usa a saída do comando
echo "Meu nome é $0" # variáveis embutidas
echo "Você me deu os seguintes $# parâmetros: "$*
echo "O primeiro parâmetro: "$1
echo -n "Como você se chama? " ; read seu_nome
echo note a diferença: "oi $your_name" # quotando com "
echo note a diferença: 'oi $your_name' # quotando com '
DIRS=0 ; ARQS=0
for arquivo in `ls .` ; do
  if [ -d ${arquivo} ] ; then  # se arquivo for um diretório
    DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1
  elif [ -f ${arquivo} ] ; then
    ARQS=`expr $ARQS + 1`
  fi
  case ${arquivo} in
    *.gif|*jpg) echo "${arquivo}: arquivo gráfico" ;;
    *.txt|*.tex) echo "${arquivo}: arquivo texto" ;;
    *.c|*.f|*.for) echo "${arquivo}: arquivo fonte" ;;
    *) echo "${arquivo}: arquivo genérico" ;;
  esac
done
echo "há ${DIRS} diretórios e ${ARQS} arquivos"
ls | grep "ZxY--!!!WKW"
if [ $? != 0 ] ; then # código de saída do último comando
  echo "ZxY--!!!WKW não encontrado"
fi
echo "pront... digite 'man bash' se você quiser mais informações."

113.2 C

No UNIX, a linguagem do sistema é C, quer queira, quer não. Muitas outras linguagens (Java, FORTRAN, Pascal, Lisp, Basic, Perl, awk...) também estão disponíveis.

Pressupondo que você conhece C, aqui estão algumas diretrizes para vocês que foram "estragados" pelo Turbo C++ ou algum outro do DOS. O compilador C do Linux se chama gcc, e não tem todas aquelas "frescuras" que normalmente acompanham suas contrapartidas do DOS: não há IDE (ambiente integrado de desenvolvimento), ajuda on-line, depurador integrado, etc. É apenas um seco compilador de linha de comando, muito poderoso e eficiente. Para compilar seu hello.c padrão, você deve digitar:

$ gcc hello.c

que criará um arquivo executável chamado a.out. Para dar um nome diferente ao executável, faça

$ gcc -o hola hello.c

Para vincular uma biblioteca ao programa, adicione a opção -l<libname>. Por exemplo, para vincular a biblioteca matemática:

$ gcc -o progmat progmat.c -lm

(A opção -l<libname> força o gcc a vincular a biblioteca /usr/lib/lib<libname>.a; então -lm vincula /usr/lib/libm.a).

Até aqui, tudo bem. Mas, se seu programa for composto de vários arquivos fontes, você terá que usar o utilitário make. Suponha que você tenha escrito um analisador de expressões: seu arquivo fonte se chama parser.c e #inclui dois arquivos header, parser.h e xy.h. Depois você quer usar rotinas de parser.c em um programa, digamos, calc.c, que por sua vez #inclui parser.h. Que bagunça! O que você tem que fazer para compilar calc.c?

Você terá que escrever um arquivo chamado makefile, que diz ao compilador quais as dependências entre os arquivos fontes e objetos. No nosso exemplo:

# Isto é um makefile, usado para compilar calc.c
# Pressione a tecla <TAB> onde indicado!

calc: calc.o parser.o
<TAB>gcc -o calc calc.o parser.o -lm
# calc depende de dois arquivos objeto: calc.o e parser.o

calc.o: calc.c parser.h
<TAB>gcc -c calc.c
# calc.o depende de dois arquivos fonte

parser.o:  parser.c parser.h xy.h
<TAB>gcc -c parser.c
# parser.o depende de três arquivos fonte

# fim do makefile.

Salve este arquivo como Makefile e digite make para compilar seu programa; ou salve como calc.mak, digite make -f calc.mak e, é claro, LPM. Você pode conseguir ajuda sobre funções C, que são cobertas pela seção 3 das páginas de manual; por exemplo,

$ man 3 printf

Para depurar seus programas, use gdb. info gdb para aprender a usá-lo.

Há várias bibliotecas disponíveis; entre as primeiras que você vai querer usar estão ncurses, para lidar com modo texto, e svgalib, para modo gráfico. Se você se sentir-se corajoso o suficiente para abordar programação em X11, há bibliotecas como XForms, Qt, Gtk e muitas outras, que tornam a programação em X11 uma moleza. Dê uma olhada em http://www.xnet.com/~blatura/linapp6.html .

Muitos editores podem funcionar como um IDE; emacs e jed, por exemplo, também permitem coloração por sintaxe, identação automática e assim por diante. Alternativamente, pegue o pacote rhide de ftp://sunsite.unc.edu:/pub/Linux/devel/debuggers/. É um clone do IDE Borland, e é provável que você goste.