Comando Linux csh

Em sistemas operacionais do tipo Unix, o comando csh inicia o shell C, é um interpretador de comandos com uma sintaxe inspirada na linguagem de programação C.

Descrição

O csh é um intérprete de linguagem de comando com muitos recursos poderosos, incluindo um mecanismo de histórico (consulte Substituições do histórico ), recursos de controle de tarefas (consulte Trabalhos ), conclusão de nome de arquivo interativo e nome de usuário (consulte Conclusão de nome de arquivo ) e uma sintaxe semelhante a C. É usado como um shell de login interativo e como um processador de comandos de script de shell.

Se o primeiro argumento (argumento 0) do shell for um traço (‘ – ‘), o csh será executado como um shell de logon. Um shell de login também pode ser especificado invocando o shell com o sinalizador -l como o único argumento.

Sintaxe

  csh [-bcefimnstVvXx] [ argumento ...]

  csh [-l]

Opções

Depois que os argumentos do sinalizador são processados, se os argumentos permanecerem, mas nenhuma das opções -c , -i , -s ou -t for fornecida, o primeiro argumento será considerado como o nome de um arquivo de comandos a serem executados. O shell abre esse arquivo e salva seu nome para possível re-substituição em $ 0 . Como muitos sistemas usam os shells padrão da versão 6 ou 7, cujos scripts de shell não são compatíveis com esse shell, o shell executará um shell “padrão” se o primeiro caractere de um script não for uma marca de hash ( # ); ou seja, se o script não começar com um comentário. Os argumentos restantes inicializam a variável argv .

Uma instância do csh começa executando comandos do arquivo /etc/csh.cshrc e, se esse for um shell de login, /etc/csh.login . Em seguida, ele executa comandos de .cshrc no diretório inicial do invocador e, se esse for um shell de logon, o arquivo .login no mesmo local. É comum que os usuários nos monitores CRT coloquem o comando ” stty crt ” em seu arquivo .login e também invoquem o tset lá.

No caso normal, o shell começará a ler comandos do terminal , solicitando com %. O processamento de argumentos e o uso do shell para processar arquivos contendo scripts de comando são descritos abaixo.

O shell executa repetidamente as seguintes ações: uma linha de entrada de comando é lida e dividida em “palavras”. Essa sequência de palavras é colocada na lista do histórico de comandos e analisada. Finalmente, cada comando na linha atual é executado.

Quando um shell de logon termina, ele executa comandos dos arquivos .logout no diretório inicial do usuário e /etc/csh.logout .

Estrutura Lexical

O shell divide as linhas de entrada em palavras em espaços em branco e guias, com as seguintes exceções. Os caracteres & , | , ; , < , > , ( , e ) formam palavras separadas. Se dobrar em && , || , << ou >> , esses pares formam palavras únicas. Esses metacaracteres do analisador podem fazer parte de outras palavras ou ter seu significado especial impedido, precedendo-os com uma barra invertida ( \ ). Uma nova linha precedida por a \ é equivalente a um espaço em branco.

Seqüências de caracteres entre pares de aspas correspondentes, ‘ , ` ou “ formam partes de uma palavra; os metacaracteres nessas seqüências de caracteres, incluindo espaços em branco e tabulações, não formam palavras separadas. Essas citações têm semântica a ser descrita posteriormente. Dentro de pares de “ ou “ caracteres, uma nova linha precedida por a \ fornece um verdadeiro caractere de nova linha.

Quando a entrada do shell não é um terminal, o caractere # introduz um comentário que continua até o final da linha de entrada. Este significado especial é evitado quando precedido por \ e entre aspas usando ` , ‘ e “ .

Comandos

Um comando simples é uma sequência de palavras, a primeira especifica o comando a ser executado. Um comando simples ou uma sequência de comandos simples separados por | caracteres forma um pipeline. A saída de cada comando em um pipeline é conectada à entrada do próximo. Sequências de tubulações podem ser separadas por ; e são executados sequencialmente. Uma sequência de pipelines pode ser executada sem esperar imediatamente o término seguindo-o com um & .

Qualquer uma das opções acima pode ser colocada em ( ) para formar um comando simples (que pode ser um componente de um pipeline, por exemplo). Também é possível separar oleodutos com || ou && mostrando, como no idioma C, que o segundo deve ser executado apenas se o primeiro falhar ou for bem-sucedido, respectivamente. Veja expressões .

Empregos

O shell associa um trabalho a cada pipeline. Ele mantém uma tabela de trabalhos atuais, impressa pelo comando de trabalhos, e atribui a eles pequenos números inteiros . Quando um trabalho é iniciado de forma assíncrona com & , o shell imprime uma linha parecida com:

  [1] 1234

mostrando que o trabalho iniciado de forma assíncrona era o número 1 e tinha um processo (de nível superior), cujo ID do processo era 1234 .

Se você estiver executando um trabalho e desejar fazer outra coisa, pressione ^ Z (control-Z), que envia um sinal SIGSTOP para o trabalho atual. O shell normalmente mostrará que o trabalho foi “Parado” e imprimirá outro prompt. Em seguida, você pode manipular o estado desse trabalho, colocando-o em segundo plano com o comando bg ou executar outros comandos e, eventualmente, trazer o trabalho de volta ao primeiro plano com o comando fg . A ^ Z entra em vigor imediatamente e é como uma interrupção em que a saída pendente e a entrada não lida são descartadas quando digitadas. Há outra chave especial ^ Y que não gera um sinal SIGSTOP até que um programa tente lê-lo. Essa solicitação pode ser útil quando você tiver preparado alguns comandos para um trabalho que deseja interromper após a leitura.

Um trabalho que está sendo executado em segundo plano será interrompido se tentar ler no terminal. Normalmente, os trabalhos em segundo plano têm permissão para produzir saída, mas isso pode ser desativado dando o comando stty tostop . Se você definir esta opção tty , os trabalhos em segundo plano serão interrompidos quando tentarem produzir saída, como fazem ao tentar ler a entrada.

Existem várias maneiras de se referir a trabalhos no shell. O caractere % introduz um nome de trabalho. Se você quiser se referir ao trabalho número 1, pode nomeá-lo como % 1 . Apenas nomear um trabalho o coloca em primeiro plano; portanto, % 1 é sinônimo de fg% 1 , trazendo o trabalho número 1 de volta ao primeiro plano. Da mesma forma, dizer % 1 & retoma o trabalho número 1 em segundo plano. Os trabalhos também podem ser nomeados por prefixos da sequência digitada para iniciá-los, se esses prefixos não forem ambíguos; portanto, % ex normalmente reiniciaria um trabalho ex suspenso, se houvesse apenas um trabalho suspenso cujo nome começasse com a cadeia “ex”. Também é possível dizer %? string , que especifica um trabalho cujo texto contenha string , se houver apenas um desses trabalhos.

O shell mantém uma noção dos trabalhos atuais e anteriores. Na saída dos trabalhos, o trabalho atual é marcado com um + e o trabalho anterior com um – . A abreviação % + refere-se ao trabalho atual e % – refere-se ao trabalho anterior. Para uma analogia próxima com a sintaxe do mecanismo do histórico (descrito abaixo), %% também é sinônimo do trabalho atual.

O mecanismo de controle de tarefas exige que a opção stty new seja definida. É um artefato de uma nova implementação do driver tty que permite a geração de caracteres de interrupção do teclado para dizer aos trabalhos que parem. Consulte stty para obter detalhes sobre as opções de configuração no novo driver tty.

Relatório de status

O shell aprende imediatamente sempre que um processo muda de estado. Normalmente, ele informa sempre que um trabalho é bloqueado, para que nenhum progresso adicional seja possível, mas apenas antes de imprimir um prompt. Isso é feito para não atrapalhar o seu trabalho. Se, no entanto, você definir a variável de notificação de shell, o shell notificará você imediatamente sobre alterações de status nos trabalhos em segundo plano. Há também um comando de shell notificar que marca um único processo para que suas alterações de status sejam imediatamente relatadas. Por padrão, o notify marca o processo atual; diga notificar após iniciar um trabalho em segundo plano para marcá-lo.

Quando você tenta sair do shell enquanto os trabalhos estão parados, você será avisado de que “Você interrompeu os trabalhos”. Você pode usar o comando jobs para ver o que são. Se você tentar sair novamente imediatamente, o shell não avisará uma segunda vez e os trabalhos suspensos serão encerrados.

Conclusão do nome do arquivo

Quando o recurso de conclusão de nome de arquivo é ativado pela configuração da variável de shell filec (consulte o conjunto ), o csh conclui interativamente nomes de arquivos e nomes de usuários a partir de prefixos exclusivos quando são inseridos no terminal, seguidos pelo caractere de escape (a tecla de escape ou controle). [ ) Por exemplo, se o diretório atual se parecer com

 DSC.OLD                     bin       cmd     lib   xmpl.c
 DSC.NEW                     chaosnet  cmtest  mail  xmpl.o
 classe de banco de dados    dev mbox  xmpl.out

e a entrada é

 % vi ch<escape>

O csh completará o prefixo ” ch ” com o único nome de arquivo correspondente ” chaosnet “, alterando a linha de entrada para

  % vi chaosnet

No entanto, dado

  % vi D <escapa>

O csh expandirá apenas a entrada para

  % vi DSC.

e tocará a campainha do terminal para indicar que a expansão está incompleta, pois há dois nomes de arquivos correspondentes ao prefixo D.

Se um nome de arquivo parcial for seguido pelo caractere de fim de arquivo (geralmente control-D ), em vez de completar o nome, o csh listará todos os nomes de arquivos correspondentes ao prefixo. Por exemplo, a entrada

  % vi D <control-D>

faz com que todos os arquivos começando com D sejam listados:

  DSC.NEW DSC.OLD

enquanto a linha de entrada permanece inalterada.

O mesmo sistema de escape e final de arquivo também pode ser usado para expandir nomes de usuário parciais, se a palavra a ser concluída (ou listada) começar com o caractere til ( ~ ). Por exemplo, digitando

  cd ~ ro <escape>

pode produzir a expansão

  cd ~ root

O uso da campainha do terminal para sinalizar erros ou várias correspondências pode ser inibido configurando a variável nobeep .

Normalmente, todos os arquivos no diretório específico são candidatos à conclusão do nome. Arquivos com certos sufixos podem ser excluídos da consideração, definindo a variável fignore na lista de sufixos a serem ignorados. Portanto, se fignore for definido pelo comando

  % set fignore = (.o .out)

então digitando

  % vi x <escape>

resultaria na conclusão de

  % vi xmpl.c

ignorando os arquivos ” xmpl.o ” e ” xmpl.out “. No entanto, se a única conclusão possível exigir não ignorar esses sufixos, eles não serão ignorados. Além disso, o fignore não afeta a lista de nomes de arquivos pelo controle-D . Todos os arquivos são listados independentemente de seus sufixos.

Substituições da História

As substituições do histórico colocam as palavras da entrada de comando anterior como partes de novos comandos, facilitando a repetição de comandos, a repetição de argumentos de um comando anterior no comando atual ou a correção de erros ortográficos no comando anterior com pouca digitação e alto grau de confiança. As substituições da história começam com o personagem ! e pode começar em qualquer lugar do fluxo de entrada (desde que não sejam aninhados). Isso ! pode ser precedido por a \ para impedir seu significado especial; por conveniência, a ! O caractere é passado inalterado quando é seguido por um espaço em branco, tab, nova linha, = ou ( . As substituições do histórico também ocorrem quando uma linha de entrada começa com ^ . Essa abreviação especial é descrita abaixo. Qualquer linha de entrada que contenha substituição do histórico é ecoada no terminal antes de ser executado, pois teria sido digitado sem substituição do histórico.

Os comandos de entrada do terminal que consistem em uma ou mais palavras são salvos na lista de histórico. As substituições do histórico reintroduzem sequências de palavras desses comandos salvos no fluxo de entrada. O tamanho da lista do histórico é controlado pela variável do histórico ; o comando anterior é sempre mantido, independentemente do valor da variável do histórico . Os comandos são numerados sequencialmente a partir de 1 .

Considere a seguinte saída do comando history :

  09 escrever michael
 10 ex write.c
 11 cat oldwrite.c
 12 diff * write.c

Os comandos são mostrados com seus números de eventos. Geralmente, não é necessário usar números de eventos, mas o número do evento atual pode fazer parte do prompt, colocando a ! na sequência de prompt.

Com o evento atual 13 , podemos nos referir a eventos anteriores pelo número do evento ! 11 , relativamente como em ! -2 (referindo-se ao mesmo evento), por um prefixo de uma palavra de comando como em ! D para o evento 12 ou ! Wri for event 9 ou por uma sequência contida em uma palavra no comando como em !? Mic? também se referindo ao evento 9 . Esses formulários, sem alterações adicionais, reintroduzem as palavras dos eventos especificados, cada um separado por um único espaço em branco. Como um caso especial, !! refere-se ao comando anterior; assim !! sozinho é um re-fazer.

Para selecionar palavras de um evento, podemos seguir a especificação do evento por : e um designador para as palavras desejadas. As palavras de uma linha de entrada são numeradas de 0 , a primeira (geralmente comando) é 0 , a segunda (primeiro argumento) é 1 , etc. Os designadores básicos de palavras são:

O : separando a especificação do evento do designador de palavras pode ser omitido se o seletor de argumentos começar com ^ , $ , * , – ou % . Após o designador opcional de palavras, uma sequência de modificadores pode ser colocada, cada uma precedida por um :. Os seguintes modificadores estão definidos:

A menos que seja precedido por g, a alteração é aplicada apenas à primeira palavra modificável. Com substituições, é um erro que nenhuma palavra seja aplicável.

O lado esquerdo das substituições não são expressões regulares no sentido dos editores, mas cadeias de caracteres. Qualquer caractere pode ser usado como delimitador no lugar de / ; a \ cita o delimitador nas cadeias l e r . O caractere & no lado direito é substituído pelo texto da esquerda. A \ também cita & . Um NULL l ( // ) usa a string anterior de um l ou de uma string de varredura contextual s in !? S \? . O delimitador à direita na substituição pode ser omitido se uma nova linha seguir imediatamente, assim como a à direita ? em uma varredura contextual.

Uma referência de histórico pode ser fornecida sem uma especificação de evento; por exemplo ,! $ . Aqui, a referência é ao comando anterior, a menos que uma referência de histórico anterior tenha ocorrido na mesma linha, caso em que este formulário repete a referência anterior. Assim, ” !? Foo? ^! $ ” Fornece o primeiro e o último argumento do comando correspondente a ” ? Foo? “.

Uma abreviação especial de uma referência de histórico ocorre quando o primeiro caractere não em branco de uma linha de entrada é ^ . Isso é equivalente a ” !: S ^ “, fornecendo uma abreviação conveniente para substituições no texto da linha anterior. Assim, ^ lb ^ lib corrige a ortografia de ” lib ” no comando anterior. Finalmente, uma substituição de histórico pode ser cercada com { e }, se necessário, para isolá-la dos caracteres a seguir. Assim, depois de ls -ld ~ paul , poderíamos fazer ! {L} a fazer ls -ld ~ paula , enquanto ! La procuraria um comando começando com ” la “.

Citações com ´ e “

A citação de strings por ‘ e “ pode ser usada para impedir todas ou algumas das substituições restantes. Strings entre ‘ são impedidos de qualquer interpretação adicional. Strings entre “ podem ser expandidos conforme descrito abaixo.

Nos dois casos, o texto resultante se torna (no todo ou em parte) uma única palavra; somente em um caso especial (consulte Substituição de Comando , abaixo) uma “ cadeia de caracteres citada produz partes de mais de uma palavra; ‘as cadeias de caracteres citadas nunca produzem.

Substituição de alias

O shell mantém uma lista de aliases que podem ser estabelecidos, exibidos e modificados pelos comandos alias e unalias . Após a varredura de uma linha de comando, ela é analisada em comandos distintos e a primeira palavra de cada comando, da esquerda para a direita, é verificada para ver se possui um alias. Caso isso aconteça, o texto que é o alias para esse comando é relido com o mecanismo de histórico disponível como se esse comando fosse a linha de entrada anterior. As palavras resultantes substituem a lista de comandos e argumentos. Se nenhuma referência for feita à lista de histórico, a lista de argumentos permanecerá inalterada.

Portanto, se o alias para ” ls ” for ” ls -l “, o comando ls / usr seria mapeado para ls -l / usr , a lista de argumentos aqui não será perturbada. Da mesma forma, se o alias de ” pesquisa ” fosse ” grep! ^ / Etc / passwd “, a conta de pesquisa seria mapeada para grep bill / etc / passwd .

Se um alias for encontrado, a transformação da palavra do texto de entrada é executada e o processo de alias começa novamente na linha de entrada reformada. O loop é impedido se a primeira palavra do novo texto for a mesma que a antiga, sinalizando-a para evitar aliases adicionais. Outros loops são detectados e causam um erro.

Observe que o mecanismo permite que os aliases introduzam o analisador “metasyntax”. Assim, podemos também imprimir ‘pr \! * | lpr ‘ para fazer um comando que apresenta seus argumentos para a impressora de linha.

Substituição Variável

O shell mantém um conjunto de variáveis, cada uma das quais tem como valor uma lista de zero ou mais palavras. Algumas dessas variáveis ​​são definidas pelo shell ou mencionadas por ele. Por exemplo, a variável argv mantém a lista de argumentos do shell, e as palavras do valor dessa variável são mencionadas de maneiras especiais.

Os valores das variáveis ​​podem ser exibidos e alterados usando os comandos set e unsetet. Das variáveis ​​referidas pelo shell, um número é alternado; o shell não se importa com o seu valor, apenas se eles estão definidos ou não. Por exemplo, a variável detalhada é uma alternância que faz com que a entrada do comando seja ecoada. A configuração dessa variável resulta da opção de linha de comando -v .

Outras operações tratam variáveis ​​numericamente. O comando @ permite que cálculos numéricos sejam executados e o resultado atribuído a uma variável. Os valores variáveis ​​são, no entanto, sempre representados como (zero ou mais) cadeias. Para fins de operações numéricas, a cadeia nula é considerada zero e a segunda e outras palavras dos valores de várias palavras são ignoradas.

Depois que a linha de entrada é alterada e analisada, e antes de cada comando ser executado, a substituição de variável é executada, digitada por $ caracteres. Essa expansão pode ser evitada precedendo o $ com a \, exceto entre aspas duplas ( “ ), onde a substituição sempre ocorre, e entre aspas simples ( ‘ ), onde nunca ocorre. As strings citadas por backticks ( ` ` ) são interpretadas posteriormente ( consulte Substituição de comando , abaixo), para que a substituição de $ não ocorra até mais tarde, se for o caso .. Um $ é passado inalterado se seguido por um espaço em branco, tabulação ou fim de linha.

Os redirecionamentos de entrada / saída são reconhecidos antes da expansão variável e são expandidos separadamente. Caso contrário, o nome do comando e a lista de argumentos inteira serão expandidos juntos. Portanto, é possível que a primeira palavra (comando) (até este ponto) gere mais de uma palavra, a primeira se tornando o nome do comando e o restante se tornando argumentos.

A menos que inclua “ ou receba o modificador : q , os resultados da substituição de variável podem eventualmente ser substituídos por comando e nome de arquivo. Dentro de “ , uma variável cujo valor consiste em várias palavras se expande para (uma parte de) uma única palavra, com as palavras de o valor da variável separado por espaços em branco. Quando o modificador : q é aplicado a uma substituição, a variável será expandida para várias palavras, com cada palavra separada por um espaço em branco e entre aspas para impedir a substituição posterior de comandos ou nomes de arquivos.

As seguintes metasequências são fornecidas para a introdução de valores variáveis ​​na entrada do shell. Exceto como observado, é um erro referenciar uma variável que não está definida.

Os modificadores : e ,: h,: t ,: r ,: q e : x podem ser aplicados às substituições acima da seguinte maneira : gh,: gt e : gr . Se chaves { } aparecerem no formulário de comando, os modificadores deverão aparecer dentro das chaves. A implementação atual permite apenas um : modificador em cada expansão de $ .

As seguintes substituições não podem ser modificadas por : modifiers.

Substituição de comando e nome de arquivo

As substituições restantes, substituição de comando e nome de arquivo, são aplicadas seletivamente aos argumentos dos comandos internos. Aqui, “seletivamente” significa que partes de expressões que não são avaliadas não estão sujeitas a essas expansões. Para comandos que não são internos ao shell, o nome do comando é substituído separadamente da lista de argumentos. Isso ocorre muito tarde, após o redirecionamento de entrada e saída ser executado e em um filho do shell principal.

Substituição de Comando

A substituição de comando é mostrada por um comando incluído em ` . A saída desse comando normalmente é dividida em palavras separadas em espaços em branco, guias e novas linhas, com palavras nulas sendo descartadas; esse texto substitui a sequência original. Entre aspas duplas ( “ ), apenas as novas linhas forçam novas palavras; os espaços em branco e as guias são preservados.

De qualquer forma, a nova linha final única não força uma nova palavra. Observe que, portanto, é possível que uma substituição de comando produza apenas parte de uma palavra, mesmo que o comando produza uma linha completa.

Substituição de nome de arquivo

Se uma palavra contiver algum dos caracteres * ,? , [ , ou { , ou começa com o caractere ~ , então essa palavra é candidata à substituição de nome de arquivo, também conhecida como ” globbing “. Essa palavra é considerada um padrão e substituída por uma lista classificada alfabeticamente de nomes de arquivos que correspondem ao padrão. Em uma lista de palavras que especificam a substituição do nome do arquivo, é um erro que nenhum padrão corresponda a um nome de arquivo existente, mas não é necessário que cada padrão corresponda. Apenas os metacaracteres * ,? , e [ implica correspondência de padrão, os caracteres ~ e { são mais parecidos com abreviações.

Nos nomes de arquivos correspondentes, o personagem . no início de um nome de arquivo ou imediatamente após um / , bem como o caractere / deve ser correspondido explicitamente. O caractere * corresponde a qualquer sequência de caracteres, incluindo a sequência nula. O personagem ? corresponde a qualquer caractere único.

A sequência ” [ … ] ” corresponde a qualquer um dos caracteres incluídos. Dentro de ” [ … ] “, um par de caracteres separados por – corresponde a qualquer caractere lexicamente entre os dois (inclusive). Dentro de ” [ … ] “, o nome de uma classe de caractere entre [: e :] representa a lista de todos os caracteres pertencentes a essa classe. Classes de caracteres suportadas:

• alnum
• alfa
• em branco
• cntrl
• dígito
• gráfico
• mais baixo
• impressão
• espaço
• superior
• pontual
• xdigit

Eles correspondem aos caracteres usando as macros especificadas no ctype . Uma classe de caracteres não pode ser usada como um ponto final de um intervalo.

O caractere ~ no início de um nome de arquivo se refere aos diretórios pessoais. Sozinho, ou seja, ~ , ele se expande para o diretório inicial do chamador, conforme refletido no valor da variável inicial. Quando seguido por um nome que consiste em letras, dígitos e caracteres – , o shell procura um usuário com esse nome e substitui o diretório inicial; portanto, ” ~ ken ” pode se expandir para ” / usr / ken ” e ” ~ ken / chmach ” para ” / usr / ken / chmach “. Se o caractere ~ for seguido por um caractere que não seja uma letra ou / ou não aparecer no início de uma palavra, ele será deixado inalterado.

A metanotação ” a {b, c, d} e ” é uma abreviação de ” abe ace ade “. A ordem da esquerda para a direita é preservada, com os resultados das correspondências sendo classificados separadamente em um nível baixo para preservar essa ordem. Essa construção pode ser aninhada . Portanto, ” ~ source / s1 / {oldls, ls} .c ” se expande para ” /usr/source/s1/oldls.c /usr/source/s1/ls.c ” sem chance de erro se o diretório inicial para ” fonte “é” / usr / fonte “. Da mesma forma, ” ../{memo,*box} ” pode ser expandido para ” ../memo ../box ../mbox “. Observe que ” memorando ” não foi classificado com os resultados da correspondência para ” * caixa “. Como um caso especial, { , } e {} são passados ​​imperturbáveis.

Entrada / saída

A entrada padrão e a saída padrão de um comando podem ser redirecionadas com a seguinte sintaxe:

Um comando recebe o ambiente no qual o shell foi chamado conforme modificado pelos parâmetros de entrada e saída e a presença do comando em um pipeline. Assim, diferentemente de alguns shells anteriores, os comandos executados a partir de um arquivo de comandos shell não têm acesso ao texto dos comandos por padrão; em vez disso, eles recebem a entrada padrão original do shell. O mecanismo << deve ser usado para apresentar dados embutidos. Isso permite que os scripts de comando do shell funcionem como componentes de pipelines e permite que o shell bloqueie a leitura de sua entrada. Observe que a entrada padrão padrão para uma execução de comando desanexada não é modificada para ser o arquivo vazio / dev / null ; em vez disso, a entrada padrão permanece como a entrada padrão original do shell. Se este for um terminal e se o processo tentar ler no terminal, o processo será bloqueado e o usuário será notificado (consulte Trabalhos acima).

A saída de erro padrão pode ser direcionada através de um tubo com a saída padrão. Use o formulário | & em vez de apenas | .

Expressões

Vários dos comandos internos (a serem descritos posteriormente) usam expressões, nas quais os operadores são semelhantes aos de C, com a mesma precedência, mas com o agrupamento oposto: da direita para a esquerda. Essas expressões aparecem nos comandos @ , exit , if e while . Os seguintes operadores estão disponíveis:

• ||
• &&
• |
• ↑
• &
• ==
• ! =
• = ~
• ! ~
• <=
• > =
• <
• >
• <<
• >>
• +
• –
• *
• /
• %
• !
• ~
• (
• )

Aqui a precedência aumenta na lista, com == ! = = ~ E ! ~ , <=> = < E > , << e >> , + e – , * / e % estando, em grupos, no mesmo nível . Os operadores == ! = = ~ E ! ~ Comparam seus argumentos como strings; todos os outros operam em números. Os operadores = ~ e ! ~ São como ! = E == exceto que o lado direito é um padrão (contendo, por exemplo, * ‘s ,? ‘ E instâncias de ” […] “) contra os quais o O operando esquerdo é correspondido. Isso reduz a necessidade de uso da instrução switch nos scripts de shell quando tudo o que é realmente necessário é a correspondência de padrões.

Seqüências de caracteres que começam com 0 são consideradas números octais . Argumentos nulos ou ausentes são considerados 0 . Os resultados de todas as expressões são cadeias, que representam números decimais . É importante observar que nenhum componente de uma expressão pode aparecer na mesma palavra; exceto quando adjacentes a componentes de expressões que são sintaticamente significantes para o analisador ( & , | , < , > , ( e ) ), eles devem estar cercados por espaços.

Também estão disponíveis em expressões como operandos primitivos as execuções de comandos incluídas em { and } e as consultas de arquivo do formulário -l name em que l é um dos seguintes:

O nome especificado é comando e nome do arquivo expandido e testado para verificar se ele possui o relacionamento especificado com o usuário real. Se o arquivo não existir ou estiver inacessível, todas as consultas retornarão false , ou seja, 0 . As execuções de comando são bem-sucedidas, retornando true, ou seja, 1 , se o comando sair com o status 0 , caso contrário, elas falham, retornando false, ou seja, 0 . Se informações de status mais detalhadas forem necessárias, o comando deverá ser executado fora de uma expressão e o status da variável examinado.

Controle de fluxo

O shell contém vários comandos que podem ser usados ​​para regular o fluxo de controle nos arquivos de comando (scripts de shell) e (de maneiras limitadas, mas úteis) da entrada do terminal. Todos esses comandos operam forçando o shell a reler ou ignorar sua entrada e, devido à implementação, restringir o posicionamento de alguns dos comandos.

As instruções foreach , switch e while , bem como a forma if-then-else da instrução if exigem que as principais palavras-chave apareçam em um único comando simples em uma linha de entrada, como mostrado abaixo.

Se a entrada do shell não for procurável, o shell armazena em buffer a entrada sempre que um loop está sendo lido e realiza buscas nesse buffer interno para realizar a releitura implícita no loop. Na medida em que isso permitir, os gotos anteriores terão êxito em insumos não procuráveis.

Comandos internos

Comandos internos são executados dentro do shell. Se um comando interno ocorrer como qualquer componente de um pipeline, exceto o último, ele será executado em um sub-shell.

Pre-defined and environment variables

The following variables have special meaning to the shell. Of these, argv , cwd , home , path , prompt , shell and status are always set by the shell. Except for cwd and status , this setting occurs only at initialization; these variables will not then be modified unless done explicitly by the user.

The shell copies the environment variable USER into the variable user , TERM into term , and HOME into home , and copies these back into the environment whenever the normal shell variables are reset. The environment variable PATH is likewise handled; it is not necessary to worry about its setting other than in the file .cshrc as inferior csh processes will import the definition of path from the environment, and re-export it if you then change it.

Non-built-in command execution

When a command to be executed is found to not be a built-in command the shell attempts to execute the command via execve . Each word in the variable path names a directory from which the shell will attempt to execute the command. If it is given neither a -c nor a -t option, the shell will hash the names in these directories into an internal table so that it will only try an exec in a directory if there is a possibility that the command resides there. This shortcut greatly speeds command location when many directories are present in the search path. If this mechanism has been turned off (via unhash ), or if the shell was given a -c or -t argument, and in any case for each directory component of path that does not begin with a / , the shell concatenates with the given command name to form a path name of a file which it then attempts to execute.

Parenthesized commands are always executed in a sub-shell. portanto

 (cd; pwd);  pwd

prints the home directory; leaving you where you were (printing this after the home directory), while

  CD;  pwd

leaves you in the home directory. Parenthesized commands are most often used to prevent chdir from affecting the current shell.

If the file has execute permissions but is not an executable binary to the system, then it is assumed to be a file containing shell commands and a new shell is spawned to read it.

If there is an alias for shell then the words of the alias will be prepended to the argument list to form the shell command. The first word of the alias should be the full path name of the shell (eg, ” $shell “). Note that this is a special, late occurring, case of alias substitution, and only allows words to be prepended to the argument list without change.

Signal Handling

The shell normally ignores SIGQUIT signals . Jobs running detached (either by & or the bg or %… & commands) are immune to signals generated from the keyboard, including hangups. Other signals have the values which the shell inherited from its parent. The shell’s handling of interrupts and terminate signals in shell scripts can be controlled by onintr . Login shells catch the SIGTERM (terminate) signal; otherwise this signal is passed on to children from the state in the shell’s parent. Interrupts are not allowed when a login shell is reading the file .logout .

Limitações

Comprimentos de palavras: as palavras não podem ter mais que 1024 caracteres. O número de argumentos para um comando que envolve expansão de nome de arquivo é limitado a 1/6 do número de caracteres permitidos em uma lista de argumentos. As substituições de comando podem substituir não mais caracteres do que os permitidos em uma lista de argumentos. Para detectar loop, o shell restringe o número de substituições de alias em uma única linha para 20.

arquivos

Exemplos

  csh

Executa e executa o C Shell (se presente).

Consulte o guia .cshrc para obter um exemplo do arquivo .cshrc e informações adicionais sobre esse arquivo.

Comandos relacionados

bash – O interpretador de comandos do shell Bourne Again.
bc – Uma calculadora.
login – Inicia uma sessão em um sistema.
ls – lista o conteúdo de um diretório ou diretórios.
mais – Exibe o texto uma tela por vez.
ps – Relate o status de um processo ou processos.
sh – O interpretador de comandos do Bourne shell.