sgrep - Online na nuvem

PROGRAMA:

NOME

sgrep - pesquisa um arquivo para um padrão estruturado

SINOPSE

grep [-aCcDdhiIlNnPqSsTtV] [-g opção] [-O nome do arquivo] [-o "formato"] [-p pré-processador] [-w
carbonizar Lista] [-x nome do arquivo] [-e] expressão [nome do arquivo ...]

grep [-aCcDdhiIlNnPqSsTtV] [-g opção] [-O nome do arquivo] [-o "formato"] [-p pré-processador] [-w
carbonizar Lista] [-x nome do arquivo] -f nome do arquivo [-e expressão] [nome do arquivo ...]

grep [-aCcDdhiIlNnPqSsTtV] [-g opção] [-O nome do arquivo] [-o "formato"] [-p pré-processador] [-w
carbonizar Lista] [-x nome do arquivo] -f nome do arquivo -F nome do arquivo [-e expressão]

grep -h

DESCRIÇÃO

grep (estruturada grep) é uma ferramenta para pesquisar texto arquivos e filtragem texto córregos
usando critérios estruturais. O modelo de dados do sgrep é baseado em regiões, que não são
substrings vazias de texto. Regiões são tipicamente ocorrências de strings constantes ou
elementos de texto significativos, que são reconhecíveis por meio de algumas strings de delimitação. Regiões
pode ser arbitrariamente longo, sobrepor-se arbitrariamente e aninhado arbitrariamente.

grep usa padrões chamados região expressões para expressar quais regiões do texto de entrada
saem para a saída padrão. A seleção de regiões é baseada em contenção e
ordenação condições das regiões, expressa pela expressão da região.

Região expressões são lidos por padrão primeiro do arquivo $ HOME / .sgreprc, ou se não
existe, do arquivo / usr / lib / sgreprc, e a partir da linha de comando. Comportamentos diferentes podem
ser especificado por meio de opções de linha de comando.

Entrada arquivos são processados ​​um por um (ou seja, as regiões não podem ultrapassar os limites do arquivo),
exceto se o -S bandeira é fornecida, caso em que grep pega a concatenação da entrada
arquivos como seu texto de entrada. Se nenhum arquivo de entrada for fornecido, grep lê a entrada padrão.
A entrada padrão também pode ser especificada como um arquivo de entrada, fornecendo o hífen '-' como um nome de arquivo.

As regiões selecionadas são produzidas em ordem crescente de suas posições iniciais. Se vários
as regiões de saída se sobrepõem, uma região mínima que cobre todas elas é a saída, por padrão,
em vez de produzir cada um deles separadamente.

OPÇÕES

-a Atua como um filtro: exibe as regiões correspondentes, possivelmente formatadas de acordo com o
formato de saída, intercalado com o resto do texto. (Veja a descrição de
opção -o abaixo.)

-C Exibir aviso de direitos autorais.

-c Exibe apenas a contagem das regiões que correspondem à expressão.

-D Exibir saída de progresso detalhado. OBSERVAÇÃO: Isso é usado apenas para fins de depuração
e pode não funcionar em versões futuras do sgrep.

-d Exibe cada região correspondente uma vez, mesmo se as regiões se sobrepõem ou aninham.

-e expressão
Procure no texto de entrada por ocorrências de expressão.

-f lima
Leia a expressão de região do arquivo nomeado. Nome do arquivo - refere-se a stdin.

-F nome do arquivo
Leia a lista de arquivos de entrada de nome do arquivo em vez de linha de comando

-g opção
Defina a opção do scanner. opção pode ser qualquer um dos seguintes:

sgml usar scanner SGML

html usar scanner HTML (atualmente o mesmo que scanner SGML)

xml usar scanner XML

sgml-debug
mostrar tokens SGML reconhecidos

incluir entidades
inclui automaticamente entidades do sistema

-h Mostra uma breve ajuda.

-i Ignore as distinções de maiúsculas e minúsculas nas frases.

-I Muda para o modo de indexação, quando fornecido como primeira opção

