sim_pasc - Online in de cloud

PROGRAMMA:

NAAM

sim - vind overeenkomsten in C-, Java-, Pascal-, Modula-2-, Lisp-, Miranda- of tekstbestanden

KORTE INHOUD

sim_c [ -[defFiMnpPRsSTv] -r N -t N -w N -o F ] het dossier ... [ [ / | ] het dossier ... ]
sim_c ...
sim_java ...
sim_pasc ...
sim_m2 ...
sim_lisp ...
sim_mira ...
sim_tekst ...

PRODUCTBESCHRIJVING

Sim_c leest de C-bestanden filet ... en zoekt naar tekstsegmenten die op elkaar lijken; twee
segmenten van programmatekst zijn vergelijkbaar als ze alleen verschillen in lay-out, commentaar, identifiers,
en de inhoud van cijfers, tekenreeksen en tekens. Als er runs van voldoende lengte zijn:
gevonden, worden ze gerapporteerd op standaarduitvoer; het aantal significante tokens in de run
staat tussen vierkante haken.

Sim_java doet hetzelfde voor Java, sim_pasc voor Pascal, sim_m2 voor Modula-2, sim_mira voor
Miranda, en sim_lisp voor Lisp. Sim_tekst werkt op willekeurige tekst en het is af en toe
handig voor shell-scripts.

Het programma kan worden gebruikt voor het vinden van gekopieerde stukjes code die ogenschijnlijk niets met elkaar te maken hebben
programma's (met -s or -S), of voor het vinden van per ongeluk gedupliceerde code in grotere projecten
(met -f or -F).

Als een scheidingsteken / or | aanwezig is in de lijst met invoerbestanden, zijn de bestanden onderverdeeld in a
groep "nieuwe" bestanden (vóór de / or |) en een groep "oude" bestanden; als er geen / or
|, alle bestanden zijn "nieuw". Oude bestanden worden nooit met elkaar vergeleken. Zie ook de
beschrijving van de -s en -S onderstaande opties.

Omdat de gelijkenistester bestandsnamen nodig heeft om de overeenkomsten te lokaliseren, kan het niet lezen
van standaard invoer.

Er zijn de volgende opties:

-d De uitvoer is in a diff(1)-achtige indeling in plaats van de standaard indeling met 2 kolommen.

