Posts com a tag: bash
The shell is completely wrong
2013-01-04 13:56 -0200. Tags: comp, prog, bash, unix, wrong, rant, em-portugues
![[Foto de John McCarthy com a legenda 'Programming: You're doing it completely wrong']](img/doing-it-wrong-small.jpg "A dificuldade que foi fazer esse layout funcionar é digna de post próprio")
Reading and splitting
2012-12-31 13:39 -0200. Tags: comp, prog, bash, em-portugues
Durante os últimos 354 anos eu estive splitando linhas em bash assim:
line="root:x:0:0:root:/root:/bin/bash"
IFS=":"
set -- $line
echo "$1" # root
echo "$7" # /bin/bash
# ou:
IFS=":"
fields=($line)
echo "${fields[0]}" # root
echo "${fields[6]}" # /bin/bash
Turns out que faz 354 anos que eu estou fazendo isso errado.
Acontece que expansão de parâmetros (i.e., $var) fora de aspas duplas não só causa word splitting (que é o que queremos), mas também causa pathname expansion (substituição de *, ?, ~ e afins pelos nomes de arquivo que casam com o padrão):
cd /
line='a*:b*:c*'
IFS=":"
fields=($line)
echo "${fields[0]}" # a*
echo "${fields[1]}" # bin
echo "${fields[2]}" # boot
echo "${fields[3]}" # c*
Esse problema nunca me ocorreu na prática, mas me dei conta disso depois de escrever o post sobre manipulação de strings em bash. O pior é que eu já sabia há muito tempo que variáveis fora das aspas sofrem pathname expansion, mas acho que adquiri o hábito de splitar strings assim antes de saber disso. Uma solução correta é usar o comando IFS=delimitadores read -a arrayname (que lê uma linha com campos separados por delimitadores e coloca os pedaços na variável arrayname) em conjunto com o operador <<<string (que alimenta a stdin do comando com a string):
line='a*:b*:c*'
IFS=":" read -a fields <<<"$line"
echo "${fields[0]}" # a*
echo "${fields[1]}" # b*
echo "${fields[2]}" # c*
De brinde agora é possível incluir : em um campo usando a seqüência \:, já que o read entende o \ como um indicador de que o próximo caractere deve ser interpretado literalmente (a menos que a opção -r (de raw) seja usada).
O último exemplo de splitting do post anterior (que procura o nome do shell de um usuário no /etc/passwd) ficaria assim:
#!/bin/bash
user="$1"
IFS=":"
while read -a campos line; do
if [ "${campos[0]}" = "$user" ]; then
echo "${campos[6]}"
fi
done </etc/passwd
Outra feature interessante do read é a opção -d, que permite especificar um caractere diferente de \n como terminador de linha. Isso é útil, por exemplo, em conjunto com o find -print0, que imprime os nomes dos arquivos separados pelo caractere \0 (ASCII NUL) ao invés de \n:
find . -name '*.bkp' -print0 | while IFS= read -d $'\0' file; do
echo "Arquivo $file será renomeado."
mv "$file" "${file%.bkp}~"
done
Isso garante que o script vai funcionar mesmo que o nome de algum arquivo contenha quebras de linha, o que faz com que o script não seja vulnerável ao usuário malandro que criar um arquivo chamado foo\n/bin/bash\nbar.bkp em seu home.
Manipulando strings em bash
2012-12-27 02:49 -0200. Tags: comp, prog, bash, em-portugues
Seguindo uma sugestão indireta, eis um post sobre as funções básicas de manipulação de strings do bash.
Antes de mais nada, gostaria de citar uma frase do manual do INTERCAL que me parece apropriada a respeito do bash:
Please be kind to our operators: they may not be very intelligent, but they're all we've got.
Dito isto, vamos ao ponto.
Parameter substitution
Como toda linguagem normal, bash possui variáveis.
person="Elmord" echo "$person's Magic Valley"
A sintaxe $nome invoca o que se chama de parameter expansion. 'Parâmetro' é um termo mais geral que 'variável' em bash, e inclui variáveis, argumentos recebidos por um script ou função ($1, $2, ...), e alguns valores especiais mantidos pelo bash (e.g., $$ (PID do shell), $* (todos os argumentos do script/função em uma string só), etc.). Em bash, todos os parâmetros são strings (ou quase: $*, $@ e aparentados são meio indecisos sobre se são strings ou arrays de strings).
$nome pode ser escrito como ${nome}. Isso é útil quando se deseja isolar o nome do parâmetro de uma string adjacente que poderia ser interpretada como parte do nome:
animal="Raposa"
echo "${animal}s não dão dinheiro."
Além disso, essa sintaxe estendida permite especificar modificações sobre o valor a ser retornado pela expansão. Entre as modificações mais usadas estão as remoções de prefixos e sufixos:
- ${nome#pattern}: Remove o menor prefixo que case com pattern
- ${nome##pattern}: Remove o maior prefixo que case com pattern
- ${nome%pattern}: Remove o menor sufixo que case com pattern
- ${nome%%pattern}: Remove o maior sufixo que case com pattern
(Mnemônico: # fica à esquerda (prefixo) de $ no teclado, % à direita (sufixo) de $.)
Por exemplo:
file="arquivo.feliz.html"
echo "$file" # arquivo.feliz.html
echo "${file%.*}" # arquivo.feliz (remove o menor sufixo do tipo .*, i.e., do último ponto em diante)
echo "${file##*.}" # html (remove o maior prefixo do tipo *., i.e., do começo até o último ponto)
echo "${file%%.*}" # arquivo (remove tudo do primeiro ponto em diante)
echo "${file#*.}" # feliz.html (remove apenas até o primeiro ponto)
Exemplo levemente mais elaborado:
path="foo/bar/baz/quux/hack"
echo "${path%/*}" # foo/bar/baz/quux
echo "${path%/*/*}" # foo/bar/baz
echo "${path%/*/*/*}" # foo/bar
echo "${path%/*/*/*/*}" # foo
echo "${path%/*/*/*/*/*}" # foo/bar/baz/quux/hack
No primeiro echo, removemos apenas o último componente do caminho. No segundo, removemos o menor sufixo que casa com /*/*, i.e., que consiste de uma barra, seguida por qualquer coisa (inclusive nada), seguido por outra barra, seguida por qualquer coisa (inclusive nada), o que resulta na eliminação dos dois últimos componentes do caminho. No último comando, o pattern não casa com nada (não há cinco barras na string), e portanto o resultado é o valor de path intacto. (Note que isso funciona porque estamos removendo o menor sufixo, com o operador % simples. Se usássemos o operador %% (i.e., ${path%%/*}, etc.) ficaríamos apenas com foo em todos os casos exceto o último.)
E se ao invés de remover os dois últimos componentes, quiséssemos ficar com apenas os dois últimos componentes? Infelizmente não existe um operador para remover o "segundo maior prefixo" que case com */. Uma maneira de conseguir isso é fazer a operação em dois passos:
path="foo/bar/baz/quux/hack"
prefix="${path%/*/*}" # coloca "foo/bar/baz" em prefix
echo "${path#"$prefix"}" # remove "foo/bar/baz" do começo de $path, deixando "/quux/hack"; ou
echo "${path#"$prefix/"}" # remove "foo/bar/baz/" do começo de $path, deixando "quux/hack"
Ou, de maneira mais abreviada (e talvez menos legível):
echo "${path#"${path%/*/*}"}"
Note as aspas ao redor da sub-expressão (${path#"prefix"}). Elas são necessárias porque o valor de $prefix poderia conter caracteres como *, que seriam interpretados como wildcards se não houvesse aspas.
Os wildcards que podem aparecer nas patterns são os mesmos que podem ser usados com nomes de arquivos: * (zero ou mais caracteres quaisquer), ? (um caractere qualquer), [abcde] (qualquer um dos caracteres listados; ranges do tipo A-Z, bem como classes de caracteres do tipo [:digit:], podem ser incluídos na lista), [^abcde] (qualquer caractere não listado). Se a opção shopt -s extglob estiver ativa, patterns estendidas também são aceitas, mas isso é assunto para outro post.
Outro tipo de modificação útil são as substituições de substrings:
- ${nome/pattern/string}: substitui a primeira ocorrência de pattern por string;
- ${nome//pattern/string}: substitui todas as ocorrências de pattern por string;
- ${nome/#pattern/string}: substitui uma ocorrência de pattern por string, desde que pattern ocorra no início de $nome;
- ${nome/%pattern/string}: substitui uma ocorrência de pattern por string, desde que pattern ocorra no fim de $nome.
A pattern de substituição sempre casa com a maior ocorrência (i.e., se x="foo.bar.baz.quux.hack", ${x/.*./BOOM} expande para fooBOOMhack). Aparentemente não há um meio de substituir o menor prefixo/sufixo. Go figure.
Outra modificação útil é o slicing: ${nome:início:tamanho} seleciona tamanho caracteres de $nome, começando pelo início-ésimo (contando do zero). início e tamanho são expressões aritméticas; portanto, nomes de variáveis podem ser usados sem $, e operações aritméticas podem ser realizadas diretamente, sem necessidade de usar a sintaxe usual para expansão aritmética ($((expressão))):
x="foobarbazquux"
echo "${x:6:3}" # baz
n=6
echo "${x:n:n/2}" # baz
Se tamanho for omitido, o trecho de início até o final da string é usado. Se início for negativo, conta-se a partir do final da string:
echo "${x:(-4):1}" # q
echo "${x:(-4)}" # quux
(Note que o - deve ser separado do : que o precede (com parênteses ou espaços, por exemplo), pois ${nome:-string} significa algo completamente diferente em bash (usa o valor de $nome, ou string se $nome for vazio).)
Se um índice negativo indicar uma posição antes do começo da string, o resultado é a string vazia. (Por quê? Por quê?)
${#nome} devolve o comprimento de $nome. Há outras modificações; para mais informações, procure por Parameter Expansion na manpage do bash.
Separando em pedacinhos
Uma operação comum sobre strings é separá-la em diversos componentes segundo algum caractere separador. Essa operação existe em diversas linguagens sob o nome de split. Por exemplo, em JavaScript:
js> x = "foo bar baz"
"foo bar baz"
js> partes = x.split(" ")
["foo", "bar", "baz"]
js> partes[1]
"bar"
(By the way: já experimentou dar Ctrl-Shift-K no Firefox?)
Bash é uma linguagem muito hábil em separar strings. Por sinal, bash é hábil demais em separar strings: qualquer parâmetro não envolto em aspas está sujeito ao infame word splitting: o valor resultante da expansão do parâmetro é separado em múltiplas "palavras", e cada palavra é tratada como um argumento separado. Por exemplo:
$ file="nome com espaços" $ ls "$file" ls: cannot access nome com espaços: No such file or directory $ ls $file ls: cannot access nome: No such file or directory ls: cannot access com: No such file or directory ls: cannot access espaços: No such file or directory
Isso significa que você deve colocar aspas maniacamente em torno de qualquer string com variáveis que você não quer que sejam splitadas. Isso também significa que você pode se aproveitar dessa feature para obter os pedacinhos individuais de uma string. Uma maneira de fazer isso é criando um array com o resultado da expansão:
partes=($file)
echo "${partes[0]}" # nome
echo "${partes[1]}" # com
echo "${partes[2]}" # espaços
echo "${#partes[@]}" # 3 (comprimento do array)
Outra maneira é substituir os argumentos posicionais do shell pelo resultado da expansão:
set -- $file echo "$1" # nome echo "$2" # com echo "$3" # espaços echo "$#" # 3O que define uma "palavra" são os separadores contidos na variável IFS (internal field separator): essa variável contém todos os caracteres que são considerados separadores. Por padrão, os separadores são espaços, tabs e newlines. Você pode setar essa variável para quaisquer outros caracteres, e remover a variável (com unset IFS) para restaurar os separadores originais. Por exemplo, se quiséssemos escrever um script para procurar no arquivo /etc/passwd (cujos campos são separados por :) o nome do shell de um determinado usuário, poderíamos fazer assim:
#!/bin/bash
user="$1"
IFS=":"
while read line; do
campos=($line)
if [ "${campos[0]}" = "$user" ]; then
echo "${campos[6]}"
fi
done </etc/passwd
Update: Há uma solução melhor.
Matching
Às vezes queremos saber se uma string casa com um determinado padrão. A maneira mais comum de se fazer isso é através do comando case:
case "$file" in
*.txt)
echo "É um arquivo de texto."
cat "$file"
;;
*.gif|*.jpg|*.png)
echo "É uma figurinha."
xloadimage "$file"
;;
*)
echo "Que que é isso, medeus?"
;;
esac
Cada cláusula do case começa com uma pattern, seguida de ). Os tipo de pattern aceitos são os mesmos usados para expansão de nomes de arquivos e para remoções de prefixo/sufixo e outras substituições de string. Cada cláusula é terminada com ;;. (O ;; na última cláusula é opcional.) Múltiplas patterns, separadas por |, podem ser especificadas.
As patterns do shell são um tanto quanto limitadas, o que exige uma certa dose de treta na hora de usá-las. Por exemplo, imagine que queiramos fazer um script que exige um número como argumento, e queremos que o script teste se o argumento foi passado corretamente. Não temos como especificar uma pattern que diga que apenas números são aceitos. A solução é especificar que se o argumento contiver algum caractere que não seja um número, o script deve emitir um erro:
case "$1" in
*[^0-9]*)
echo "Erro: argumento deve ser um número."
exit 1
;;
*)
echo "Eis um número: $1."
;;
esac
Parece bom? Quase: se uma string vazia for passada, nenhum dos caracteres que a compõem casa com [^0-9], e portanto a primeira pattern não casa, e portanto caímos na segunda cláusula do case, embora o argumento passado não seja um número. Para resolver esse problema, temos que incluir a string vazia na primeira cláusula:
case "$1" in
*[^0-9]*|)
echo "Erro: argumento deve ser um número."
exit 1
;;
*)
echo "Eis um número: $1"
;;
esac
Comandos externos
Até agora utilizamos apenas recursos internos do shell. Mas temos também à disposição a vasta gama de comandos de manipulação de texto do Unix, tais como cut, sed e tr. Se quisermos alimentar um desses comandos com o conteúdo de uma variável, podemos usar o comando echo em uma pipeline, e capturar o resultado com a sintaxe $(comando):
dmy="27/05/1990" ymd="$(echo "$dmy" | sed -re 's,(..)/(..)/(....),\3-\2-\1,')" echo "$ymd" # 1990-05-27
A partir do bash 3, é possível alimentar a entrada padrão de um comando com uma string através da sintaxe comando <<<string:
ymd="$(sed -re 's,(..)/(..)/(....),\3-\2-\1,' <<<"$dmy")"
Outras features
Este post não cobre todas as features de manipulação de strings no bash. (Em particular, faltou cobrir o comando [[ expressão ]] e suas habilidades com expressões regulares, as quais eu ainda não experimentei direito.) Para mais informações, dê uma olhada na manpage do bash. Sinta-se à vontade para acrescentar outras mandingas ou fazer perguntas nos comentários.
The googling people
2012-11-08 21:58 -0200. Tags: about, comp, bash, random, em-portugues
Pois ao invés de fazer alguma coisa útil com a vida, resolvi fazer uma análise dos termos de busca usados pelo povo que cai neste blog via Google. Primeiro alguns números:
- Desde 13 de abril de 2012, houve 11804 acessos ao blog a partir do Google.
- Destes, 3036 não indicam a string de busca; suponho que isso seja uma configuração de privacidade do Google.
- Dos 8768 restantes, 8137 (92.8%) são pesquisas pelos horários dos TM{1,2,3}.
- Outros assuntos freqüentemente procurados:
- Pesquisas sobre um jogo chamado Magic Valley que aparentemente surgiu por volta de julho, 105 buscas;
- Busybox, 59 buscas;
- VLC como root, 46 buscas;
- Sucker Punch, 26 buscas (normalmente na forma "qual o nome do filme em que ...");
- Pesquisas sobre aluguel e morar sozinho, 25 buscas;
- Inverter cores, 24 buscas;
- Lisp, 23 buscas;
- Democracia direta, 22 buscas;
- Esperanto, 9 buscas;
- Povo perguntando por que não logar como root, e que foram levados para o mau caminho, 4 buscas;
Muitas das buscas são em forma de perguntas. Seguem algumas respostas e observações:
- c como guardar o descritor da funçao open numa estrutura
- Da mesma maneira como se guarda o descritor fora da estrutura: em um int.
- Para que serve o quote (‘) quando colocado em frente a algo como um símbolo em Lisp?
- Dada a inicial maiúscula e o fato de que o "quote" não é um quote de verdade ('), assumo que isso seja pergunta de exercício. O fato de ainda se usar Lisp em algum curso me surpreende. De qualquer forma, o quote serve para indicar que a próxima expressão não deve ser avaliada, e sim tomada como um dado literal (x se refere à variável x, 'x é um símbolo; (+ 2 3) é 5, '(+ 2 3) é uma lista de três elementos).
- QUAL PROCESSADOR AQUECE MENOS
- O desligado.
- Usando fork() e exec():Faça um programa usando as chamadas de sistema fork() e exec() que produza as seguintes seqüências de ações:a.O processo pai deve criar um único processo filho. O filho será substituído pelo processo more ou cat.b.O parâmetro passado para o programa more ou cat deverá ser o nome do arquivo fonte do exercício. Por exemplo: "executa.c"
- Whoa, uma abordagem totalmente nova para resolver exercícios. Vou lembrar disso para momentos apropriados.
- alguma comando do prompt que aumente o tamanho dos caracteres
- No xterm, Shift-<+ do keypad numérico>. No gnome-terminal, acho que só nas Preferências.
Surpreendentemente, existe uma seqüência ESC para trocar a fonte do xterm, desde que o recurso XTerm*allowFontOps: true esteja setado:
printf '\e]50;?\a' # Descobre a fonte atual printf '\e]50;nome-da-fonte\a' # Muda a fonte atual printf '\e]50;#N\a' # Seleciona a fonte N da lista de fontes padrão do xterm printf '\e]50;#+N\a' # Escolhe a próxima N-ésima fonte printf '\e]50;#-N\a' # Escolhe a N-ésima fonte anterior
Só de ter descoberto isso já valeu ter escrito este post.
- alterando strings bash
- Digno de post futuro.
- como acalmar o processador
- Cante uma música para ele.
- konsole mudou sozinho para "u@h:w$"
- Chute: o shell padrão mudou do bash para o sh.
- linguagem de programação mais ineficiente
- Máquina de Turing.
- listar inodes com 2 hard links
- find . -links 2
- nao estou me fazendo de vitima
- Será?
- now write about yourself
- Say 'please'.
- o que vai morar de pois do fim do mundo
- Não sei se entendi, mas essas pausas dramáticas me deixaram até com medo.
- o que acontece se eu criar um programa que chame o método fork() várias vezes seguidas, após cada fork, imprima o pid do processo e de seu pai.
- Não tem resposta! [atira o leite de unicórnio de duas cabeças longe]
- o que significa os 7 simbolos na palavra coexist
- Huh...
- oq é oq é muito dificil de descobrir
- Eu sei, mas não conto pra ninguém.
- os maias usavam o calendario para que?
- Para datar eventos históricos e para trollar europeus.
- passar conteudo variavel para outra prompt
- Essa é interessante. Um jeito é usar o comando declare -p var, que imprime um comando que, quando executado, recria a variável var com o mesmo conteúdo. Podemos tentar automatizar a tarefa criando algumas funções e adicionando-as ao ~/.bashrc. O problema é que o comando declare cria variáveis locais, e conseqüentemente elas deixam de existir depois do término da função. É possível simplesmente remover os "declare" iniciais da saída do declare -p, mas com isso declarações de array não funcionam. Talvez o negócio seja implementar na mão mesmo:
VARDIR="$HOME/.vars" [[ -d $VARDIR ]] || mkdir "$VARDIR" save() { local __var __i __indexes __ref; for __var; do eval "__indexes=(\${!$__var[*]})" { echo "unset $__var" for __i in "${__indexes[@]}"; do __ref="$__var[$__i]" printf "%s[%d]=%q\n" "$__var" "$__i" "${!__ref}" done } >"$HOME/.vars/$__var" done } load() { local __var; for __var; do . "$VARDIR/$__var" done }The horror, the horror.
- qual a diferença entre prompt string 1 e prompt string 2
- PS1 é o prompt comum. PS2 é o prompt usado quando você digita um comando incompleto e o bash espera pela continuação; normalmente, o PS2 é > .
- qual o melhor 3g em viamao?
- Para o preço pelo qual é oferecido, o Oi pré-pago até que não é ruim (R$ 9,80 por mês). O da Tim é inutilizável. Vivo e Claro não tenho dados.
- qual é o padrao de numero de recarga tim
- Coméqueé?
- quando se aluga taxa de iptu paga mensalmente
- Não. É possível parcelar, da mesma maneira como o IPTU de casa própria, mas o valor do IPTU não tem ligação com o valor do aluguel (pelo menos no meu caso não teve).
- quem paga a taxa de incendio no mesmo quintal
- Taxa de incêndio é por imóvel, e é cobrada como uma percentagem sobre o valor do aluguel. Não faz diferença (que me conste) se há mais imóveis no mesmo terreno.
- quer morar onde?
- Reykjavík, mas só por um tempo.
- unix saber quando hostname foi alterado
- Meu deus, o que é que o(a) senhor(a) está fazendo?
- vitor de araujo inf ufrgs etapa
- Quem diabos procurou isto?
Não achei nenhuma pérola do nível de "blog de gente se explicando", todavia...
RU for you
2012-11-08 08:42 -0200. Tags: comp, prog, bash, em-portugues
Coisas que acontecem em noites insones:
![[Screenshot de script que exibe o cardápio do RU]](img/ru-screenshot.png "Tudo isso pra descobrir que vai ter lentilha... :(")
O código está tenebroso, e provavelmente explode dependendo de variações de humor do HTML da página do cardápio do RU, mas é o que temos no momento. Divirta-se.
Log de papers
2012-10-21 05:36 -0200. Tags: comp, prog, bash, em-portugues
Não estou muito inspirado para escrever em língua de pessoas hoje. O que eu tenho para dizer é que acabei de escrever em língua de máquinas um pequeno script que supre (parcialmente) uma necessidade que eu tenho há um bom tempo: um log de papers. (Vejam vocês, minha falta de vida social é de tal magnitude que eu passo uma parte razoável do meu tempo livre lendo papers.)
A idéia é simples: ao invés de mandar o Firefox abrir arquivos PDF e PS com o Evince (ou qualquer que seja o visualizador de sua preferência), você o instrui a abri-lo com esse script (lembre-se de dar permissão de execução ao arquivo (chmod +x /blabla/evince-log.sh)). O script então extrai o título e o abstract do texto do PDF/PS, rouba a URL de onde o arquivo foi baixado de dentro do downloads.sqlite do Firefox, e grava essas informações em um arquivo ~/evince-log.txt. Não é lá grande coisa, mas pelo menos é mais provável que daqui a um ano eu consiga encontrar os papers que eu li hoje quando eu precisar deles.
O script requer (no Debian) os pacotes sqlite3 (para ler o log de downloads do Firefox), poppler-tools (que contém o pdftotext) e ghostscript (que contém o ps2txt). Se você executar o script sem parâmetros, ele lhe dirá se algum desses programas estiver faltando.
Disclaimer: O "algoritmo" para extrair o título e o abstract são uma baita de uma faconice; o resultado é vagamente correto, mas suficiente para os meus propósitos por ora. Considere o "abstract" como uma amostra do início do paper para facilitar a identificação, e nada mais. Sugestões de melhorias são aceitas.
Feliz fuso novo para todos.
The art of the prompt string
2012-05-06 03:49 -0300. Tags: comp, unix, bash, em-portugues
Ofereço este post com conteúdo útil como sacrifício aos leitores, de modo a ter crédito para escrever posts reclamando da vida mais tarde.
O prompt padrão do bash na maior parte das distribuições de GNU/Linux costuma ser algo do tipo username@hostname diretório$ . Esse prompt pode ser customizado alterando-se o valor das variáveis PS1 ("prompt string 1") e companhia:
vitor@eukleides ~$ PS1='oi? ' oi? pwd /home/vitor oi?
Você pode experimentar prompts diferentes alterando essa variável até achar um que seja do seu agrado, e então alterar um dos arquivos de configuração do bash (e.g., ~/.bashrc) para setar a variável para o valor desejado na inicialização do shell.
Backslash sequences
Como você pode imaginar, o conteúdo de PS1 não precisa ser texto estático. O bash substitui certas seqüências de \ seguido de um caractere (e.g., \u) na definição do prompt por valores específicos (e.g., o nome do usuário). O prompt padrão apresentado acima pode ser obtido pela string \u@\h \W\$ :
- \u é substituído pelo nome do usuário;
- \h é substituído pelo hostname;
- \W é substituído pela porção final (basename) do nome do diretório atual, abreviando o home para ~;
- \$ é substituído por # se o usuário atual for o root, e $ se não for.
Uma lista completa das seqüências expandidas pelo bash no prompt pode ser obtida procurando por PROMPTING no manual (man bash). Outras seqüências úteis incluem \w (caminho completo do diretório atual) e \! (número do comando atual no histórico; útil para quem gosta de usar os comandos de recuperação do histórico, e.g., !42 para reexecutar o comando de número 42).
Escape sequences
Uma das maravilhas do terminal (que talvez seja digna de um post a respeito no futuro) são as escape sequences: seqüências de caracteres especiais que podem produzir toda sorte de firula, desde cores e outros efeitos de texto até alterações no título da janela de terminal. Por exemplo, a seqüência ESC [ 3 número m, onde ESC é o caractere ASCII número 27, seleciona a cor de texto com o número especificado (que varia de 0 a 7); a seqüência ESC [ 0 m retorna as cores e outros atributos para seus valores padrão. O caractere ESC pode ser representado no prompt pela seqüência \e. Assim:
PS1='\e[34m\u@\h \W\$ \e[0m'
lhe dará um prompt idêntico ao padrão, mas em azul. Existe uma manpage (man console_codes) com uma lista de seqüências ESC suportadas por diversos terminais.
Só tem um problema: o bash usa o tamanho da string de prompt expandida para calcular o tamanho que o prompt ocupa na tela; ele precisa dessa informação para determinar onde ocorre a quebra de linha, caso o comando digitado possua mais de uma linha, e para saber onde posicionar o cursor caso você tecle Home, entre outras coisas. O problema é que os caracteres de uma seqüência ESC não ocupam espaço na tela, mas aumentam o tamanho da prompt string. Para o bash poder calcular corretamente o tamanho do prompt, é necessário demarcar os trechos de seqüências ESC no prompt entre \[ e \]:
PS1='\[\e[34m\]u@\h \W\$ \[\e[0m\]'
Provavelmente a coisa mais útil que se costuma fazer com seqüências ESC no prompt é setar o título da janela de terminal para conter o diretório atual:
PS1='\[\e]0;\w\a\]\u@\h \W\$ '
ESC ] 0 ; título BEL é a seqüência que muda o título da janela do xterm e outros terminais gráficos. (BEL, representado no prompt por \a, é o caractere ASCII número 7; em situações normais, ele é o caractere que faz o terminal emitir um beep.)
Se você nem sempre acessa o terminal via interface gráfica, pode ser uma boa idéia testar se o terminal atual é gráfico antes de adicionar seqüências ESC no prompt:
case "$TERM" in
xterm*|gnome*|konsole*) PS1='\[\e]0;\w\a\]\u@\h \W\$ ' ;;
*) PS1='\u@\h \W\$ ' ;;
esac
Ou, alternativamente, para evitar duplicação:
# Primeiro adiciona a seqüência ESC.
case "$TERM" in
xterm*|gnome*|konsole*) PS1='\[\e]0;\w\a\]' ;;
*) PS1='' ;;
esac
# Depois, o resto do prompt (igual em ambos os casos).
PS1+='\u@\h \W\$ '
Variáveis
Além de backslash sequences, o bash substitui variáveis presentes na prompt string. Por exemplo, PS1='$USER@$HOSTNAME $PWD\$ ' tem mais ou menos o mesmo efeito que PS1='\u@\h \w\$ '. Ao se usar variáveis no prompt, é importante usar aspas simples em volta do valor que está sendo atribuído a PS1:
- PS1='$PWD' atribui a string $PWD à variável PS1; quando o bash imprimir o prompt, ele substituirá o $PWD pelo valor da variável PWD, que contém o caminho completo do diretório atual. A expansão ocorrerá cada vez que o bash imprimir o prompt; se eu trocar de diretório, o prompt será atualizado de acordo.
- PS1="$PWD" atribui o valor atual da variável PWD (e.g., /home/vitor) à variável PS1. A partir daí, o valor de PS1 passa a ser /home/vitor, e o prompt não mudará se eu trocar de diretório.
O bash também expande comandos (usando a sintaxe $(comando) ou `comando`) presentes na string de prompt. Novamente, é importante cuidar para usar aspas simples caso se queira que o comando execute toda vez que o prompt é impresso, e não apenas uma vez durante a definição do prompt. De modo geral, executar um comando (criar um processo) cada vez que o prompt é impresso não me parece uma boa idéia; normalmente, executar o comando uma vez só resolve a maior parte dos problemas e é menos custoso computacionalmente. (Se bem que hoje em dia criar um processo provavelmente não vai fazer uma diferença palpável na execução do shell ou do sistema; eu recomendaria não fazer isso com o prompt do root, entretanto. A gente nunca sabe quando vai ter que matar uma fork bomb ou um processo mal-comportado no sistema.)
Uma utilidade de usar variáveis e/ou comandos é incluir nome da tty atual no prompt. Isso é particularmente útil quando se está trabalhando no modo texto, pois pelo nome da tty sabe-se o número do console virtual (e lembrando o número pode-se rapidamente voltar para o console em questão teclando Alt-Fn).
tty="$(tty)" # Recupera o nome completo da tty (e.g., /dev/tty1)
if [[ $tty == */pts/* ]]; then
ttybase="pts${tty##*/}" # Transforma /dev/pts/0 em pts0
else
ttybase="${tty##*/}" # Transforma /dev/tty1 em tty1
fi
PS1='\u@$ttybase \W\$ ' # Usa o nome da tty ao invés do hostname.
Ganhamos o nome da tty, mas perdemos o hostname. Uma possibilidade é testar se a conexão atual é via ssh, e usar o hostname nesse caso:
tty="$(tty)"
if [[ $SSH_CONNECTION ]]; then
ttybase="$HOSTNAME"
elif [[ $tty == */pts/* ]]; then
ttybase="pts${tty##*/}"
else
ttybase="${tty##*/}"
fi
PS1='\u@$ttybase \W\$ '
Outra informação útil de se incluir no prompt (uma que eu já não consigo viver sem, a ponto de alterar o prompt de outras máquinas quando vou usá-las por mais do que alguns minutos) é o exit status do último comando. O exit status é um valor ente 0 e 255 que cada processo retorna ao terminar. (É por isso que a main() retorna int, e não void, em C.) Por convenção, um programa retorna 0 se foi bem-sucedido, e um valor diferente de zero caso tenha ocorrido um erro (valores diferentes podem ser usados para erros diferentes). O exit status do último comando vive na pseudo-variável $?:
PS1='\u@$ttybase \W($?)\$ '
A presença do exit status no prompt é útil por mil razões. Primeiro, se você costuma escrever shell scripts, freqüentemente deseja saber que valor um comando retorna em certa situação. Além disso, o exit status presente no prompt dá um feedback imediato quanto ao sucesso ou falha do último comando, sem ter que ler toda a saída do comando. Por exemplo, ao copiar um diretório com muitos arquivos com cp -v, pode ser que uma mensagem de erro passe desapercebida no meio da saída normal do cp; com o exit status no prompt, o erro é imediatamente visível. Com o tempo, verificar o exit status é um ato inconsciente; para mim, hoje em dia, ele é um feedback tão importante quanto a saída do comando. Finalmente, existem alguns programas cretinos que não imprimem mensagens de erro, apenas retornam 1 para indicar que falharam. (Lamentavelmente, com o exit status no prompt, você possivelmente se sentirá inclinado a escrever programas que fazem o mesmo. Eu não tenho o direito de atirar pedras.)
The prompt command
A última maravilha promptística que tenho a apresentar é a variável PROMPT_COMMAND: se essa variável for setada, seu valor é interpretado como um comando a ser executado antes de imprimir o prompt. Você pode usá-la para chamar alguma função que seta uma variável usada na string do prompt.
Eis uma possibilidade: nos doces tempos do bash 1.14, o comportamento do \W era diferente: não havia abreviação do diretório home para ~; além disso, se o diretório estivesse diretamente abaixo do raiz (e.g., /mnt), o bash imprimia a / no início do nome, e não apenas mnt. O comportamento mudou no bash 2, e me foi a mi mui mal. Felizmente, é possível corrigir esse problema usando o PROMPT_COMMAND e uma variável no prompt:
reduced_pwd() {
case "$PWD" in
/*/*) REDPWD="${PWD##*/}" ;;
*) REDPWD="$PWD" ;;
esac
}
PROMPT_COMMAND="reduced_pwd"
PS1='\u@$ttybase $REDPWD($?)\$ '
Pode-se adaptar a reduced_pwd, com uma pequena dose de falcatrua, para mostrar os últimos dois itens do diretório atual, ao invés do caminho completo ou do último item:
reduced_pwd() {
local prefix
case "$PWD" in
/*/*/*)
# Se PWD = /mnt/foo/bar/baz/quux:
prefix="${PWD%/*/*}" # prefix = /mnt/foo/bar
REDPWD="${PWD#"$prefix"/}" # REDPWD = baz/quux
;;
*)
REDPWD="$PWD"
;;
esac
}
Pode-se obter a temperatura da CPU, ou a carga da bateria da máquina, a partir dos arquivos em /sys. Pode-se baixar periodicamente informação climática de algum site e adicionar a temperatura ao prompt, mudando a cor dependendo de se o tempo está ensolarado ou nublado ou chuvoso. As possibilidades são infinitas.