sim_lisp - Online en la nube

PROGRAMA:

NOMBRE

sim: encuentra similitudes en C, Java, Pascal, Modula-2, Lisp, Miranda o archivos de texto

SINOPSIS

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

DESCRIPCIÓN

Sim_c lee los archivos C presentar ... y busca segmentos de texto que sean similares; dos
Los segmentos del texto del programa son similares si solo difieren en el diseño, comentario, identificadores,
y el contenido de números, cadenas y caracteres. Si hay tramos de longitud suficiente
encontrados, se informan en la salida estándar; la cantidad de tokens significativos en la ejecución
se da entre corchetes.

sim_java hace lo mismo con Java, sim_pasc para Pascal, sim_m2 para Modula-2, sim_mira for
Miranda y sim_lisp para Lisp. Sim_texto trabaja en texto arbitrario y ocasionalmente es
útil en scripts de shell.

El programa se puede utilizar para encontrar fragmentos de código copiados en supuestamente no relacionados
programas (con -s or -S), o para encontrar código duplicado accidentalmente en proyectos más grandes
(con -f or -F).

Si un separador / or | está presente en la lista de archivos de entrada, los archivos se dividen en un
grupo de archivos "nuevos" (antes del / or |) y un grupo de archivos "antiguos"; si no hay / or
|, todos los archivos son "nuevos". Los archivos antiguos nunca se comparan entre sí. Ver también el
descripción del -s y -S opciones a continuación.

Dado que el probador de similitudes necesita nombres de archivo para identificar las similitudes, no puede leer
desde la entrada estándar.

Existen las siguientes opciones:

-d La salida está en un diff(1) formato similar en lugar del formato predeterminado de 2 columnas.

