sim_pasc - Online na nuvem

PROGRAMA:

NOME

sim - encontre semelhanças em C, Java, Pascal, Modula-2, Lisp, Miranda ou arquivos de texto

SINOPSE

sim_c [ - [defFiMnpPRsSTv] -r N -t N -w N -o F ] Arquivo ... [ [ / | ] Arquivo ... ]
sim_c ...
sim_java ...
sim_pasc ...
sim_m2 ...
sim_lisp ...
sim_mira ...
sim_texto ...

DESCRIÇÃO

sim_c lê os arquivos C lima ... e procura segmentos de texto semelhantes; dois
segmentos do texto do programa são semelhantes se diferem apenas no layout, comentário, identificadores,
e o conteúdo de números, strings e caracteres. Se alguma execução de comprimento suficiente for
encontrados, eles são relatados na saída padrão; o número de tokens significativos na execução
é fornecido entre colchetes.

sim_java faz o mesmo para Java, sim_pasc para Pascal, sim_m2 para Modula-2, sim_mira para
Miranda, e sim_lisp para Lisp. Sim_texto trabalha em texto arbitrário e é ocasionalmente
útil em scripts de shell.

O programa pode ser usado para encontrar pedaços de código copiados em supostamente não relacionados
programas (com -s or -S), ou para encontrar código duplicado acidentalmente em projetos maiores
(com -f or -F).

Se um separador / or | está presente na lista de arquivos de entrada, os arquivos são divididos em um
grupo de "novos" arquivos (antes do / or |) e um grupo de arquivos "antigos"; se não há / or
|, todos os arquivos são "novos". Arquivos antigos nunca são comparados entre si. Veja também o
descrição de -s e -S opções abaixo.

Uma vez que o testador de similaridade precisa de nomes de arquivo para localizar as semelhanças, ele não pode ler
da entrada padrão.

Existem as seguintes opções:

-d A saída está em um diff(1) formato semelhante ao em vez do formato padrão de 2 colunas.