-l Formato de saída longo: preceda cada região de saída por uma linha que indica o
número ordinal da região, o nome do arquivo onde a região começa, o
comprimento da região em bytes, as posições inicial e final da região dentro do
todo o texto de entrada, a posição inicial da região dentro do arquivo que contém o
início e a posição final da região dentro do arquivo que contém o final.

-N Não adicione uma nova linha após a última região de saída.

-n Suprimir leitura $ HOME / .sgreprc or / usr / lib / sgreprc.

-O lima
Leia o formato de saída do arquivo. Veja a descrição dos formatos de saída abaixo.

-o formato
Defina o formato de saída. O formato é exibido para cada região de saída com qualquer
ocorrências dos seguintes marcadores substituídos:

%f nome do arquivo contendo o início da região

%s posição inicial da região

%e posição final da região

%l comprimento da região em bytes (ou seja, % e-% s + 1)

%i posição inicial da região no arquivo onde a região começa

%j posição final da região no arquivo onde a região termina

%r texto da região. "% r" é o formato de saída padrão.

%n obtém o número ordinal da região

-P Exibe a expressão da região (pré-processada) sem executá-la.

-p pré-processador
Inscreva-se pré-processador para a expressão de região antes de avaliá-la.

-S Modo de transmissão. Com esta opção, o sgrep considera seus arquivos de entrada como um contínuo
stream, de modo que as regiões podem se estender além dos limites do arquivo.

sgrep -S arquivo_1 ... arquivo_n

é similar a

cat arquivo_1 ... arquivo_n | sgrep

exceto que o último cria um arquivo de disco temporário do fluxo de entrada. Sgrep
pode usar muito mais memória quando executado com o -S opção, desde então não pode liberar
sua região interna lista entre o processamento de cada arquivo.

-s Formato de saída curto (padrão): não formate o texto das regiões de saída e
exibir partes sobrepostas de regiões apenas uma vez.

-T Exibe estatísticas sobre a execução.

-t Exibir o uso do tempo.

-V Exibir informações da versão.

-v Modo detalhado. Mostra o que está acontecendo.

-w carbonizar Lista
Defina a lista de caracteres usados ​​para reconhecer palavras.

-x nome do arquivo
Use o arquivo de índice fornecido em vez do scanner. Implica -S.

-- Sem mais opções.

Uma lista de opções pode ser fornecida também como o valor da variável de ambiente SGREPOPT.

SINTAXE OF EXPRESSÕES

região_expr -> basic_expr
| operador_expr

operator_expr -> region_expr ['não'] 'em' basic_expr
| region_expr ['não'] 'contendo' basic_expr
| region_expr ['não'] 'igual a' basic_expr
| region_expr 'ou' basic_expr
| region_expr 'extraindo' basic_expr
| region_expr '..' basic_expr
| region_expr '_.' basic_expr
| region_expr '._' basic_expr
| region_expr '__' basic_expr
| região_expr 'citação' basic_expr
| region_expr '_quote' basic_expr
| região_expr 'citação_' basic_expr
| region_expr '_quote_' basic_expr
| 'concat' '(' region_expr ')'
| 'interno' '(' região_expr ')'
| 'exterior' '(' região_expr ')'
| 'junção' '(' inteiro ',' expressão_regional ')'

basic_expr -> frase
| 'começar'
| 'fim'
| 'chars'
| lista_constantes
| '(' region_expr ')'

frase -> '"' char [char ...] '"'

constant_list -> '[' ']' | '[' regiões ']'

regiões -> região
| regiões da região

região -> '(' inteiro ',' inteiro ')'

Observe que as expressões de região são associativas à esquerda. Isso significa, por exemplo, que um
expressão

'" " .. " " ou ""'

avalia para as regiões começando com " " e terminando com " ", ou compreendendo apenas
a string "". Para obter as regiões que começam com " " e terminam com
seja "" ou "", deve-se indicar a ordem adequada de avaliação usando
parênteses:

" " .. (" " ou "")

As expressões também podem conter comentários, que começam com '#' e se estendem até o final do
linha. No entanto, um '#' - sinal em uma frase não inicia um comentário.

SEMÂNTICA OF EXPRESSÕES

