sim_lisp - En ligne dans le Cloud

PROGRAMME:

Nom

sim - trouver des similitudes dans C, Java, Pascal, Modula-2, Lisp, Miranda ou des fichiers texte

SYNOPSIS

sim_c [ -[defFiMnpPRsSTv] -r N -t N -w N -o F ] déposer ... [ [ / | ] déposer ... ]
sim_c ...
sim_java ...
sim_pasc ...
sim_m2 ...
sim_lisp ...
sim_mira ...
sim_texte ...

DESCRIPTION

Sim_c lit les fichiers C filet ... et recherche des segments de texte similaires ; deux
les segments du texte du programme sont similaires s'ils ne diffèrent que par la mise en page, le commentaire, les identifiants,
et le contenu des nombres, des chaînes et des caractères. Si des tronçons de longueur suffisante sont
trouvés, ils sont signalés sur la sortie standard ; le nombre de jetons significatifs en course
est donnée entre crochets.

Sim_java fait de même pour Java, sim_pasc pour Pascale, sim_m2 pour Modula-2, sim_mira pour
Miranda, et sim_lisp pour Lisp. Sim_texte fonctionne sur du texte arbitraire et il est parfois
utile sur les scripts shell.

Le programme peut être utilisé pour trouver des morceaux de code copiés dans des
programmes (avec -s or -S), ou pour trouver du code dupliqué accidentellement dans des projets plus importants
(avec -f or -F).

Si un séparateur / or | est présent dans la liste des fichiers d'entrée, les fichiers sont divisés en un
groupe de "nouveaux" fichiers (avant le / or |) et un groupe d'"anciens" fichiers ; si il n'y a pas / or
|, tous les fichiers sont "nouveaux". Les anciens fichiers ne sont jamais comparés les uns aux autres. Voir aussi le
descriptif de la -s et -S options ci-dessous.

Étant donné que le testeur de similarité a besoin de noms de fichiers pour identifier les similitudes, il ne peut pas lire
à partir de l'entrée standard.

Il existe les options suivantes :

-d La sortie est dans un diff(1)-like format au lieu du format par défaut à 2 colonnes.

