Shell do Unix

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Tela durante uma sessão mostra Bash, extraída do Gentoo Linux.

Um shell do Unix é um interpretador de linha de comando ou shell que fornece uma interface semelhante ao Unix tradicional. Os usuários indicam a operação do computador pela entrada de comandos como texto para um interpretador de linha de comando executar, ou criando scripts de texto de um ou mais de tais comandos. Usuários tipicamente interagem com um shell do Unix usando um emulador terminal, entretanto, operação direta via conexão serial de hardware, ou sessão de rede de computadores, são comuns para sistemas de servidor. Todos os shells do Unix fornecem caracteres-curinga de nome de arquivo, encadeamento, here documentos, substituição de comando, variáveis e estruturas de controle para teste condicional e iteração.

Conceito[editar | editar código-fonte]

O senso mais genérico do termo shell significa algum programa que o usuário emprega para tipificar comandos. Um shell esconde os detalhes do sistema operacional subjacente e gerencia detalhes técnicos da interface do kernel do sistema operacional, que é o nível mais baixo, ou componente "mais íntimo" de muitos sistemas operacionais.

Em sistemas operacionais tipo Unix, usuários tipicamente têm muitas escolhas de interpretadores de linha de comando para sessões interativas. Quando um usuário faz login no sistema interativamente, um programa shell é automaticamente executado para a duração da sessão. O tipo do shell, que deve ser customizado por cada usuário, é tipicamente armazenado no perfil do usuário, por exemplo, no arquivo passwd local ou em um sistema de configuração distribuída como o NIS ou LDAP; contudo, o usuário deve executar algum outro shell disponível interativamente.

O shell do Unix é ambos, um linguagem de comando interativa, e também uma linguagem de script, e é usado pelo sistema operacional como a facilidade para controlar (shell script) a execução do sistema.[1] Shells criados para outros sistemas operacionais frequentemente fornecem funcionalidade similar.

Em hosts com um sistema de janelas, como o macOS, alguns usuários nunca devem usar o shell diretamente. Em sistemas Unix, o shell foi historicamente a linguagem de implementação de scripts de boot do sistema, incluindo o programa que inicia um sistema de janelas, configura a rede de computadores, e muitas outras funções essenciais. Porém, alguns fornecedores de sistema substituíram o sistema de boot tradicional baseado em shell (init) com abordagens diferentes, tais como o systemd.

Primeiros shells[editar | editar código-fonte]

O primeiro shell do Unix foi o Thompson shell, sh, escrito por Ken Thompson no Bell Labs e distribuído com versões 1 até o 6 do Unix, de 1971 a 1975.[2] Embora rudimentar pelos padrões modernos, ele introduziu muitos dos recursos básicos comuns, mais tarde, a todos os shells do Unix, incluindo encadeamento, estruturas de controle simpl usando if e goto, e caracteres-curinga de nome de arquivo. Embora não esteja em uso atualmente, é ainda disponível como parte de alguns antigos sistemas UNIX.

Ele foi modelado depois do shell da Multics, que foi modelado depois do programa RUNCOM de Louis Pouzin, que o mostrou à equipe da Multics. O sufixo "rc" em alguns arquivos de configuração Unix (por exemplo, ".vimrc"), é um remanescente da linhagem RUNCOM dos shells do Unix.[3][4]

O shell PWB ou shell Mashey, sh, foi uma versão compatível do Thompson shell, expandida por John Mashey e distribuída com o Workbench do Programador UNIX, por volta de 1975-1977. Ele realçou em fazer um shell de programação prática, especialmente em grandes centros de informática compartilhados. Ele adicionou variáveis shell (precursoras das variáveis de ambiente, incluindo o mecanismo path de pesquisa que evoluiu para $PATH), scripts shell executáveis por usuário, e tratamento de interrupções. Estruturas de controle foram estendidas de if/goto para if/then/else/endif, switch/breaksw/endsw, e while/end/break/continue.