O valor de uma expressão é um conjunto de regiões de texto de entrada que satisfazem a expressão.

Valor v (basic_expr) de uma expressão básica:

v (frase): =
o conjunto de regiões do texto de entrada cujo texto é igual ao texto da frase.

v ('iniciar'): =
um conjunto que consiste em regiões de um único caractere para a primeira posição de cada entrada
Arquivo. Se a opção -S for fornecida, o valor é um conjunto contendo uma única região que
compreende o primeiro caractere no fluxo de entrada.

v ('fim'): =
um conjunto que consiste em regiões de um único caractere para a última posição de cada entrada
Arquivo. Se a opção -S for fornecida, o valor é um conjunto contendo uma única região que
compreende o último caractere no fluxo de entrada.

v ('chars'): =
um conjunto que consiste em todas as regiões de um único caractere.

v ([ ]): =
um conjunto vazio.

v ([(s_1, e_1) (s_1, e_2) ... (s_n, e_n)]): =
um conjunto que consiste em regiões r_i para cada i = 1, ..., n, onde a posição inicial de
região r_i is si e sua posição final é e_i. As posições têm que ser
inteiros não negativos, e as regiões devem ser dadas em ordem crescente de seus
posições iniciais; regiões com posições iniciais comuns devem ser fornecidas em
ordem crescente de suas posições finais. As posições são contadas desde o primeiro
caractere de cada arquivo de entrada, a menos que a opção -S seja fornecida, caso em que o
as posições são contadas a partir do início do fluxo de entrada. O número
da primeira posição em um arquivo ou fluxo é zero.

v ('(' região_expr ')'): = v (região_expr).

Valor v (expressão_operador) de expressões de operador:

v (região_expr 'no' basic_expr): =
o conjunto das regiões em v (região_expr) que estão contidos em alguma região em
v (basic_expr). Uma região x está contido em outra região y se e somente se o
posição inicial de x é maior do que a posição inicial de y e a posição final de
x não é maior do que a posição final de y, ou a posição final de x é menor
do que a posição final de y e a posição inicial de x não é menor que o
posição inicial de y.

v (região_expr 'não' 'no' basic_expr): =
o conjunto das regiões em v (região_expr) que não estão contidos em qualquer região em
v (basic_expr).

v (região_expr 'contendo' basic_expr): =
o conjunto das regiões em v (região_expr) que contém alguma região em v (basic_expr).

v (região_expr 'não' 'contendo' basic_expr): =
o conjunto das regiões em v (região_expr) que não contêm nenhuma região em
v (basic_expr).

v (região_expr 'igual' basic_expr): =
O conjunto de regiões, que ocorrem em ambos v (região_expr) e v (basic_expr).

v (região_expr 'não igual' basic_expr): =
O conjunto de regiões, que ocorrem em v (região_expr) mas não ocorrem em
v (basic_expr).

v (região_expr 'ou' basic_expr): =
o conjunto das regiões que aparecem em v (região_expr) ou em v (basic_expr) ou em
ambos.

v (região_expr 'extraindo' basic_expr): =
o conjunto das regiões não vazias que são formadas pelas regiões em v (região_expr)
extraindo uma sobreposição com qualquer região em v (basic_expr). Por exemplo, o valor
of

'[(1,4) (3,6) (7,9)] extraindo [(2,5) (4,7)]'

consiste nas regiões (1,1) e (8,9).

v (região_expr '..' básico_expr):
O valor desta expressão consiste nas regiões que podem ser formadas por emparelhamento
regiões de v (região_expr) com regiões de v (basic_expr). O emparelhamento é
definido como uma generalização da forma como os parênteses aninhados são emparelhados
"de dentro para fora". Para isso, precisamos comparar a ordem das regiões,
que podem estar sobrepostos e aninhados. Essa ordem é definida a seguir.

Deixei x e y ser duas regiões. Dizemos que região x precede região y se o fim
posição de x é menor do que a posição inicial de y. Dizemos que região x is
mais tarde que região y se a posição final de x é maior do que a posição final de y,
ou se eles terminam na mesma posição e no início de x é maior do que o início de
y. Região x is mais cedo que região y se a posição inicial de x É menor que
a posição inicial de y, ou se eles começam na mesma posição e na posição final
of x é menor que a posição final de y. Agora uma região x da v (região_expr) e uma
região y da v (basic_expr) estão emparelhados na expressão v (região_expr '..' básico_expr)
se e apenas se