-e Cada arquivo é comparado a cada arquivo isoladamente; isso encontrará todas as semelhanças
entre todos os textos envolvidos, independentemente do texto repetitivo (consulte `Cálculo
Porcentagens 'abaixo).

-f As execuções são restritas a segmentos com parênteses de equilíbrio, para isolar o potencial
corpos de rotina (não em sim_texto).

-F Os nomes das rotinas nas chamadas devem corresponder exatamente (não em sim_texto).

-i Os nomes dos arquivos a serem comparados são lidos a partir da entrada padrão, incluindo um
possível separador / or |; os nomes dos arquivos devem ser um por linha. Esta opção
permite que um grande número de nomes de arquivo seja especificado; difere do @
facilidade fornecida por alguns compiladores no sentido de que lida apenas com nomes de arquivos, e faz
não reconhece argumentos de opção.

-M As informações de uso de memória são exibidas na saída de erro padrão.

-n As semelhanças encontradas são resumidas por nome de arquivo, posição e tamanho, ao invés de
exibido na íntegra.

-o F A saída é gravada no arquivo denominado F.

-p A saída é fornecida em porcentagens de similaridade; veja `Calculando Porcentagens 'abaixo;
implica -e e -s.

-P As -p mas apenas o contribuidor principal é mostrado; implica -e e -s.

-r N O comprimento mínimo de execução é definido como N unidades; o padrão é 24 tokens, exceto em
sim_texto, onde são 8 palavras.

-R Os diretórios na lista de entrada são inseridos recursivamente, e todos os arquivos que eles contêm
estão envolvidos na comparação.

-s O conteúdo de um arquivo não é comparado a ele mesmo (-s para "não próprio").

-S O conteúdo dos novos arquivos é comparado apenas aos arquivos antigos - não entre
si mesmos.

-t N Em combinação com o -p or -P opções, define o limite (em porcentagem) abaixo
quais semelhanças não serão relatadas; o padrão é 1, exceto em sim_texto,
onde é 20.

-T Uma forma mais concisa e uniforme de saída é produzida, o que pode ser mais adequado para
pós-processamento.

-v Imprime o número da versão e a data de compilação na saída padrão e para.

-w N A largura da página usada é definida para N colunas; o padrão é 80.

-- (Uma opção secreta, que imprime a entrada como o verificador de similaridade a vê, e
então para.)

A -p opção resulta em linhas do formulário
F consiste em x% de material G
o que significa que x% do texto de F também pode ser encontrado em G. Observe que esta relação não é
simétrico; na verdade, é bem possível que um arquivo consista em 100% de texto de
outro arquivo, enquanto o outro arquivo consiste em apenas 1% do texto do primeiro arquivo, se
seus comprimentos diferem o suficiente. o -P (P maiúsculo) opção mostra o principal contribuinte para
cada arquivo apenas. Isso simplifica a identificação de um conjunto de arquivos A [1] ... A [n], onde
a concatenação desses arquivos também está presente. Um limite pode ser definido usando o -t
opção; observe que a granularidade do texto reconhecido ainda é governada pelo -r
opção ou seu padrão.

A -r opção controla o número de "unidades" que constituem uma corrida. Para os programas que
compare o código da linguagem de programação, uma unidade é um token léxico na linguagem pertinente;
comentário e material de preâmbulo padrão (inclusão de arquivo, etc.) são ignorados e todas as strings
são considerados iguais. Para sim_texto uma unidade é uma "palavra" que é definida como qualquer sequência
de uma ou mais letras, dígitos ou caracteres acima de 127 (177 octal), (para acomodar
letras como ä, ø, etc.).
Sim_texto aceita texto espaçado como texto normal.

A -s e -S as opções controlam quais arquivos comparar. Os arquivos de entrada são divididos em dois
grupos, novos e antigos. Na ausência dessas opções de controle, os programas comparam os
arquivos assim (para 4 novos arquivos e 6 antigos):
novo / antigo <- primeiro arquivo
1 2 3 4/5 6 7 8 9 10
| ------------ / ------------
n 1 | c/
e 2 | cc /
w 3 | ccc /
4 cccc /
segundo / / / / / / / / / / / / /
arquivo -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 cccc /
10 cccc /
onde o cs representa comparações de arquivos, e a / a demarcação entre o novo e o antigo
arquivos.
Com o -s opção reduz isso a:
novo / antigo <- primeiro arquivo
1 2 3 4/5 6 7 8 9 10
| ------------ / ------------
número 1 | /
e 2 | c/
w 3 | cc /
4 ccc /
segundo / / / / / / / / / / / / /
arquivo -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 cccc /
10 cccc /
A -S opção reduz isso ainda mais a:
novo / antigo <- primeiro arquivo
1 2 3 4/5 6 7 8 9 10
| ------------ / ------------
número 1 | /
e2 | /
w3 | /
4 /
segundo / / / / / / / / / / / / /
arquivo -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 cccc /
10 cccc /

Os programas podem lidar com nomes de arquivo UNICODE no Windows. Isso é relevante apenas sob o
-R opção, uma vez que não há como fornecer nomes de arquivo UNICODE a partir da linha de comando.

LIMITAÇÕES

A entrada repetitiva é a ruína da verificação de similaridade. Se tivermos um arquivo contendo 4
cópias de texto idêntico,
A1 A2 A3 A4
onde os números servem apenas para distinguir as cópias idênticas, existem 8 identidades:
A1 = A2, A1 = A3, A1 = A4, A2 = A3, A2 = A4, A3 = A4, A1A2 = A3A4 e A1A2A3 = A2A3A4. Destes, apenas 3
são significativos: A1 = A2, A2 = A3 e A3 = A4. E para uma mesa com 20 linhas idênticas a cada
outro, não incomum em um programa, existem 715 identidades, das quais no máximo 19 são
significativo. Reportar todos os 715 deles é claramente inaceitável.

Para remediar isso, encontrar as identidades é realizado da seguinte forma: Para cada posição no
texto, o maior segmento é encontrado, do qual uma cópia não sobreposta ocorre no texto
seguindo-o. Esse segmento e sua cópia são relatados e a digitalização continua na posição
logo após o segmento. Para o exemplo acima, isso resulta nas identidades A1A2 = A3A4
e A3 = A4, o que é bastante satisfatório, e para N segmentos idênticos aproximadamente 2 log N
mensagens são dadas.

Isso também funciona bem quando os quatro segmentos idênticos estão em arquivos diferentes:
Arquivo1: A1
Arquivo2: A2
Arquivo3: A3
Arquivo4: A4
Agora, segmentos combinados como A1A2 não ocorrem, e o algoritmo encontra as execuções A1 = A2,
A2 = A3 e A3 = A4, para um total de N-1 corre, tudo informativo.

Calculando Percentagens
A abordagem acima não é adequada para obter a porcentagem do conteúdo de um arquivo que
pode ser encontrado em outro arquivo. Isso requer a comparação isolada de cada par de arquivos
representado por ac nas matrizes acima; isso é o que -e opção faz. Debaixo de -e
opção um segmento Arquivo1: A1, reconhecido no Arquivo2, será novamente reconhecido no Arquivo3 e
Arquivo4. No exemplo acima, ele produz as corridas
Arquivo1: A1 = Arquivo2: A2
Arquivo1: A1 = Arquivo3: A3
Arquivo1: A1 = Arquivo4: A4
Arquivo2: A2 = Arquivo3: A3
Arquivo2: A2 = Arquivo4: A4
Arquivo3: A3 = Arquivo4: A4
para um total de ½N (N-1) corre.

TIME E ESPAÇO REQUISITOS

Foi tomado cuidado para manter os requisitos de tempo de todos os processos internos (quase)
linear nos comprimentos dos arquivos de entrada, usando várias tabelas. Se, no entanto, houver
não há memória suficiente para as tabelas, elas são descartadas por ordem de desimportância, sob a qual
condições os algoritmos voltam à sua natureza quadrática.

Os requisitos de tempo são quadráticos no número de arquivos. Isso significa que, por exemplo,
um arquivo de 64 MB é processado muito mais rápido do que arquivos de 8000 8 kB.

O programa requer 6 bytes de memória para cada token na entrada; 2 bytes por nova linha
(não ao fazer porcentagens); e cerca de 76 bytes para cada execução encontrada.

EXEMPLOS

A chamada
sim_c * .c
destaca o código duplicado no diretório. (É útil remover os arquivos gerados
primeiro.) Uma chamada
sim_c -f -F * .c
pode identificá-los ainda mais.

Uma chamada
sim_text -e -p -s new / * / old / *
compara cada arquivo em novo / * com cada arquivo em novo / * e antigo / *, e se algum par tiver mais que
20% em comum, esse fato é relatado. Normalmente, uma semelhança de 30% ou mais é significativa;
menor que 20% é provavelmente coincidência; e no meio é duvidoso.

Uma chamada
sim_text -e -n -s -r100 new / * "|" velho/*
compara os mesmos arquivos e relata grandes segmentos comuns. (O | pode ser usado como
separador em vez de / em sistemas onde o / como um parâmetro de linha de comando é mutilado por
o interpretador de comandos.)

Ambas as abordagens são boas para detecção de plágio.

Use sim_pasc online usando serviços onworks.net