Como a programação de shell tornou-se muito difundida, estes comandos externos foram incorporados ao shell para a sua performance.

Mas, os mais amplamente distribuídos e influentes dos primeiros shells do Unix foram o Bourne shell e o C shell. Ambos os shells foram usados como código-base e modelo das muitas derivações e trabalhos de shells semelhantes com configurações de fábrica estendidas.[5]

Bourne shell[editar | editar código-fonte]

Ver artigo principal: Bourne shell

O Bourne shell, sh, foi reescrito por completo por Stephen Bourne no Bell Labs.[6] Distribuído como o shell para o UNIX Versão 7 em 1979, ele introduziu o resto dos recursos básicos considerados comuns a todos os shells do Unix, incluindo here documentos, substituição de comando, mais variáveis genéricas e mais estruturas de controle embutidas extensivas. A linguagem, incluindo o uso de uma palavra-chave invertida para marcar o fim de um bloco, foi influenciada por ALGOL 68.[7] Tradicionalmente, o nome do programa Bourne shell é sh e seu path na hierarquia do sistema de arquivos Unix é /bin/sh. Mas um número de trabalhos semelhantes compatíveis estão também disponíveis com várias melhorias e recursos adicionais.

Em muitos sistemas, sh deve ser uma ligação simbólica ou ligação forte para uma destas alternativas:

O padrão POSIX especifica seu shell padrão como uma subconfiguração rigorosa do Korn shell, uma versão melhorada do Bourne shell. Da perspectiva do usuário, o Bourne shell foi imediatamente reconhecido quando ativo pelo caractere de prompt de linha de comando padrão característico, o símbolo de dólar ($).

C shell[editar | editar código-fonte]

Ver artigo principal: Csh

O C shell, csh, foi escrito por Bill Joy, enquanto um estudante graduado na Universidade da Califórnia em Berkeley e largamente distribuído com o BSD Unix.[9] A linguagem, incluindo as estruturas de controle e a gramática de expressão, foi modelada em C. O C shell também introduziu um largo número de recursos para trabalho interativo, incluindo os mecanismos de história e edição, pseudônimos, pilhas de diretório, notação til, cdpath, job control e path hashing. Em muitos sistemas, csh deve ser uma ligação simbólica ou ligação forte ao TENEX C shell (tcsh), uma versão melhorada do csh original de Joy. Embora os recursos interativos do C shell foram copiados em muitos outros shells atuais, a linguagem em si mesma não foi amplamente copiada. O único trabalho semelhante é o Hamilton C shell, escrito por Nicole Hamilton, primeiro distribuído no OS/2 em 1988 e no Windows desde 1992.[10]

Arquivos de configuração[editar | editar código-fonte]

Shells leem arquivos de configuração em múltiplas circunstâncias que diferenciam dependendo do shell. Estes arquivos comumente contém comandos para o shell particular e são executados quando carregados; eles são frequentemente usados para configurar importantes variáveis usadas para encontrar executáveis, como $PATH, e outras que controlam o comportamento e aparência do shell. A tabela nesta seção mostra os arquivos de configuração para shells populares.[11]

sh ksh csh tcsh bash zsh
/etc/.login login login
/etc/csh.cshrc yes yes
/etc/csh.login login login
~/.tcshrc yes
~/.cshrc yes yes[nota 1]
~/etc/ksh.kshrc int.
/etc/sh.shrc int.[nota 2]
$ENV (typically ~/.kshrc)[12] int.[nota 3][nota 4] int. int.[nota 5]
~/.login login login
~/.logout login login
/etc/profile login login login login[nota 6]
~/.profile login login login[nota 7] login[nota 6]
~/.bash_profile login[nota 7]
~/.bash_login login[nota 7]
~/.bash_logout login
~/.bashrc int.+n/login
/etc/zshenv yes
/etc/zprofile login
/etc/zshrc int.
/etc/zlogin login
/etc/zlogout login
~/.zshenv yes
~/.zprofile login
~/.zshrc int.
~/.zlogin login