1. x precede y,

2. x não está emparelhado com nenhuma região de v (basic_expr) que é anterior a y,
e

3. y não está emparelhado com nenhuma região de v (região_expr) que é mais tarde que x.

O emparelhamento de regiões x e y forma uma região que se estende desde a posição inicial de x para
a posição final de y.

v (região_expr '._' básico_expr):
O emparelhamento das regiões de v (região_expr) e as regiões de v (basic_expr)
é definido de forma semelhante a v (região_expr '..' básico_expr) acima, exceto que o
emparelhamento de regiões x e y agora forma uma região que se estende desde a posição inicial
of x para a posição imediatamente anterior ao início de y.

v (região_expr '_.' basic_expr): =
O emparelhamento das regiões de v (região_expr) e as regiões de v (basic_expr)
é definido de forma semelhante a v (região_expr '..' básico_expr) acima, exceto que. da
emparelhamento de regiões x e y agora forma uma região que se estende desde a posição
imediatamente após a posição final de x para a posição final de y.

v (região_expr '__' basic_expr): =
O emparelhamento das regiões de v (região_expr) e as regiões de v (basic_expr)
é definido de forma semelhante a v (região_expr '..' básico_expr) acima, exceto que agora o
emparelhamento de regiões x e y forma uma região que se estende desde a posição do texto
imediatamente após o final de x para a posição do texto imediatamente anterior ao
começar de y. Possivelmente, regiões vazias resultantes são excluídas do resultado.

v (região_expr 'citar' básico_expr):
O valor desta expressão consiste nas regiões que se estendem desde o início
posição de um "citação à esquerda região"Em v (região_expr) para a posição final de um
correspondente "citação certa região"Em v (basic_expr). As regiões no resultado são
sem aninhamento e sem sobreposição. As regiões de aspas à esquerda e aspas à direita
as regiões são definidas da seguinte forma:

· A região mais antiga (veja acima) em v (região_expr) é um possível citação à esquerda
região.

· Para cada região possível de aspas à esquerda x, a primeira região em v (basic_expr)
precedido por x é sua região de aspas certas.

· Para cada região de aspas certas y in v (basic_expr), a primeira região em
v (região_expr) precedido por y é uma possível região com aspas à esquerda.

O exemplo de consulta a seguir encontra comentários de não aninhamento de estilo C:

"/*" citar "*/"

O exemplo de consulta a seguir encontra strings entre aspas:

"\"" citar "\""

(Observe a diferença na expressão "\" " .. "\" ", que avaliaria qualquer substring
de texto de entrada que começa com aspas e termina com a próxima aspa.)

As variantes _citar, citar_ e _citar_ são análogos aos operadores _., ._ e __em
a sensação de que as "citações de regiões" originam-se da expressão ao lado do
sublinhar _ são excluídos das regiões de resultado. (No caso de _citar_ qualquer possível
as regiões vazias resultantes são excluídas do resultado.)

v ('concat' '(' região_expr ')' ): =
o conjunto das regiões mais longas de texto de entrada que são cobertas pelas regiões em
v (região_expr).

v ('interno' '(' região_expr ')' ): =
o conjunto de regiões em v (região_expr) que não contêm nenhuma outra região em
v (região_expr). Observe que para qualquer expressão de região A, a expressão interno (A) is
equivalente a (A não contendo A).

v ('externo' '(' região_expr ')' ): =
o conjunto de regiões em v (região_expr) que não estão contidos em qualquer outra região em
v (região_expr). Observe que para qualquer expressão de região A, a expressão externo (A) is
equivalente a (A não in A).

v ('juntar' '(' n ',' região_expr ')' ):
O valor desta expressão é formado pelo processamento das regiões de v (region_expr)
em ordem crescente de suas posições iniciais (e em ordem crescente de fim
posições para regiões com um início comum). Cada região r produz uma região de resultado
começando no início de re estendendo-se até o final da (n-1) ésima região após
r. A operação é útil apenas com regiões não aninhadas. Especialmente, quando aplicado
para 'chars', pode ser usado para expressar condições de proximidade. Por exemplo,