-e Chaque fichier est comparé à chaque fichier isolément ; cela trouvera toutes les similitudes
entre tous les textes impliqués, indépendamment du texte répétitif (voir `Calculer
Pourcentages' ci-dessous).

-f Les exécutions sont limitées aux segments avec des parenthèses d'équilibrage, pour isoler le potentiel
organes de routine (pas dans sim_texte).

-F Les noms des routines dans les appels doivent correspondre exactement (pas dans sim_texte).

-i Les noms des fichiers à comparer sont lus à partir de l'entrée standard, y compris un
séparateur possible / or |; les noms de fichiers doivent être un par ligne. Cette option
permet de spécifier un très grand nombre de noms de fichiers ; il diffère du @
facilité fournie par certains compilateurs en ce sens qu'elle ne gère que les noms de fichiers et ne
ne reconnaît pas les arguments d'option.

-M Les informations sur l'utilisation de la mémoire sont affichées sur la sortie d'erreur standard.

-n Les similitudes trouvées sont résumées par nom de fichier, position et taille, plutôt que par
affiché en entier.

-o F La sortie est écrite dans le fichier nommé F.

-p La sortie est donnée en pourcentages de similarité ; voir « Calcul des pourcentages » ci-dessous ;
implique -e et -s.

-P As -p mais seul le contributeur principal est affiché ; implique -e et -s.

-r N La longueur de course minimale est définie sur N unités; la valeur par défaut est de 24 jetons, sauf dans
sim_texte, où il s'agit de 8 mots.

-R Les répertoires de la liste d'entrée sont saisis de manière récursive et tous les fichiers qu'ils contiennent
participent à la comparaison.

-s Le contenu d'un fichier n'est pas comparé à lui-même (-s pour "not self").

-S Le contenu des nouveaux fichiers est comparé aux anciens fichiers uniquement - pas entre
se.

-t N En combinaison avec le -p or -P options, définit le seuil (en pourcentage) ci-dessous
quelles similitudes ne seront pas signalées ; la valeur par défaut est 1, sauf dans sim_texte,
où il est 20.

-T Une forme de sortie plus concise et uniforme est produite, qui peut être plus appropriée pour
post-traitement.

-v Imprime le numéro de version et la date de compilation sur la sortie standard, puis s'arrête.

-w N La largeur de page utilisée est définie sur N Colonnes; la valeur par défaut est 80.

-- (Une option secrète, qui imprime l'entrée telle que le vérificateur de similarité la voit, et
puis s'arrête.)

La -p l'option donne des lignes de la forme
F est constitué pour x % de matériau G
ce qui signifie que x % du texte de F peut également être trouvé dans G. Notez que cette relation n'est pas
symétrique; il est en effet tout à fait possible qu'un fichier soit composé à 100 % de texte de
un autre fichier, tandis que l'autre fichier ne comprend que 1 % du texte du premier fichier, si
leurs longueurs diffèrent suffisamment. Les -P (P majuscule) montre le principal contributeur pour
chaque fichier uniquement. Cela simplifie l'identification d'un ensemble de fichiers A[1] ... A[n], où
la concaténation de ces fichiers est également présente. Un seuil peut être défini à l'aide de la -t
option; notez que la granularité du texte reconnu est toujours régie par le -r
option ou sa valeur par défaut.

La -r L'option contrôle le nombre d'« unités » qui constituent une série. Pour les programmes qui
comparer le code du langage de programmation, une unité est un jeton lexical dans le langage pertinent ;
les commentaires et le préambule standard (inclusion de fichiers, etc.) sont ignorés et toutes les chaînes
sont considérés comme identiques. Pour sim_texte une unité est un "mot" qui est défini comme n'importe quelle séquence
d'une ou plusieurs lettres, chiffres ou caractères supérieurs à 127 (177 octaux), (pour accommoder
lettres telles que ä, , etc.).
Sim_texte accepte le texte espacé comme texte normal.

La -s et -S les options contrôlent les fichiers à comparer. Les fichiers d'entrée sont divisés en deux
groupes, nouveaux et anciens. En l'absence de ces options de contrôle, les programmes comparent les
fichiers donc (pour 4 nouveaux fichiers et 6 anciens) :
nouveau / ancien <- premier fichier
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | c/
e 2 | cc /
w 3 | ccc /
4 | cccc /
seconde / / / / / / / / / / / / /
fichier -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
j 8 | cccc /
9 | cccc /
10 | cccc /
où les cs représentent les comparaisons de fichiers, et le / la démarcation entre le nouveau et l'ancien
fichiers.
Le -s l'option réduit cela à :
nouveau / ancien <- premier fichier
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | /
e 2 | c/
w 3 | cc /
4 | ccc /
seconde / / / / / / / / / / / / /
fichier -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
j 8 | cccc /
9 | cccc /
10 | cccc /
La -S l'option réduit encore cela à :
nouveau / ancien <- premier fichier
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | /
et 2 | /
w 3 | /
4 | /
seconde / / / / / / / / / / / / /
fichier -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
j 8 | cccc /
9 | cccc /
10 | cccc /

Les programmes peuvent gérer les noms de fichiers UNICODE sous Windows. Ceci n'est pertinent que sous le
-R option, car il n'y a aucun moyen de donner des noms de fichiers UNICODE à partir de la ligne de commande.

LIMITATIONS

La saisie répétitive est le fléau de la vérification de similarité. Si nous avons un fichier contenant 4
copies de texte identique,
A1 A2 A3 A4
où les numéros ne servent qu'à distinguer les exemplaires identiques, il y a 8 identités :
A1=A2, A1=A3, A1=A4, A2=A3, A2=A4, A3=A4, A1A2=A3A4 et A1A2A3=A2A3A4. Parmi ceux-ci, seulement 3
sont significatifs : A1=A2, A2=A3 et A3=A4. Et pour un tableau de 20 lignes identiques à chacune
autre, pas inhabituel dans un programme, il y a 715 identités, dont au plus 19 sont
significative. Signaler les 715 d'entre eux est clairement inacceptable.

Pour y remédier, la recherche des identités s'effectue de la manière suivante : Pour chaque poste dans le
texte, le segment le plus grand est trouvé, dont une copie sans chevauchement se produit dans le texte
le suivre. Ce segment et sa copie sont signalés et la numérisation reprend à la position
juste après le segment. Pour l'exemple ci-dessus, cela donne les identités A1A2=A3A4
et A3=A4, ce qui est tout à fait satisfaisant, et pour N segments identiques à peu près 2 enregistrer N
les messages sont donnés.

Cela fonctionne également bien lorsque les quatre segments identiques se trouvent dans des fichiers différents :
Fichier1 : A1
Fichier2 : A2
Fichier3 : A3
Fichier4 : A4
Désormais, les segments combinés comme A1A2 ne se produisent plus et l'algorithme trouve les exécutions A1 = A2,
A2=A3 et A3=A4, pour un total de N-1 fonctionne, tout informatif.

Calculateur pourcentages
L'approche ci-dessus ne convient pas pour obtenir le pourcentage du contenu d'un fichier qui
peut être trouvé dans un autre fichier. Cela nécessite de comparer isolément chaque paire de fichiers
représenté par ac dans les matrices ci-dessus ; c'est ce que le -e option fait. Sous le -e
option un segment File1:A1, reconnu dans File2, sera à nouveau reconnu dans File3 et
Fichier4. Dans l'exemple ci-dessus, il produit les courses
Fichier1:A1=Fichier2:A2
Fichier1:A1=Fichier3:A3
Fichier1:A1=Fichier4:A4
Fichier2:A2=Fichier3:A3
Fichier2:A2=Fichier4:A4
Fichier3:A3=Fichier4:A4
pour un total de ½N(N-1) s'exécute.

ET SPACE EXIGENCES

Des précautions ont été prises pour maintenir les exigences de temps de tous les processus internes (presque)
linéaire dans les longueurs des fichiers d'entrée, en utilisant différentes tables. Si, cependant, il y a
pas assez de mémoire pour les tables, elles sont rejetées par ordre d'importance, sous lequel
conditions les algorithmes reviennent à leur nature quadratique.

Les exigences de temps sont quadratiques dans le nombre de fichiers. Cela signifie que, par exemple,
un fichier de 64 Mo traite beaucoup plus rapidement que 8000 fichiers de 8 Ko.

Le programme nécessite 6 octets de mémoire pour chaque jeton en entrée ; 2 octets par nouvelle ligne
(pas en faisant des pourcentages) ; et environ 76 octets pour chaque exécution trouvée.

EXEMPLES

L'appel
sim_c *.c
met en évidence le code en double dans le répertoire. (Il est utile de supprimer les fichiers générés
d'abord.) Un appel
sim_c -f -F *.c
peut les cerner davantage.

Un appel
sim_text -e -p -s nouveau/* / ancien/*
compare chaque fichier dans new/* à chaque fichier dans new/* et old/*, et si une paire a plus que
20% en commun, ce fait est rapporté. Habituellement, une similitude de 30 % ou plus est significative ;
inférieur à 20 % est probablement une coïncidence ; et entre les deux est douteux.

Un appel
sim_text -e -n -s -r100 nouveau/* "|" vieille/*
compare les mêmes fichiers et signale de grands segments communs. (Les | peut être utilisé comme
séparateur au lieu de / sur les systèmes où le / comme un paramètre de ligne de commande est mutilé par
l'interpréteur de commandes.)

Les deux approches sont bonnes pour la détection de plagiat.

Utilisez sim_lisp en ligne à l'aide des services onworks.net