Explicação:

  • blank significa um arquivo que não é lido por um shell por inteiro.
  • "yes" significa um arquivo que é sempre lido por um shell sobre o boot.
  • "login" significa um arquivo que é lido se o shell é um login shell.
  • "n/login" significa um arquivo que é lido se o shell não é um login shell.
  • "int." significa um arquivo que é lido se o shell é interativo.
  1. apenas se ~/.tcshrc não é encontrado
  2. Novas versões do Bourne shell apenas
  3. Disponível em sistemas que suportam "User Portability Utilities option"; valor da variável deve ser um path absoluto, e ela é ignorada "se o ID real do usuário e o do usuário efetivo ou o ID real e o de um grupo efetivo são diferentes."[13]
  4. $ENV is $HOME/.shrc em novas versões do Bourne shell
  5. Mesmo comportamento como sh, mas apenas se invocado como sh (bash 2+) ou, a partir do bash 4.2, também se invocado explicitamente no modo de compatibilidade POSIX (com opções --posix ou -o posix).[14]
  6. a b Apenas no modo de compatibilidade sh/ksh (quando invocado como bash, sh, ksh)
  7. a b c de fato, o primeiro legível do ~/.bash_profile, ~/.bash_login e ~/.profile; e apenas ~/.profile se invocado como sh ou, como pelo menos Bash 4.2, se invocado explicitamente no modo de compatibilidade POSIX (com opções --posix ou -o posix)

Shells exóticos[editar | editar código-fonte]

Das muitas variações exóticas no conceito do shell do Unix, incluem os seguintes:[15]

Ver também[editar | editar código-fonte]

Referências[editar | editar código-fonte]

  1. Bourne, Stephen R. (outubro de 1983). «The Unix Shell». BYTE. 187 páginas. Consultado em 30 de janeiro de 2015 
  2. «V6 Thompson Shell Port - History». V6shell.org. Consultado em 14 de agosto de 2012 
  3. Tom Van Vleck (5 de fevereiro de 1995). «Unix and Multics». Multicians.org. Consultado em 14 de agosto de 2012 
  4. Louis Pouzin (25 de novembro de 2000). «The Origin of the Shell». Multicians.org. Consultado em 14 de agosto de 2012 
  5. Nikolai Bezroukov (13 de agosto de 2015). «Introduction to the Unix shell history». Softpanorama. Consultado em 21 de agosto de 2016 
  6. «Bourne shell, or sh». Interview with Steve Bourne. Computerworld. 5 de março de 2009. Consultado em 21 de agosto de 2016 
  7. «Re: Late Bloomers Revisited». Consultado em 20 de setembro de 2014 
  8. Korn, David G. (26 de outubro de 1994), «ksh - An Extensible High Level Language», USENIX Association, Proceedings of the USENIX 1994 Very High Level Languages Symposium, consultado em 5 de fevereiro de 2015, Instead of inventing a new script language, we built a form entry system by modifying the Bourne shell, adding built-in commands as necessary. 
  9. Harley Hahn, Harley Hahn's Guide to Unix and Linux.
  10. «Hamilton C shell for Windows Release Notes 4.0». Consultado em 20 de setembro de 2014 
  11. «Different UNIX Shells». unixnote.com. 2010. Consultado em 21 de agosto de 2016 
  12. SCO Unix Group, SCO Unixware 7 documentation, 22 Apr 2004, retrieved 18 Oct 2012.
  13. «Shell Command Language». opengroup.org. Consultado em 15 de junho de 2015 
  14. [https://www.gnu.org/software/bash/manual/html_node/Bash-Startup- Files.html «Bash Reference Manual: Bash Startup Files»] Verifique valor |url= (ajuda). gnu.org. Consultado em 15 de junho de 2015  line feed character character in |url= at position 65 (ajuda)
  15. «FreeBSD Ports: Shells». Freebsd.org. 30 de março de 2014. Consultado em 5 de abril de 2014