'"/ *" aspas "* /" na junção (10, caracteres)'

seleciona os comentários "/ * ... * /" que têm no máximo 10 caracteres.

EXEMPLOS OF REGIÃO EXPRESSÕES

Conte o número de ocorrências da string "sort" no arquivo eval.c:

sgrep -c '"sort"' eval.c

Mostrar todos os blocos delimitados por colchetes no arquivo eval.c:

sgrep '"{" .. "}"' eval.c

Mostre os blocos mais externos que contêm "classificar" ou "aninhar":

sgrep 'outer ("{" .. "}" contendo ("classificar" ou "aninhar"))' \
avaliação.c

Mostra todas as linhas contendo "classificar", mas não "aninhar" em arquivos com uma extensão .c, precedidos por
o nome do arquivo:

sgrep -o "% f:% r" '"\ n" _. "\ n" contendo "classificar" \
não contém "ninho" '* .c

(Observe que esta consulta omitiria a primeira linha, uma vez que não possui uma nova linha anterior
caractere '\ n', e também o último, se não for encerrado por uma nova linha. Por um caminho correto
para expressar linhas de texto, consulte a definição da macro LINHA abaixo.)

Mostra o início das declarações condicionais, consistindo em "se" seguido por uma condição
entre parênteses, nos arquivos * .c. A consulta deve desconsiderar "se" está aparecendo nos comentários
"/ * ... * /" ou nas linhas de controle do compilador começando com '#':

sgrep '"se" não estiver em ("/ *" citação "* /" ou ("\ n #" .. "\ n")) \
.. ("(" .. ")") '* .c

Mostre as instruções if contendo a string "access" em sua parte da condição que aparece no
função principal do programa em arquivos de origem * .c:

sgrep '"se" não estiver em ("/ *" citação "* /" ou ("\ n #" .. "\ n")) \
.. ("(" .. ")") contendo "acesso" \
in ("main (" .. ("{" .. "}")) \
.. ("{" .. "}" ou ";") '* .c

Vemos que condições complicadas podem se tornar bastante ilegíveis. O uso de com cuidado
projetado macros pode tornar a expressão de consultas muito mais fácil. Por exemplo, pode-se dar o
abaixo das definições do processador de macro m4 em um arquivo, digamos, c.macros:

definir (BLOCK, ("{" .. "}"))
define (COMENTÁRIO, ("/ *" citação "* /"))
changecom (%)
define (CTRLINE, ("#" no início ou "\ n #"
_. ("\ n" ou fim)))
define (IF_COND, ("se" não em (COMMENT ou CTRLINE)
.. ("(" .. ")")))

Então, a consulta acima pode ser escrita de forma mais intuitiva como

sgrep -p m4 -f c.macros -e 'IF_COND contendo "acesso" \
in ("main (" .. BLOCK) .. (BLOCK ou ";") '* .c

OTIMIZAÇÃO

grep executa eliminação de subexpressão comum na expressão de consulta, de modo que recorrentes
subexpressões são avaliadas apenas uma vez. Por exemplo, em expressão

'("" ou "\ n" ou "\ t") .. ("" ou "\ n" ou "\ t")'

a subexpressão

'("" ou "\ n" ou "\ t")'

é avaliado apenas um.

DIAGNÓSTICO

O status de saída é 0 se alguma região correspondente for encontrada, 1 se nenhuma, 2 para erros de sintaxe ou
arquivos inacessíveis (mesmo se regiões correspondentes forem encontradas).

MEIO AMBIENTE

As próprias opções padrão para sgrep podem ser fornecidas como um valor da variável de ambiente
SGREPOPT. Por exemplo, executando

setenv SGREPOPT '-p m4 -o% r \ n'

faz com que sgrep aplique o pré-processador m4 à ​​expressão e exiba cada região de saída como
seguido por uma alimentação de linha.

Use sgrep online usando serviços onworks.net