Slackjeff Wiki

Essa página está em modo somente de leitura. Você pode visualizar a fonte, mas não alterá-la. Informe-se com o administrador do Wiki, caso você ache que isso está incorreto.
====== more ======

**more** é um paginador [[utils:glossario#t|de terminal]] :?:, originário do UNIX.

===== Noções básicas =====

Para aprender a usar o __more__, vamos começar detalhando alguns conceitos comuns da sua terminologia:

  * **Avançar** e **Retroceder**

O principal benefício de um paginador de terminal é o fato de que o texto a ser lido não precisa caber por inteiro na tela do terminal. Ele apresenta o texto inteiro, se couber, mas caso não caiba, ele mostra apenas uma parcela do texto, e você pode avançar ou retroceder no texto, isto é, visualizar linhas "abaixo" ou "acima" da parte que está visível na tela.

Ao contrário do que pode parecer, avançar é um recurso mais básico e mais simples do que retroceder, e nem todos os terminais (ou emuladores de terminais) são capazes de oferecer a operação de retrocesso, obrigando um recarregamento do arquivo desde o início. Essa limitação também era comum nas primeiras versões de __more__, o que fez com que o programa __less__ ganhasse mais popularidade.

Há diferentes maneiras de avançar e de retroceder. O movimento pode ser feito por páginas, por linhas ou por grupos de linhas, e pode ainda ser feito via rolagem ou via redesenho. Há ainda a possibilidade de mudar para pontos diferentes do texto fazendo pesquisas por termos ou navegando para locais previamente marcados. E ainda existe também a navegação para um ponto especificado (seja pelo número da linha ou por um percentual em relação ao tamanho total do arquivo).

  * **Anterior** e **Próximo**

Ao ser chamado, o programa __more__ pode receber como argumentos um ou mais arquivos de texto que serão abertos para a leitura paginada. Caso haja mais de um, a paginação dos arquivos é separada (isto é, os arquivos não são concatenados e lidos em sequência). Ao terminar a leitura de um arquivo, é apresentado um //prompt// para que se passe para o próximo arquivo da lista, ou encerrar o programa, caso não haja mais nenhum.

É possível também acionar comandos internos do paginador __more__, para navegar de volta para o arquivo anterior, ou pular o arquivo atual e passar para o próximo da lista.

  * **Buffer**

Para paginar arquivos, __more__ usa um //buffer//, isto é, uma área de memória que vai guardar o texto do arquivo. O modo como __more__ gerencia esse //buffer// é um detalhe de implementação, podendo variar. Em alguns casos, todo o conteúdo é salvo no //buffer//, em outros, ele pode manter apenas parte do arquivo, para poupar memória.

  * **Capacidades do terminal**

É possível acionar o programa __more__ a partir de diferentes tipos de terminal (ou emuladores de terminal). Cada um deles pode ter capacidades diferentes. Capacidades dizem respeito a cores suportadas, tamanhos de tela suportados, possibilidade ou não de retroceder no texto, possibilidades de formatação (negrito, itálico e sublinhado, por exemplo), dentre outras propriedades.

A depender das capacidades oferecidas pelo terminal, o programa __more__ poderá oferecer mais ou menos recursos.

  * **Comando**

Uma vez com o programa aberto, é possível enviar alguns comandos para ele. Comandos como navegar para outro arquivo (anterior, próximo ou algum arquivo cujo nome seja informado), abrir o arquivo atual em um editor de texto, pesquisar por alguma palavra ou trecho específico, dentre outros.

  * **Editor**

Uma vez com o programa __more__ aberto, é possível acionar um editor de texto para abrir o arquivo atual e possivelmente alterá-lo. Portanto nesse existe a noção de editor como o programa que vai ser usado nesse contexto (tipicamente o __vi__).

  * **Examinar**

Na especificação POSIX, o termo "examinar" é frequentemente usado, significando abrir um arquivo para leitura. Portanto, é comum falar em usar o paginador __more__ para examinar arquivos de texto.

  * **Expressão regular**

Vide [[prog:regex|expressões regulares]]. __more__ utiliza as expressões básicas (BRE) do padrão POSIX.

  * **Linhas** e **Colunas**

Tratando-se de um paginador de texto de terminal, as dimensões verticais e horizontais são dadas, respectivamente, por linhas e colunas. Colunas nesse contexto são caracteres, mais especificamente a quantidade de posições ocupadas pelos caracteres, independentemente de quantos bytes compõe cada um deles.

Caracteres //multi-byte// (geralmente os acentuados e com cedilhas) contam, cada um, como um caractere nesse contexto, mas sua interpretação dependerá do suporte a Unicode na implementação em questão. Sem esse suporte, contarão como múltiplas colunas.

O critério de divisão de linhas nesse caso é a presença de caracteres de fim de linha (//line-feed//, ou LF). Já os caracteres de retorno (//carriage-return//, ou CR) são tipicamente ignorados (podendo não ser, dependendo das opções informadas ao iniciar o programa).

  * **Marcador**

Posições dentro do texto podem ser marcadas, de modo que depois fique prático voltar para aquele ponto, se necessário.

  * **Página**

Uma página é caracterizada pela quantidade de linhas **visíveis** que cabe em uma tela. Aqui friso o "visíveis", pois uma linha do arquivo pode ser grande demais para caber na tela (isto é, possuir mais colunas do que o terminal dispõe), o que faz com que ela apareça "dobrada", ou seja, dividida em duas ou mais linhas, o quanto for necessário para caber.

  * **Pesquisa**

O paginador __more__ suporta pesquisa de texto, de modo a facilitar a navegação para ocorrências do texto pesquisado. A pesquisa pode ser feita tanto de modo afirmativo (linha que possui aquele texto) como negativa (linha que não possui), e também pode ser direcionada para a frente (da linha atual para o fim do arquivo) ou para trás (da linha anterior para o início do arquivo).

  * **Posição**

Uma posição dentro do paginador é dada por uma linha. Por exemplo, a posição 50 significa que a linha de número 50 é deve ser a primeira visível na tela.

  * **Prompt**

__more__ é uma ferramenta interativa. O modo dessa ferramenta de mostrar que está à espera de um comando do usuário (como avançar ou retroceder no texto, por exemplo) é apresentando um //prompt// ao fim da página.

Esse //prompt// consiste em um texto destacado informando o nome do arquivo que está sendo lido, e possivelmente algumas informações adicionais (como o percentual de linhas desde o início do arquivo até o ponto atual em relação ao tamanho total do arquivo).

  * **Redesenho**

Um redesenho da tela é o movimento de apagar o conteúdo atual da tela, e reescrever ou substituir por um texto diferente.

  * **Rolagem**

Uma rolagem de tela é o movimento de adicionar linhas ao fim da página (quando está avançando) ou ao topo (quando está retrocedendo) e deslizar as demais linhas para cima (ao avançar) ou para baixo (ao retroceder).

  * **Tags**

//Tags// (do inglês, etiquetas) são uma maneira de rastrear definições (de funções, de tipos e outros objetos) dentro de um arquivo de código-fonte C ou Fortran (e opcionalmente de outras linguagens). Um arquivo específico guarda as referências dessas definições, apontando para o arquivo e para o local dentro desse arquivo onde cada uma delas pode ser encontrada.

O arquivo em questão é gerado pelo utilitário [[utils:ctags|ctags]], e __more__ suporta a abertura de arquivos buscando por essas referências, o que é conveniente para a leitura de código-fonte.
===== Iniciando e encerrando =====

Iniciar o paginador __more__ é bastante simples. Basta acionar o programa, seguido (opcionalmente) pelos seus [[utils:glossario#p|parâmetros]] :?: e depois por um ou mais arquivos a serem paginados.

<code>
$ more arquivo1 arquivo2 arquivo3
</code>

Os arquivos não são abertos todos de uma vez. Apenas o primeiro deles estará visível na tela do terminal (ou seja, neste exemplo, apenas //arquivo1// estaria visível na tela, os outros só poderiam ser acessados por meio de comandos de navegação do paginador).

Antes de tratarmos sobre como navegar pelos arquivos abertos, precisamos falar sobre como encerrar o paginador. Basta digitar **q**, um //comando// que encerra o paginador, independente de você ter lido tudo ou não. Em qualquer ponto do texto, de qualquer um dos arquivos abertos para examinação, você pode acionar esse comando para encerrar o paginador.

Ao encerrar __more__, você notará que o texto continuará visível na tela.

<note tip>
A permanência do texto na tela pode ou não ser conveniente (costuma ser, quando o conteúdo do arquivo paginado é alguma informação útil para algum outro comando que deseja executar), mas caso não seja, você pode depois limpar a tela com __clear__ (ou **Ctrl** + **L**).
</note>

===== Comandos =====

...
===== Trocando de arquivos =====

...

===== Texto formatado =====

...

===== Pesquisa de texto =====

...

==== Expressões regulares ====

...

===== Marcadores =====

...

===== Passando para a edição =====

...

===== História =====

O comando __more__ surgiu no 3.0BSD, por estudantes da universidade de Berkeley (originalmente criado por Daniel Halbert, em 1978). O comando foi gradualmente aprimorado ainda nesse sistema e depois se espalhou para outros UNIX, e depois até mesmo para sistemas não UNIX.

O programa inicialmente tinha algumas limitações, como não navegar em sentido reverso. Isso fez com que perdesse a popularidade para o programa __less__, que tinha essa e outras capacidades adicionais. No entanto, __more__ virou parte do padrão POSIX, tendo em parte o padrão se baseado em __less__, e hoje __less__ é uma das implementações possíveis de __more__ (vide seção de [[#implementacoes|Implementações]]).
===== Padronização =====

O paginador __more__ é parte do padrão POSIX. Presente nas seguintes revisões:

  * [[https://pubs.opengroup.org/onlinepubs/9799919799/utilities/more.html|2024]]
  * [[https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/utilities/more.html|2018]]
  * [[https://pubs.opengroup.org/onlinepubs/9699919799.2016edition/utilities/more.html|2016]]
  * [[https://pubs.opengroup.org/onlinepubs/9699919799.2013edition/utilities/more.html|2013]]
  * [[https://pubs.opengroup.org/onlinepubs/9699919799.2008edition/utilities/more.html|2008]]

===== Implementações =====

Em alguns sistemas tipo UNIX é comum que o paginador __more__ seja apenas uma referência à ferramenta __less__, com opções de compatibilidade com o padrão. Por este motivo, a lista de implementações abaixo fica bem restrita:

  * [[https://git.kernel.org/pub/scm/utils/util-linux/util-linux.git/tree/text-utils|util-linux]] ([[https://www.man7.org/linux/man-pages/man1/more.1.html|docs]])
  * [[https://git.busybox.net/busybox/tree/util-linux/more.c|Busybox]] ([[https://www.busybox.net/downloads/BusyBox.html#more|docs]])

__less__ (aqui usado como __more__):

  * [[https://www.greenwoodsoftware.com/less/|less]] ([[https://www.man7.org/linux/man-pages/man1/less.1.html|docs]])

Nesse sentido, __less__ pode ser entendido como uma das implementações de __more__, desde que usado em modo de compatibilidade (isto é, com o uso da variável de ambiente **LESS_IS_MORE**, ou com o uso de um link simbólico para __less__ cujo nome seja "//more//"). Para mais informações, vide [[utils:less|less]].

Cabe dizer também que no OpenBSD há uma página de manual dedicada ao uso de __less__ em modo de compatibilidade com __more__:

  * [[https://man.openbsd.org/more|more]]

Existem algumas diferenças quanto ao nível de aderência dessas implementações ao padrão POSIX, sendo o modo de compatibilidade do __less__ um dos mais aderentes (sobretudo se considerarmos o suporte a __ctags__).

Além dos sistemas aderentes (totalmente ou parcialmente) ao padrão POSIX, outros sistemas também possuem o paginador __more__, com algumas diferenças inevitáveis de implementação, mas com relativa semelhança.

  * [[https://github.com/FDOS/more|FreeDOS]] ([[http://wiki.freedos.org/wiki/index.php/More|docs]])
  * [[https://reactos.org/wiki/Working_Batch_Commands#m|ReactOS]] ([[https://ss64.com/nt/more.html|docs]])
  * [[https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/more|Windows]]