-e Cada archivo se compara con cada archivo de forma aislada; esto encontrará todas las similitudes
entre todos los textos involucrados, independientemente del texto repetitivo (consulte `Cálculo
Porcentajes 'a continuación).

-f Las ejecuciones están restringidas a segmentos con paréntesis de equilibrio, para aislar el potencial
cuerpos de rutina (no en texto_sim).

-F Los nombres de las rutinas en las llamadas deben coincidir exactamente (no en texto_sim).

-i Los nombres de los archivos que se van a comparar se leen de la entrada estándar, incluida una
posible separador / or |; los nombres de los archivos deben ser uno por línea. Esta opción
permite especificar una gran cantidad de nombres de archivos; se diferencia de la @
facilidad proporcionada por algunos compiladores en el sentido de que solo maneja nombres de archivos, y no
no reconoce los argumentos de las opciones.

-M La información sobre el uso de la memoria se muestra en la salida de error estándar.

-n Las similitudes encontradas se resumen por nombre de archivo, posición y tamaño, en lugar de
mostrado en su totalidad.

-o F La salida se escribe en el archivo llamado F.

-p La salida se da en porcentajes de similitud; consulte "Cálculo de porcentajes" a continuación;
implica -e y -s.

-P As -p pero solo se muestra el contribuyente principal; implica -e y -s.

-r N La longitud mínima de ejecución se establece en N unidades; el valor predeterminado es 24 tokens, excepto en
texto_sim, donde son 8 palabras.

-R Los directorios de la lista de entrada se ingresan de forma recursiva y todos los archivos que contienen
están involucrados en la comparación.

-s El contenido de un archivo no se compara consigo mismo (-s para "no propio").

-S El contenido de los archivos nuevos se compara con los archivos antiguos solamente, no entre


-t N En combinación con el -p or -P opciones, establece el umbral (en porcentaje) por debajo
qué similitudes no se informarán; el valor predeterminado es 1, excepto en texto_sim,
donde es 20.

-T Se produce una forma de salida más concisa y uniforme, que puede ser más adecuada para
Postprocesamiento.

-v Imprime el número de versión y la fecha de compilación en la salida estándar y luego se detiene.

-w N El ancho de página utilizado se establece en N columnas; el valor predeterminado es 80.

-- (Una opción secreta, que imprime la entrada como la ve el verificador de similitud, y
luego se detiene.)

El sistema -p la opción da como resultado líneas del formulario
F consiste en x% de material G
lo que significa que el x% del texto de F también se puede encontrar en G. Tenga en cuenta que esta relación no es
simétrico; de hecho, es muy posible que un archivo consista en el 100% del texto de
otro archivo, mientras que el otro archivo consta de solo el 1% del texto del primer archivo, si
sus longitudes difieren bastante. los -P La opción (P mayúscula) muestra el contribuyente principal para
cada archivo solamente. Esto simplifica la identificación de un conjunto de archivos A [1] ... A [n], donde
la concatenación de estos archivos también está presente. Se puede establecer un umbral utilizando el -t
opción; tenga en cuenta que la granularidad del texto reconocido todavía se rige por la -r
opción o su valor predeterminado.

El sistema -r La opción controla el número de "unidades" que constituyen una ejecución. Para los programas que
comparar código de lenguaje de programación, una unidad es un token léxico en el lenguaje pertinente;
el comentario y el material de preámbulo estándar (inclusión de archivos, etc.) se ignoran y todas las cadenas
se consideran iguales. Para texto_sim una unidad es una "palabra" que se define como cualquier secuencia
de una o más letras, dígitos o caracteres de más de 127 (177 octal), (para acomodar
letras como ä, ø, etc.).
Sim_texto acepta texto espaciado como texto normal.

El sistema -s y -S las opciones controlan qué archivos comparar. Los archivos de entrada se dividen en dos
grupos, nuevos y viejos. En ausencia de estas opciones de control, los programas comparan
archivos así (para 4 archivos nuevos y 6 viejos):
nuevo / antiguo <- primer archivo
1 2 3 4/5 6 7 8 9 10
| ------------ / ------------
n 1 | C /
e 2 | cc /
w 3 | ccc /
4 | cccc /
segundo / / / / / / / / / / / / /
archivo -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
donde las cs representan comparaciones de archivos, y la / la demarcación entre lo nuevo y lo antiguo
archivos.
Usando el -s La opción reduce esto a:
nuevo / antiguo <- primer archivo
1 2 3 4/5 6 7 8 9 10
| ------------ / ------------
norte 1 | /
e 2 | C /
w 3 | cc /
4 | ccc /
segundo / / / / / / / / / / / / /
archivo -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
El sistema -S La opción reduce esto aún más a:
nuevo / antiguo <- primer archivo
1 2 3 4/5 6 7 8 9 10
| ------------ / ------------
norte 1 | /
mi 2 | /
w 3 | /
4 | /
segundo / / / / / / / / / / / / /
archivo -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /

Los programas pueden manejar nombres de archivos UNICODE en Windows. Esto es relevante solo bajo el
-R opción, ya que no hay forma de dar nombres de archivo UNICODE desde la línea de comando.

LIMITACIONES

La entrada repetitiva es la pesadilla de la verificación de similitudes. Si tenemos un archivo que contiene 4
copias de texto idéntico,
A1 A2 A3 A4
donde los números sirven solo para distinguir las copias idénticas, hay 8 identidades:
A1 = A2, A1 = A3, A1 = A4, A2 = A3, A2 = A4, A3 = A4, A1A2 = A3A4 y A1A2A3 = A2A3A4. De estos, solo 3
son significativos: A1 = A2, A2 = A3 y A3 = A4. Y para una tabla con 20 líneas idénticas a cada una
otras, no es inusual en un programa, hay 715 identidades, de las cuales como máximo 19 son
significativo. Informar los 715 de ellos es claramente inaceptable.

Para remediar esto, la búsqueda de identidades se realiza de la siguiente manera: Para cada posición en el
texto, se encuentra el segmento más grande, del cual ocurre una copia no superpuesta en el texto
siguiéndolo. Ese segmento y su copia se informa y el escaneo se reanuda en la posición
justo después del segmento. Para el ejemplo anterior, esto da como resultado las identidades A1A2 = A3A4
y A3 = A4, que es bastante satisfactorio, y para N segmentos idénticos aproximadamente 2 log N
se dan mensajes.

Esto también funciona bien cuando los cuatro segmentos idénticos están en archivos diferentes:
Archivo1: A1
Archivo2: A2
Archivo3: A3
Archivo4: A4
Ahora los segmentos combinados como A1A2 no ocurren, y el algoritmo encuentra las ejecuciones A1 = A2,
A2 = A3 y A3 = A4, para un total de N-1 corre, todo informativo.

Calculador porcentajes
El enfoque anterior no es adecuado para obtener el porcentaje del contenido de un archivo que
se puede encontrar en otro archivo. Esto requiere comparar de forma aislada cada par de archivos
representado por ac en las matrices anteriores; esto es lo que el -e la opción lo hace. Bajo la -e
opción un segmento File1: A1, reconocido en File2, será reconocido nuevamente en File3 y
Archivo4. En el ejemplo anterior, produce las carreras
Archivo1: A1 = Archivo2: A2
Archivo1: A1 = Archivo3: A3
Archivo1: A1 = Archivo4: A4
Archivo2: A2 = Archivo3: A3
Archivo2: A2 = Archivo4: A4
Archivo3: A3 = Archivo4: A4
para un total de ½N (N-1) carreras.

Captura de Y SPACE REQUISITOS

Se ha tenido cuidado de mantener los requisitos de tiempo de todos los procesos internos (casi)
lineal en las longitudes de los archivos de entrada, mediante el uso de varias tablas. Sin embargo, si hay
no hay suficiente memoria para las tablas, se descartan en orden de poca importancia, bajo el cual
condiciones los algoritmos vuelven a su naturaleza cuadrática.

Los requisitos de tiempo son cuadráticos en el número de archivos. Esto significa que, por ejemplo,
un archivo de 64 MB se procesa mucho más rápido que 8000 archivos de 8 kB.

El programa requiere 6 bytes de memoria para cada token en la entrada; 2 bytes por línea nueva
(no al hacer porcentajes); y alrededor de 76 bytes por cada ejecución encontrada.

EJEMPLOS

La llamada
sim_c * .c
resalta el código duplicado en el directorio. (Es útil para eliminar archivos generados
primero.) Una llamada
sim_c -f -F * .c
puede identificarlos más.

Una llamada
sim_text -e -p -s nuevo / * / antiguo / *
compara cada archivo en nuevo / * con cada archivo en nuevo / * y antiguo / *, y si algún par tiene más de ese
20% en común, ese hecho se informa. Por lo general, una similitud del 30% o más es significativa;
menos del 20% es probablemente una coincidencia; y en el medio es dudoso.

Una llamada
sim_text -e -n -s -r100 nuevo / * "|" viejo/*
compara los mismos archivos e informa grandes segmentos comunes. (Los | Puede usarse como un
separador en lugar de / en sistemas donde el / como un parámetro de la línea de comandos es destrozado por
el intérprete de comandos.)

Ambos enfoques son buenos para la detección de plagio.

Use sim_lisp en línea usando los servicios de onworks.net