-e Elk bestand wordt afzonderlijk met elk bestand vergeleken; dit zal alle overeenkomsten vinden
tussen alle betrokken teksten, ongeacht herhalende tekst (zie `Berekenen'
percentages' hieronder).

-f Runs zijn beperkt tot segmenten met balancerende haakjes, om potentieel te isoleren
routine-instanties (niet in sim_tekst).

-F De namen van routines in aanroepen moeten exact overeenkomen (niet in sim_tekst).

-i De namen van de te vergelijken bestanden worden uit de standaardinvoer gelezen, inclusief a
mogelijk scheidingsteken / or |; de bestandsnamen moeten één op een regel zijn. Deze optie
staat toe dat een zeer groot aantal bestandsnamen wordt gespecificeerd; het verschilt van de @
faciliteit die door sommige compilers wordt geboden doordat het alleen bestandsnamen verwerkt, en
optieargumenten niet herkennen.

-M Informatie over geheugengebruik wordt weergegeven op standaardfoutuitvoer.

-n De gevonden overeenkomsten worden samengevat op bestandsnaam, positie en grootte, in plaats van:
volledig weergegeven.

-o F De uitvoer wordt geschreven naar het bestand met de naam F.

-p De output wordt gegeven in overeenstemmingspercentages; zie 'Percentages berekenen' hieronder;
impliceert -e en -s.

-P As -p maar alleen de belangrijkste bijdrager wordt getoond; impliceert -e en -s.

-r N De minimale runlengte is ingesteld op: N eenheden; de standaard is 24 tokens, behalve in
sim_tekst, waar het 8 woorden zijn.

-R Directory's in de invoerlijst worden recursief ingevoerd en alle bestanden die ze bevatten
zijn betrokken bij de vergelijking.

-s De inhoud van een bestand wordt niet met zichzelf vergeleken (-s voor "niet zelf").

-S De inhoud van de nieuwe bestanden wordt alleen vergeleken met de oude bestanden - niet tussen
zich.

-t N In combinatie met de -p or -P opties, stelt de onderstaande drempel (in procenten) in
welke overeenkomsten niet worden gerapporteerd; de standaard is 1, behalve in sim_tekst,
waar het 20 is.

-T Er wordt een meer beknopte en uniforme vorm van output geproduceerd, die mogelijk meer geschikt is voor:
nabewerking.

-v Drukt het versienummer en de compilatiedatum af op standaarduitvoer en stopt dan.

-w N De gebruikte paginabreedte is ingesteld op N kolommen; de standaardwaarde is 80.

-- (Een geheime optie, die de invoer afdrukt zoals de gelijkeniscontrole het ziet, en
stopt dan.)

De -p optie resulteert in regels van de vorm
F bestaat voor x% uit G-materiaal
wat betekent dat x % van de tekst van F ook in G te vinden is. Merk op dat deze relatie niet is
symmetrisch; het is namelijk heel goed mogelijk dat één bestand voor 100 % uit tekst bestaat uit
een ander bestand, terwijl het andere bestand slechts voor 1% uit tekst van het eerste bestand bestaat, als
hun lengtes verschillen genoeg. De -P (hoofdletter P) optie toont de belangrijkste bijdrage voor
elk bestand alleen. Dit vereenvoudigt de identificatie van een set bestanden A[1] ... A[n], waarbij
de aaneenschakeling van deze bestanden is ook aanwezig. Een drempel kan worden ingesteld met behulp van de -t
optie; merk op dat de granulariteit van de herkende tekst nog steeds wordt bepaald door de -r
optie of de standaardinstelling.

De -r optie regelt het aantal "eenheden" dat een run vormt. Voor de programma's die
vergelijk programmeertaalcode, een eenheid is een lexicale token in de relevante taal;
commentaar en standaard preambulemateriaal (bestandsopname, enz.) wordt genegeerd en alle tekenreeksen
worden als hetzelfde beschouwd. Voor sim_tekst een eenheid is een "woord" dat wordt gedefinieerd als een willekeurige reeks
van een of meer letters, cijfers of tekens van meer dan 127 (177 octaal), (om tegemoet te komen aan)
letters zoals ä, ø, enz.).
Sim_tekst accepteert tekst met spatie als normale tekst.

De -s en -S opties bepalen welke bestanden u wilt vergelijken. Invoerbestanden zijn in tweeën verdeeld
groepen, nieuw en oud. Bij het ontbreken van deze besturingsopties vergelijken de programma's de
bestanden dus (voor 4 nieuwe bestanden en 6 oude):
nieuw / oud <- eerste bestand
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | C /
e 2 | cc /
w 3 | ccc /
4 | cccc /
tweede / / / / / / / / / / / / /
bestand -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
waarbij de cs bestandsvergelijkingen vertegenwoordigen, en de / de scheidslijn tussen nieuw en oud
bestanden.
De -s optie reduceert dit tot:
nieuw / oud <- eerste bestand
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n1 | /
e 2 | C /
w 3 | cc /
4 | ccc /
tweede / / / / / / / / / / / / /
bestand -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
De -S optie reduceert dit verder tot:
nieuw / oud <- eerste bestand
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n1 | /
e2 | /
w3 | /
4 | /
tweede / / / / / / / / / / / / /
bestand -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /

De programma's kunnen onder Windows overweg met UNICODE-bestandsnamen. Dit is alleen relevant onder de
-R optie, aangezien er geen manier is om UNICODE-bestandsnamen te geven vanaf de opdrachtregel.

Beperkingen

Herhaalde invoer is de vloek van het controleren van overeenkomsten. Als we een bestand hebben met 4
kopieën van identieke tekst,
A1 A2 A3 A4
waar de nummers alleen dienen om de identieke exemplaren te onderscheiden, zijn er 8 identiteiten:
A1=A2, A1=A3, A1=A4, A2=A3, A2=A4, A3=A4, A1A2=A3A4 en A1A2A3=A2A3A4. Hiervan slechts 3
zijn betekenisvol: A1=A2, A2=A3 en A3=A4. En voor een tafel met 20 lijnen die identiek zijn aan elk
anders, niet ongebruikelijk in een programma, zijn er 715 identiteiten, waarvan maximaal 19
zinvol. Het is duidelijk onaanvaardbaar om ze alle 715 te rapporteren.

Om dit te verhelpen, wordt het vinden van de identiteiten als volgt uitgevoerd: Voor elke positie in de
tekst, het grootste segment wordt gevonden, waarvan een niet-overlappende kopie in de tekst voorkomt
het volgen. Dat segment en zijn kopie worden gerapporteerd en het scannen wordt hervat op de positie
net na het fragment. Voor het bovenstaande voorbeeld resulteert dit in de identiteiten A1A2=A3A4
en A3=A4, wat redelijk bevredigend is, en voor N identieke segmenten ongeveer 2 inloggen N
berichten worden gegeven.

Dit werkt ook goed als de vier identieke segmenten in verschillende bestanden staan:
Bestand1: A1
Bestand2: A2
Bestand3: A3
Bestand4: A4
Nu komen gecombineerde segmenten zoals A1A2 niet voor, en het algoritme vindt de runs A1=A2,
A2=A3, en A3=A4, voor een totaal van N-1 loopt, allemaal informatief.

Berekenen percentages
De bovenstaande benadering is niet geschikt om het percentage van de inhoud van een bestand te verkrijgen dat:
vindt u in een ander bestand. Dit vereist dat elk bestandspaar afzonderlijk wordt vergeleken
weergegeven door ac in de bovenstaande matrices; dit is wat de -e optie doet. Onder de -e
optie een segment File1:A1, herkend in File2, wordt weer herkend in File3 en
Bestand4. In het bovenstaande voorbeeld produceert het de runs
Bestand1:A1=Bestand2:A2
Bestand1:A1=Bestand3:A3
Bestand1:A1=Bestand4:A4
Bestand2:A2=Bestand3:A3
Bestand2:A2=Bestand4:A4
Bestand3:A3=Bestand4:A4
voor een totaal van ½N(N-1) runs.

TIJD EN SPACE VEREISTEN

Er is voor gezorgd dat de tijdseisen van alle interne processen (bijna)
lineair in de lengte van de invoerbestanden, door gebruik te maken van verschillende tabellen. Als er echter
niet genoeg geheugen voor de tabellen, ze worden weggegooid in volgorde van onbelangrijk, waaronder:
omstandigheden keren de algoritmen terug naar hun kwadratische aard.

De tijdsvereisten zijn kwadratisch in het aantal bestanden. Dit betekent dat bijv.
een bestand van 64 MB verwerkt veel sneller dan 8000 8 kB-bestanden.

Het programma vereist 6 bytes geheugen voor elk token in de invoer; 2 bytes per nieuwe regel
(niet bij het doen van percentages); en ongeveer 76 bytes voor elke gevonden run.

Voorbeelden

Het telefoontje
sim_c *.c
markeert dubbele code in de map. (Het is handig om gegenereerde bestanden te verwijderen
eerst.) Een oproep
sim_c -f -F *.c
kan ze verder lokaliseren.

Een telefoontje
sim_text -e -p -s nieuw/* / oud/*
vergelijkt elk bestand in new/* met elk bestand in new/* en old/*, en als een paar meer heeft dan
20% gemeen, dat feit wordt gerapporteerd. Meestal is een overeenkomst van 30% of meer significant;
lager dan 20% is waarschijnlijk toeval; en daartussen is twijfelachtig.

Een telefoontje
sim_text -e -n -s -r100 nieuw/* "|" oud/*
vergelijkt dezelfde bestanden en rapporteert grote gemeenschappelijke segmenten. (De | kan worden gebruikt als een
scheidingsteken in plaats van / op systemen waar de / als een opdrachtregelparameter wordt verminkt door
de opdrachtvertolker.)

Beide benaderingen zijn goed voor plagiaatdetectie.

Gebruik sim_pasc online met behulp van onworks.net-services