Uhr
Codezeilen zählen
cloc zählt Leerzeilen, Kommentarzeilen und physische Zeilen des Quellcodes in vielen Programmiersprachen.
Neueste Version: v2.02 (2. August 2024)
cloc wechselte im September 2015 zu GitHub, nachdem es seit August 2006 unter http://cloc.sourceforge.net/ gehostet wurde.
- Schnellstart
- Überblick
- Herunterladen
- Über den Paketmanager installieren
- Stabile Veröffentlichung
- Entwicklungsversion
- Lizenz
- Warum Cloc verwenden?
- Andere Zähler
- Erstellen einer ausführbaren Windows-Datei
- Grundlegende Verwendung
- Optionen
- Anerkannte Sprachen
- Wie es funktioniert
- Erweiterte Verwendung
- Entfernen Sie Kommentare aus dem Quellcode
- Arbeiten Sie mit komprimierten Archiven
- Unterschiede
- Erstellen Sie benutzerdefinierte Sprachdefinitionen
- Kombinieren Sie Berichte
- SQL
- Benutzerdefinierte Spaltenausgabe
- Cloc in andere Skripte einbinden
- Git- und UTF8-Pfadnamen
- Sprachskalierungsfaktoren der dritten Generation
- Optionen.txt-Konfigurationsdatei
- Java-Programmschnittstelle
- Rekursionslimit für komplexe reguläre Unterausdrücke
- Einschränkungen
- Bitte um Unterstützung für weitere Sprachen
- Probleme melden
- Zitat
- Danksagungen
- Copyright
Schnellstart ▲
Schritt 1: Laden Sie cloc herunter (mehrere Methoden, siehe unten) oder führen Sie das Docker-Image von cloc aus. Für die ausführbare Windows-Datei gelten keine Anforderungen. Die Quellversion von cloc erfordert einen Perl-Interpreter und die Docker-Version von cloc erfordert eine Docker-Installation.
Schritt 2: Öffnen Sie ein Terminal ( cmd.exe unter Windows).
Schritt 3: Rufen Sie cloc auf, um Ihre Quelldateien, Verzeichnisse, Archive oder Git-Commits zu zählen. Der Name der ausführbaren Datei unterscheidet sich je nachdem, ob Sie die Entwicklungsquellversion ( cloc ), die Quelle für eine veröffentlichte Version ( cloc-2.02.pl ) oder eine ausführbare Windows-Datei ( cloc-2.02.exe ) verwenden.
Auf dieser Seite ist cloc der Oberbegriff für alle diese Elemente.
Include Security verfügt über ein YouTube-Video, das die Schritte in Aktion zeigt.
eine Datei
prompt> cloc hallo.c
1 Textdatei.
1 einzigartige Datei.
0 Dateien ignoriert.
https://github.com/AlDanial/cloc v 1,65 T=0,04 s (28,3 Dateien/s, 340,0 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
C 1 0 7 5
-------------------------------------------------- ---------------
ein Verzeichnis
Eingabeaufforderung> cloc gcc-5.2.0/gcc/c
16 Textdateien.
15 einzigartige Dateien.
3 Dateien ignoriert.
https://github.com/AlDanial/cloc v 1,65 T=0,23 s (57,1 Dateien/s, 188914,0 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
C 10 4680 6621 30812
C/C++-Header 3 99 286 496
-------------------------------------------------- ---------------
SUMME: 13 4779 6907 31308
-------------------------------------------------- ---------------
ein Archiv
Wir rufen die Quell-ZIP-Datei von cloc von GitHub ab und zählen dann den Inhalt:
Eingabeaufforderung> wget https://github.com/AlDanial/cloc/archive/master.zip
Eingabeaufforderung> cloc master.zip
https://github.com/AlDanial/cloc v 1,65 T=0,07 s (26,8 Dateien/s, 141370,3 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
Perl 2 725 1103 8713
-------------------------------------------------- ---------------
SUMME: 2 725 1103 8713
-------------------------------------------------- ---------------
ein Git-Repository, das einen bestimmten Commit verwendet
Dieses Beispiel verwendet Code von PuDB, einem fantastischen Python-Debugger.
Eingabeaufforderung> Git-Klon https://github.com/inducer/pudb.git
Eingabeaufforderung> cd pudb
Eingabeaufforderung> cloc 6be804e07a5db
48 Textdateien.
41 einzigartige Dateien.
8 Dateien ignoriert.
github.com/AlDanial/cloc v 1,99 T=0,04 s (1054,9 Dateien/s, 189646,8 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
Python 28 1519 728 4659
reStructuredText 6 102 20 203
YAML 2 9 2 75
Bourne Shell 3 6 0 17
Text 1 0 0 11
Machen Sie 1 4 6 10
-------------------------------------------------- ---------------
SUMME: 41 1640 756 4975
-------------------------------------------------- ---------------
jedes Unterverzeichnis eines bestimmten Verzeichnisses
Angenommen, Sie haben ein Verzeichnis mit drei verschiedenen von Git verwalteten Projekten: Project0, Project1 und Project2. Sie können die Schleifenfunktion Ihrer Shell nutzen, um den Code in jedem zu zählen. In diesem Beispiel wird Bash verwendet (scrollen Sie nach unten für das cmd.exe-Beispiel):
prompt> für d in ./*/ ; do (cd "$d" && echo "$d" && cloc --vcs git); Erledigt
./Projekt0/
7 Textdateien.
7 einzigartige Dateien.
1 Datei ignoriert.
github.com/AlDanial/cloc v 1,71 T=0,02 s (390,2 Dateien/s, 25687,6 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
D 4 61 32 251
Abschlag 1 9 0 38
mach 1 0 0 4
-------------------------------------------------- ---------------
SUMME: 6 70 32 293
-------------------------------------------------- ---------------
./Projekt1/
7 Textdateien.
7 einzigartige Dateien.
0 Dateien ignoriert.
github.com/AlDanial/cloc v 1,71 T=0,02 s (293,0 Dateien/s, 52107,1 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
Rufen Sie 7 165 282 798 an
-------------------------------------------------- ---------------
SUMME: 7 165 282 798
-------------------------------------------------- ---------------
./Projekt2/
49 Textdateien.
47 einzigartige Dateien.
13 Dateien ignoriert.
github.com/AlDanial/cloc v 1,71 T=0,10 s (399,5 Dateien/s, 70409,4 Zeilen/s)
-------------------------------------------------- ---------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------
Python 33 1226 1026 3017
C 4 327 337 888
Abschlag 1 11 0 28
YAML 1 0 2 12
-------------------------------------------------- ---------------
SUMME: 39 1564 1365 3945
-------------------------------------------------- ---------------
jedes Unterverzeichnis eines bestimmten Verzeichnisses (Windows/cmd.exe)
for /D %I in (.*) do cd %I && cloc --vcs git && cd ..
Übersicht ▲
cloc zählt Leerzeilen, Kommentarzeilen und physische Zeilen des Quellcodes in vielen Programmiersprachen. Bei zwei Versionen einer Codebasis kann cloc Unterschiede in Leer-, Kommentar- und Quellzeilen berechnen. Es ist vollständig in Perl geschrieben, ohne Abhängigkeiten außerhalb der Standarddistribution von Perl v5.6 und höher (Code einiger externer Module ist in cloc eingebettet) und daher recht portabel. cloc läuft bekanntermaßen auf vielen Varianten von Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX, z/OS und Windows. (Um die Perl-Quellversion von cloc unter Windows auszuführen, benötigt man ActiveState Perl 5.6.1 oder höher, Strawberry Perl, Windows-Subsystem für Linux, Cygwin, MobaXTerm mit installiertem Perl-Plug-in oder eine Mingw-Umgebung und ein Terminal, wie sie von bereitgestellt werden Git für Windows kann alternativ die mit PAR::Packer generierte Windows-Binärdatei von cloc verwenden, um auf Windows-Computern zu laufen, die weder Perl noch Cygwin haben.)
Zusätzlich zum Zählen von Code in einzelnen Textdateien, Verzeichnissen und Git-Repositorys kann cloc auch Code in Archivdateien wie .tar (einschließlich komprimierter Versionen), .zip , Python Wheel .whl , Jupyter Notebook .ipynb und Quell-RPMs zählen .rpm oder .src (erfordert rpm2cpio ) und Debian .deb Dateien (erfordert dpkg-deb ).
cloc enthält Code aus David Wheelers SLOCCount, Damian Conway und Abigails Perl-Modul Regexp::Common, Sean M. Burkes Perl-Modul Win32::Autoglob und Tye McQueens Perl-Modul Algorithm::Diff. Sprachskalierungsfaktoren wurden von der Website von Mayes Consulting, LLC http://softwareestimator.com/IndustryData2.htm abgeleitet.
Neue Veröffentlichungen erscheinen nominell alle sechs Monate.
Über Docker ausführen
docker run --rm -v $PWD :/tmp aldanial/cloc
Über Docker auf Git-Bash ausführen
docker run --rm -v " / $( pwd -W ) " :/tmp aldanial/cloc
Über den Paketmanager installieren
Abhängig von Ihrem Betriebssystem funktioniert möglicherweise eine dieser Installationsmethoden für Sie (alle bis auf die letzten beiden Einträge für Windows erfordern einen Perl-Interpreter):
npm install -g cloc # https://www.npmjs.com/package/cloc
sudo apt install cloc # Debian, Ubuntu
sudo yum install cloc # Red Hat, Fedora
sudo dnf install cloc # Fedora 22 or later
sudo pacman -S cloc # Arch
sudo emerge -av dev-util/cloc # Gentoo https://packages.gentoo.org/packages/dev-util/cloc
sudo apk add cloc # Alpine Linux
doas pkg_add cloc # OpenBSD
sudo pkg install cloc # FreeBSD
sudo port install cloc # macOS with MacPorts
brew install cloc # macOS with Homebrew
winget install AlDanial.Cloc # Windows with winget
choco install cloc # Windows with Chocolatey
scoop install cloc # Windows with Scoop
Hinweis : Ich kontrolliere keines dieser Pakete. Wenn Sie bei Verwendung eines der oben genannten Pakete auf einen Fehler in cloc stoßen, versuchen Sie es mit cloc aus der neuesten stabilen Version hier auf GitHub (Link folgt unten), bevor Sie einen Problembericht einreichen.
Stabile Veröffentlichung
https://github.com/AlDanial/cloc/releases/latest
Entwicklungsversion
https://github.com/AlDanial/cloc/raw/master/cloc
Lizenz ▲
cloc ist unter der GNU General Public License, Version 2, lizenziert, mit Ausnahme von Teilen, die aus anderen Quellen kopiert wurden. Aus den Perl-Modulen Regexp::Common, Win32::Autoglob und Algorithm::Diff kopierter Code unterliegt der Artistic License.
Warum Cloc verwenden? ▲
cloc verfügt über viele Funktionen, die es einfach zu verwenden, umfassend, erweiterbar und portabel machen:
- Liegt als einzelne, eigenständige Datei vor, die nur minimalen Installationsaufwand erfordert – laden Sie einfach die Datei herunter und führen Sie sie aus.
- Kann Sprachkommentardefinitionen aus einer Datei lesen und somit möglicherweise mit Computersprachen arbeiten, die noch nicht existieren.
- Ermöglicht die Zusammenfassung der Ergebnisse mehrerer Durchläufe nach Sprache und Projekt.
- Kann Ergebnisse in einer Vielzahl von Formaten erzeugen: einfacher Text, Markdown, SQL, JSON, XML, YAML, durch Kommas getrennte Werte.
- Kann Code in komprimierten Archiven zählen (Tar-Balls, Zip-Dateien, Java-.ear-Dateien).
- Verfügt über zahlreiche Optionen zur Fehlerbehebung.
- Behandelt Datei- und Verzeichnisnamen mit Leerzeichen und anderen ungewöhnlichen Zeichen.
- Hat keine Abhängigkeiten außerhalb der Standard-Perl-Distribution.
- Läuft auf Linux-, FreeBSD-, NetBSD-, OpenBSD-, macOS-, AIX-, HP-UX-, Solaris-, IRIX- und z/OS-Systemen mit Perl 5.6 oder höher. Die Quellversion läuft unter Windows entweder mit dem ActiveState Perl-, Strawberry Perl-, Cygwin- oder MobaXTerm+Perl-Plugin. Alternativ kann man unter Windows die Windows-Binärdatei ausführen, die keine Abhängigkeiten aufweist.
Andere Zähler ▲
Wenn cloc nicht Ihren Anforderungen entspricht, sollten Sie folgende andere frei verfügbare Zähler in Betracht ziehen:
- loc
- gcloc
- gocloc
- Ohcount
- scc
- sclc
- SLOCCount
- Sonar
- Tokei
- Einheitliche Codeanzahl
Weitere Referenzen:
- QSMs Verzeichnis der Code-Zähltools.
- Der Wikipedia-Eintrag für Quellcodezeilen zählt.
Regexp::Common, Digest::MD5, Win32::Autoglob, Algorithm::Diff
Obwohl cloc keine Perl-Module außerhalb der in der Standarddistribution enthaltenen benötigt, ist cloc auf einige externe Module angewiesen. Code aus drei dieser externen Module – Regexp::Common, Win32::Autoglob und Algorithm::Diff – ist in cloc eingebettet. Ein viertes Modul, Digest::MD5, wird nur verwendet, wenn es verfügbar ist. Wenn cloc Regexp::Common oder Algorithm::Diff lokal installiert findet, wird diese Installation verwendet. Ist dies nicht der Fall, installiert cloc die benötigten Teile von Regexp::Common und/oder Algorithm:Diff in temporären Verzeichnissen, die zu Beginn eines cloc-Laufs erstellt und nach Abschluss des Laufs entfernt werden. Der notwendige Code aus Regexp::Common v2.120 und Algorithm::Diff v1.1902 ist in den Cloc-Quellcode eingebettet (siehe Unterroutinen Install_Regexp_Common() und Install_Algorithm_Diff() ). Von Win32::Autoglob werden nur drei Zeilen benötigt und diese werden direkt in cloc eingebunden.
Darüber hinaus verwendet cloc Digest::MD5, um die Eindeutigkeit zwischen Eingabedateien gleicher Größe zu überprüfen, wenn Digest::MD5 lokal installiert ist.
Eine parallele Verarbeitungsoption, --processes= N , wurde mit cloc Version 1.76 eingeführt, um schnellere Ausführungen auf Multi-Core-Maschinen zu ermöglichen. Um es nutzen zu können, muss jedoch das Modul Parallel::ForkManager installiert sein. Dieses Modul funktioniert unter Windows nicht zuverlässig, daher funktioniert die Parallelverarbeitung nur auf Unix-ähnlichen Betriebssystemen.
Die Windows-Binärdatei wird auf einem Computer erstellt, auf dem sowohl Regexp::Common als auch Digest::MD5 lokal installiert sind.
Erstellen einer ausführbaren Windows-Datei ▲
Erstellen Sie Ihre eigene ausführbare Datei
Die robusteste Option zum Erstellen einer ausführbaren Windows-Datei von cloc ist die Verwendung des Perl Development Kit von ActiveState. Es enthält ein Dienstprogramm perlapp , mit dem eigenständige Windows-, Mac- und Linux-Binärdateien aus Perl-Quellcode erstellt werden können.
perl2exe wird auch den Zweck erfüllen. Wenn Sie über perl2exe verfügen, ändern Sie die Zeilen 84–87 im Cloc-Quellcode für eine geringfügige Codeänderung, die erforderlich ist, um eine Cloc-Windows-Datei ausführbar zu machen.
Andernfalls installieren Sie zum Erstellen einer ausführbaren Windows-Datei mit pp aus PAR::Packer zunächst eine Windows-basierte Perl-Distribution (z. B. Strawberry Perl oder ActivePerl) und befolgen Sie deren Anweisungen. Öffnen Sie als Nächstes eine Eingabeaufforderung, auch DOS-Fenster genannt, und installieren Sie das PAR::Packer-Modul. Rufen Sie abschließend den neu installierten pp -Befehl mit dem cloc-Quellcode auf, um eine .exe Datei zu erstellen:
C:> cpan -i Digest::MD5
C:> cpan -i Regexp::Common
C:> cpan -i Algorithmus::Diff
C:> cpan -i PAR::Packer
C:> cpan -i Win32::LongPath
C:> pp -M Win32::LongPath -M Encode::Unicode -M Digest::MD5 -c -x -o cloc-2.02.exe cloc-2.02.pl
Eine Variante der obigen Anweisungen besteht darin, dass Sie, wenn Sie die portable Version von Strawberry Perl installiert haben, zuerst portableshell.bat ausführen müssen, um Ihre Umgebung ordnungsgemäß einzurichten.
Die ausführbare Windows-Datei im Abschnitt „Releases“, cloc-2.02.exe , wurde auf einem 64-Bit-Windows 10-Computer mit Strawberry Perl 5.30.2 und PAR::Packer zum Erstellen der .exe erstellt.
Ist die Ausführung der ausführbaren Windows-Datei sicher? Enthält es Schadsoftware?
Im Idealfall benötigt niemand die ausführbare Windows-Datei, da auf seinen Computern ein Perl-Interpreter installiert ist und die Cloc-Quelldatei ausgeführt werden kann. Auf zentral verwalteten Windows-Unternehmensrechnern kann dies jedoch schwierig oder unmöglich sein.
Die mit cloc vertriebene ausführbare Windows-Datei wird als Best-Effort-Version einer viren- und Malware-freien .exe bereitgestellt. Wir empfehlen Ihnen, Ihre eigenen Virenscanner für die ausführbare Datei auszuführen und auch Websites wie https://www.virustotal.com/ zu überprüfen. Die Einträge für aktuelle Versionen sind:
cloc-2.02-winget.exe: (enthält PR 850, um die Ausführung über einen Symlink unter Windows zu ermöglichen) https://www.virustotal.com/gui/file/be033061e091fea48a5bc9e8964cee0416ddd5b34bd5226a1c9aa4b30bdba66a?nocache=1
cloc-2.02.exe: https://www.virustotal.com/gui/file/369ed76125f7399cd582d169adf39a2e08ae5066031fea0cc8b2836ea50e7ce2?nocache=1
cloc-2.00.exe: https://www.virustotal.com/gui/file/7a234ef0cb495de1b5776acf88c5554e2bab1fb02725a5fb85756a6db3121c1f
cloc-1.98.exe: https://www.virustotal.com/gui/file/88615d193ec8c06f7ceec3cc1d661088af997798d87ddff331d9e9f9128a6782?nocache=1
cloc-1.96.1.exe: https://www.virustotal.com/gui/file/00b1c9dbbfb920dabd374418e1b86d2c24b8cd2b8705aeb956dee910d0d75d45?nocache=1
cloc-1.96.exe: https://www.virustotal.com/gui/file/54bf5f46fbaba7949c4eb2d4837b03c774c0ba587448a5bad9b8efc0222b1583?nocache=1
cloc-1.94.exe: https://www.virustotal.com/gui/file/b48a6002fb75fa66ec5d0c05a5c4d51f2ad22b5b025b7eb4e3945d18419c0952?nocache=1
cloc-1.92.exe: https://www.virustotal.com/gui/file/2668fcf8609c431e8934fe9e1866bc620c58d198c4eb262f1d3ef31ef4a690f7
cloc-1.90.exe: https://www.virustotal.com/gui/file/d655caae55486f9bac39f7e3c7b7553bcfcfe2b88914c79bfc328055f22b8a37/detection
cloc-1.88.exe: https://www.virustotal.com/gui/file/97d5d2631d1cccdbfd99267ab8a4cf5968816bbe52c0f9324e72e768857f642d/detection
cloc-1.86.exe: https://www.virustotal.com/gui/file/1b2e189df1834411b34534db446330d1c379b4bc008af3042ee9ade818c6a1c8/detection
cloc-1.84.exe: https://www.virustotal.com/gui/file/e73d490c1e4ae2f50ee174005614029b4fa2610dcb76988714839d7be68479af/detection
cloc-1.82.exe: https://www.virustotal.com/#/file/2e5fb443fdefd776d7b6b136a25e5ee2048991e735042897dbd0bf92efb16563/detection
cloc-1.80.exe: https://www.virustotal.com/#/file/9e547b01c946aa818ffad43b9ebaf05d3da08ed6ca876ef2b6847be3bf1cf8be/detection
cloc-1.78.exe: https://www.virustotal.com/#/file/256ade3df82fa92febf2553853ed1106d96c604794606e86efd00d55664dd44f/detection
cloc-1.76.exe: https://www.virustotal.com/#/url/c1b9b9fe909f91429f95d41e9a9928ab7c58b21351b3acd4249def2a61acd39d/detection
cloc-1.74_x86.exe: https://www.virustotal.com/#/file/b73dece71f6d3199d90d55db53a588e1393c8dbf84231a7e1be2ce3c5a0ec75b/detection
cloc 1.72 exe: https://www.virustotal.com/en/url/8fd2af5cd972f648d7a2d7917bc202492012484c3a6f0b48c8fd60a8d395c98c/analysis/
cloc 1.70 exe: https://www.virustotal.com/en/url/63edef209099a93aa0be1a220dc7c4c7ed045064d801e6d5daa84ee624fc0b4a/analysis/
cloc 1.68 exe: https://www.virustotal.com/en/file/c484fc58615fc3b0d5569b9063ec1532980281c3155e4a19099b11ef1c24443b/analysis/
cloc 1.66 exe: https://www.virustotal.com/en/file/54d6662e59b04be793dd10fa5e5edf7747cf0c0cc32f71eb67a3cf8e7a171d81/analysis/1453601367/
Warum ist die ausführbare Windows-Datei so groß?
Ausführbare Windows-Dateien der cloc-Versionen 1.60 und früher, die wie oben erwähnt mit perl2exe erstellt wurden, sind etwa 1,6 MB groß, während die Versionen 1.62 und 1.54, die mit PAR::Packer erstellt wurden, 11 MB groß sind. Version 1.66, erstellt mit einer neueren Version von PAR::Packer , ist etwa 5,5 MB groß. Warum sind die ausführbaren PAR::Packer -Dateien so viel größer als die mit perl2exe erstellten? Meine Theorie ist, dass perl2exe eine intelligentere Baumbereinigungslogik verwendet als PAR::Packer , aber das ist reine Spekulation.
Grundlegende Verwendung ▲
cloc ist ein Befehlszeilenprogramm, das Datei-, Verzeichnis- und/oder Archivnamen als Eingaben akzeptiert. Hier ist ein Beispiel für die Ausführung von cloc für die Perl v5.22.0-Quelldistribution:
Eingabeaufforderung> cloc perl-5.22.0.tar.gz
5605 Textdateien.
5386 einzigartige Dateien.
2176 Dateien ignoriert.
https://github.com/AlDanial/cloc v 1,65 T=25,49 s (134,7 Dateien/s, 51980,3 Zeilen/s)
-------------------------------------------------- ---------------------------------
Sprachdateien leerer Kommentarcode
-------------------------------------------------- ---------------------------------
Perl 2892 136396 184362 536445
C 130 24676 33684 155648
C/C++-Header 148 9766 16569 147858
Bourne Shell 112 4044 6796 42668
Pascal 8 458 1603 8592
XML 33 142 0 2410
YAML 49 20 15 2078
C++ 10 313 277 2033
Machen Sie 4 426 488 1986
Prolog 12 438 2 1146
JSON 14 1 0 1037
yacc 1 85 76 998
Windows-Nachrichtendatei 1 102 11 489
DOS-Charge 14 92 41 389
Windows-Ressourcendatei 3 10 0 85
D 1 5 7 8
Lisp 2 0 3 4
-------------------------------------------------- ---------------------------------
SUMME: 3434 176974 243934 903874
-------------------------------------------------- ---------------------------------
Um cloc auf Windows-Computern auszuführen, öffnen Sie ein Befehlsfenster (auch bekannt als DOS) und rufen Sie dort cloc.exe über die Befehlszeile auf. Alternativ können Sie ClocViewer ausprobieren, den GUI-Wrapper rund um cloc, den Sie unter https://github.com/Roemer/ClocViewer finden.
Siehe auch https://github.com/jmensch1/codeflower für eine grafische Darstellung der Cloc-Ergebnisse.
Optionen ▲
prompt> cloc --help
Verwendung: cloc [Optionen] | |
Zählen oder berechnen Sie Unterschiede zwischen physischen Quellcodezeilen im
bestimmte Dateien (kann Archive wie komprimierte Tarballs oder ZIP-Dateien sein,
oder Git-Commit-Hashes oder Zweignamen) und/oder rekursiv unterhalb des
angegebene Verzeichnisse.
Eingabeoptionen
--extract-with= Diese Option wird nur benötigt, wenn cloc nicht möglich ist
um herauszufinden, wie man den Inhalt extrahiert
die Eingabedatei(en) selbst.
Verwenden Sie , um binäre Archivdateien zu extrahieren (z. B.:
.tar.gz, .zip, .Z). Verwenden Sie das Literal „>FILE<“ als
ein Ersatz für die eigentliche(n) Datei(en).
extrahiert. Zum Beispiel, um Codezeilen zu zählen
in den Eingabedateien
gcc-4.2.tar.gz perl-5.8.8.tar.gz
auf Unix-Nutzung
--extract-with='gzip -dc >DATEI< | tar xf -'
oder, wenn Sie GNU tar haben,
--extract-with='tar zxf >DATEI<'
und unter Windows verwenden Sie zum Beispiel:
--extract-with=""c:Program FilesWinZipWinZip32.exe" -e -o >FILE< ."
(sofern WinZip dort installiert ist).
--list-file= Nimmt die Liste der Datei- und/oder Verzeichnisnamen auf
Prozess aus , die eine Datei/ein Verzeichnis enthält
Name pro Zeile. Es werden nur exakte Übereinstimmungen gezählt;
Relative Pfadnamen werden ab aufgelöst
das Verzeichnis, in dem cloc aufgerufen wird. festlegen
to – um Dateinamen aus einer STDIN-Pipe zu lesen.
Siehe auch --exclude-list-file.
--diff-list-file= Nimmt die Dateinamenpaare, von denen unterschieden werden soll
, deren Format mit der Ausgabe von übereinstimmt
--diff-alignment. (Mit dieser Option ausführen, um
siehe Beispiel.) Die Sprachkennung am
Das Ende jeder Zeile wird ignoriert. Dadurch wird --diff aktiviert
Modus und umgeht die Dateipaar-Ausrichtungslogik.
--vcs= Rufen Sie einen Systemaufruf an auf, um eine Liste von zu erhalten
Dateien, an denen gearbeitet werden soll. Wenn „git“ ist, dann wird es so sein
Rufen Sie „git ls-files“ auf, um eine Dateiliste zu erhalten und
„git submodule status“, um eine Liste der Submodule zu erhalten
deren Inhalt ignoriert wird. Siehe auch --git
welches Git-Commit-Hashes und Zweignamen akzeptiert.
Wenn „svn“ ist, wird „svn list -R“ aufgerufen.
Der Hauptvorteil besteht darin, dass cloc dann überspringt
Dateien, die vom Versionierungstool explizit ausgeschlossen wurden
in Frage, also diejenigen in .gitignore oder die
svn:ignore-Eigenschaft.
Alternativ kann ein beliebiger Systembefehl sein
das eine Liste von Dateien generiert.
Hinweis: cloc muss sich in einem Verzeichnis befinden, das gelesen werden kann
die Dateien, wie sie von zurückgegeben werden. cloc wird
Laden Sie keine Dateien aus Remote-Repositorys herunter.
„svn list -R“ kann sich auf ein Remote-Repository beziehen
um Dateinamen zu erhalten (und daher möglicherweise erforderlich
Authentifizierung gegenüber dem Remote-Repository), aber
Die Dateien selbst müssen lokal sein.
Wenn Sie auf „Auto“ setzen, wird zwischen „Git“ und „Git“ ausgewählt.
und 'svn' (oder keines von beiden), abhängig von der Anwesenheit
eines .git- oder .svn-Unterverzeichnisses unterhalb des Verzeichnisses
wo cloc aufgerufen wird.
--unicode Überprüft Binärdateien, um festzustellen, ob sie Unicode enthalten
erweiterter ASCII-Text. Dies führt zu Leistungseinbußen
fallen merklich ab.
Verarbeitungsmöglichkeiten
--autoconf Anzahl der .in-Dateien (wie von GNU Autoconf verarbeitet).
anerkannte Sprachen. Siehe auch --no-autogen.
--by-file Berichtsergebnisse für jede gefundene Quelldatei.
--by-file-by-lang Berichtet Ergebnisse für jede gefundene Quelldatei
zusätzlich zur Berichterstattung nach Sprache.
--config Befehlszeilenschalter aus lesen statt
der Standardspeicherort von /home/al/.config/cloc/options.txt.
Die Datei sollte zusammen mit einen Schalter enthalten
Argumente (falls vorhanden) pro Zeile. Leerzeilen und Zeilen
die mit „#“ beginnen, werden übersprungen. Optionen gegeben am
Die Befehlszeile hat Vorrang vor den gelesenen Einträgen
die Datei.
--count-and-diff
Führen Sie zunächst eine direkte Codezählung der Quelldatei(en) durch.
von und separat, dann führen Sie einen Diff durch
davon. Eingaben können Paare von Dateien, Verzeichnissen usw. sein.
oder Archive. Wenn --out oder --report-file angegeben ist,
Es werden drei Ausgabedateien erstellt, jeweils eine
der beiden Zählungen und eine für den Diff. Siehe auch
--diff, --diff-alignment, --diff-timeout,
--ignore-case, --ignore-whitespace.
--diff Berechnet Unterschiede im Code und in den Kommentaren zwischen
Quelldatei(en) von und . Die Eingänge
kann eine beliebige Mischung aus Dateien, Verzeichnissen, Archiven usw. sein.
oder Git-Commit-Hashes. Verwenden Sie --diff-alignment, um
Erzeugen Sie eine Liste, die zeigt, welche Dateipaare sich wo befinden
verglichen. Beim Vergleich von Git-Branches nur Dateien
die sich in einem der beiden Commits geändert haben, werden verglichen.
Siehe auch --git, --count-and-diff, --diff-alignment,
--diff-list-file, --diff-timeout, --ignore-case,
--ignore-whitespace.
--diff-timeout Ignoriert Dateien, die länger als Sekunden dauern
zu verarbeiten. Der Standardwert beträgt 10 Sekunden. Einstellung
auf 0 ermöglicht unbegrenzte Zeit. (Große Dateien mit vielen
Wiederholte Zeilen können Algorithm::Diff::sdiff() verursachen
kann Stunden dauern.) Siehe auch --timeout.
--docstring-as-code cloc betrachtet Dokumentzeichenfolgen als Kommentare, dies ist jedoch der Fall
nicht immer korrekt, da Dokumentzeichenfolgen regulär darstellen
Zeichenfolgen, wenn sie auf der rechten Seite eines erscheinen
Zuweisung oder als Funktionsargumente. Dieser Schalter
erzwingt, dass Dokumentzeichenfolgen als Code gezählt werden.
--follow-links [nur Unix] Folgen Sie symbolischen Links zu Verzeichnissen
(Sym-Links zu Dateien werden immer befolgt).
Siehe auch --stat.
--force-lang=[,]
Verarbeiten Sie alle Dateien mit der Erweiterung
mit dem Zähler für Sprache . Für
Um beispielsweise alle .f-Dateien mit dem zu zählen
Fortran 90-Zähler (der Dateien erwartet
endet mit .f90) anstelle des Standard-Fortran 77
Zähler, Gebrauch
--force-lang="Fortran 90,f"
Wenn weggelassen wird, wird jede Datei gezählt
mit dem -Zähler. Diese Option kann sein
mehrfach angegeben (aber das ist nur
nützlich, wenn jedes Mal angegeben wird).
Siehe auch --script-lang, --lang-no-ext.
--force-lang-def= Sprachverarbeitungsfilter aus laden,
Verwenden Sie dann diese Filter anstelle der integrierten
Filter. Hinweis: Sprachen, die denselben Sprachen zugeordnet sind
Dateierweiterung (zum Beispiel:
MATLAB/Mathematica/Objective-C/MUMPS/Mercury;
Pascal/PHP; Lisp/OpenCL; Lisp/Julia; Perl/Prolog)
werden ignoriert, da diese zusätzliche erfordern
Verarbeitung, die nicht in Sprache ausgedrückt wird
Definitionsdateien. Verwenden Sie zum Definieren --read-lang-def
Neue Sprachfilter, ohne die integrierten zu ersetzen
Filter (siehe auch --write-lang-def,
--write-lang-def-incl-dup).
--git Erzwingt, dass die Eingaben als Git-Ziele interpretiert werden
(Hashes, Zweignamen usw. festschreiben), wenn diese
werden zunächst nicht als Datei oder Verzeichnis identifiziert
Namen. Diese Option überschreibt die Logik --vcs=git
wenn dies gegeben ist; mit anderen Worten: --git bekommt es
Liste der Dateien, an denen direkt von Git aus gearbeitet werden soll
den Hash- oder Zweignamen und nicht von
'git ls-files'. Diese Option kann mit verwendet werden
--diff, um Zeilenanzahlunterschiede zwischen Git durchzuführen
Commits oder zwischen einem Git-Commit und einer Datei,
Verzeichnis oder Archiv. Verwenden Sie -v/--verbose, um es anzuzeigen
Das Git-System befiehlt Cloc-Probleme.
--git-diff-rel Dasselbe wie --git --diff oder einfach --diff, wenn die Eingaben erfolgen
werden als Git-Ziele erkannt. Nur Dateien, die
die sich in einem der beiden Commits geändert haben, werden verglichen.
--git-diff-all Git-Diff-Strategie Nr. 2: Vergleichen Sie alle Dateien im
Repository zwischen den beiden Commits.
--ignore-whitespace Ignoriert horizontalen Leerraum beim Vergleichen von Dateien
mit --diff. Siehe auch --ignore-case.
--ignore-case Änderungen der Groß-/Kleinschreibung im Dateiinhalt ignorieren;
Betrachten Sie Groß- und Kleinbuchstaben als gleichwertig
beim Vergleichen von Dateien mit --diff. Siehe auch
--ignore-whitespace.
--ignore-case-ext Groß-/Kleinschreibung von Dateinamenerweiterungen ignorieren. Das wird
kann bei manchen Sprachen zu Problemen beim Zählen führen
(Konkret sind .c und .C mit C und verbunden
C++; Dieser Schalter würde .C-Dateien eher als C zählen
als C++ auf *nix-Betriebssystemen). Dateiname
Die Groß-/Kleinschreibung wird unter Windows immer berücksichtigt.
--lang-no-ext= Dateien ohne Erweiterungen mit zählen
Schalter. Diese Option überschreibt die interne Logik
für Dateien ohne Erweiterungen (wo solche Dateien
werden anhand bekannter Skriptsprachen überprüft
durch Untersuchen der ersten Zeile auf #!). Siehe auch
--force-lang, --script-lang.
--max-file-size= Dateien überspringen, die größer als Megabyte sind, wenn
Verzeichnisse durchqueren. Standardmäßig ist =100.
Der Speicherbedarf von cloc beträgt etwa das Zwanzigfache
größer als die größte Datei, die daher ausgeführt wird
Dateien, die größer als 100 MB sind, auf einem Computer mit weniger
Mehr als 2 GB Speicher verursachen Probleme.
Hinweis: Diese Prüfung gilt nicht für Dateien
explizit als Befehlszeilenargumente übergeben.
--no-autogen[=list] Ignoriert von Code-Produktionssystemen generierte Dateien
wie GNU autoconf. Um eine Liste dieser Dateien anzuzeigen
(dann beenden), mit --no-autogen list ausführen
Siehe auch --autoconf.
--original-dir [Nur wirksam in Kombination mit
--strip-comments] Schreiben Sie die entfernten Dateien
in dasselbe Verzeichnis wie die Originaldateien.
--read-binary-files Verarbeitet zusätzlich zu Textdateien auch Binärdateien.
Dies ist normalerweise eine schlechte Idee und sollte auch nur so sein
Habe es mit eingebetteten Textdateien versucht
Binärdaten.
--read-lang-def= Neue Sprachverarbeitungsfilter aus laden
und füge sie mit denen zusammen, von denen bereits bekannt ist, dass sie cloc sind.
Wenn eine Sprache definiert, weiß cloc dies bereits
Darüber hinaus hat die Definition von cloc Vorrang.
Verwenden Sie --force-lang-def, um Clocs zu überschreiben
Definitionen (siehe auch --write-lang-def,
--write-lang-def-incl-dup).
--script-lang=, Verarbeitet alle Dateien, die als # aufrufen!
Skriptsprache mit dem Zähler für Sprache
. Zum Beispiel Dateien, die mit beginnen
#!/usr/local/bin/perl5.8.8
wird mit dem Perl-Zähler gezählt, indem verwendet wird
--script-lang=Perl,perl5.8.8
Beim Namen der Sprache wird die Groß-/Kleinschreibung nicht beachtet, aber die
Name der ausführbaren Skriptsprache, ,
muss den richtigen Koffer haben. Diese Option kann sein
mehrfach angegeben. Siehe auch --force-lang,
--lang-no-ext.
--sdir= Verwenden Sie stattdessen als Scratch-Verzeichnis
Lassen Sie File::Temp den Speicherort auswählen. Dateien
An diesen Ort geschriebene Dateien werden nicht entfernt
am Ende des Laufs (wie bei File::Temp).
--skip-uniqueness Überspringt die Eindeutigkeitsprüfung der Datei. Das wird geben
eine Leistungssteigerung auf Kosten des Zählens
Dateien mit identischem Inhalt mehrfach kopieren
(falls solche Duplikate existieren).
--stat Einige Dateisysteme (AFS, CD-ROM, FAT, HPFS, SMB)
Es gibt keine übereinstimmenden Verzeichnis-'nlink'-Zählungen
die Anzahl seiner Unterverzeichnisse. Folglich
cloc kann die Zahl unterzählen oder ganz überspringen
Inhalte solcher Dateisysteme. Dieser Schalter erzwingt
File::Find in stat-Verzeichnissen, um die zu erhalten
richtige Zählung. Die Geschwindigkeit der Dateisuche nimmt ab.
Siehe auch --follow-links.
--stdin-name= Geben Sie einen Dateinamen an, der zur Bestimmung der Sprache verwendet werden soll
für Standardeingabe. (Verwenden Sie - als Eingabenamen für
Quellcode über STDIN erhalten.)
--strip-comments= Schreiben Sie für jede verarbeitete Datei in die aktuelle Datei
Verzeichnis eine Version der Datei, die leer ist
und kommentierte Zeilen entfernt (Inline-Kommentare).
bestehen). Der Name jeder entfernten Datei lautet
Originaldateiname mit angehängtem ..
Es wird in das aktuelle Verzeichnis geschrieben, sofern nicht
--original-dir ist aktiviert.
--strip-str-comments Ersetzt in Zeichenfolgen eingebettete Kommentarmarkierungen durch
'xx'. Dadurch wird versucht, eine Einschränkung zu umgehen
in Regexp::Common::Comment wo Kommentarmarkierungen
In Strings eingebettete Kommentare werden als tatsächlicher Kommentar angesehen
Markierungen und keine Zeichenfolgen, was häufig zu einem führt
„Rekursionslimit für komplexe reguläre Unterausdrücke“
Warnung und falsche Zählungen. Es gibt zwei
Nachteile bei der Verwendung dieses Schalters: 1/Codeanzahl
Leistungseinbußen und 2/Code generiert mit
--strip-comments enthält unterschiedliche Zeichenfolgen
wo immer eingebettete Kommentare zu finden sind.
--sum-reports Eingabeargumente sind bisherige Berichtsdateien
erstellt mit der Option --report-file im Klartext
Format (z. B. nicht JSON, YAML, XML oder SQL).
Erstellt einen kumulativen Satz von Ergebnissen, der Folgendes enthält
Summe der Daten aus den einzelnen Reportdateien.
--timeout Ignoriert Dateien, die länger als Sekunden dauern
zur Verarbeitung in einer der Filterstufen der Sprache.
Die standardmäßige maximale Anzahl an Sekunden, die für a aufgewendet werden
Die Filterstufe ist die Anzahl der Zeilen in der Datei
geteilt durch eintausend. Das Setzen von auf 0 ermöglicht
unbegrenzte Zeit. Siehe auch --diff-timeout.
--processes=NUM [Nur auf Systemen mit einer aktuellen Version verfügbar
des Parallel::ForkManager-Moduls. Nicht
verfügbar unter Windows.] Legt die maximale Anzahl fest
Kerne, die cloc verwendet. Der Standardwert ist 0
deaktiviert Multiprocessing.
--unix Überschreibt die automatische Erkennung des Betriebssystems
Logik und läuft im UNIX-Modus. Siehe auch
--windows, --show-os.
--use-sloccount Wenn SLOCCount installiert ist, verwenden Sie es kompiliert
ausführbare Dateien c_count, java_count, pascal_count,
php_count und xml_count anstelle von clocs
Zähler. Die kompilierten Zähler von SLOCCount sind
wesentlich schneller als Cloc und kann nachgeben
eine Leistungsverbesserung beim Zählen von Projekten
mit großen Dateien. Allerdings sind diese cloc-spezifisch
Funktionen werden nicht verfügbar sein: --diff,
--count-and-diff, --strip-comments, --unicode.
--windows Überschreibt die automatische Erkennung des Betriebssystems
Logik und läuft im Microsoft Windows-Modus.
Siehe auch --unix, --show-os.
Filteroptionen
--include-content= Zählt nur Dateien, die Text enthalten, der mit dem übereinstimmt
gegebener regulärer Ausdruck.
--exclude-content= Schließt Dateien aus, die Text enthalten, der mit dem angegebenen übereinstimmt
regulärer Ausdruck.
--exclude-dir=[,D2,] Schließt die angegebenen durch Kommas getrennten Verzeichnisse aus
D1, D2, D3 usw. werden nicht gescannt. Für
Beispiel: --exclude-dir=.cache,test wird übersprungen
alle Dateien und Unterverzeichnisse mit /.cache/
oder /test/ als übergeordnetes Verzeichnis.
Verzeichnisse mit den Namen .bzr, .cvs, .hg, .git, .svn,
und .snapshot sind immer ausgeschlossen.
Diese Option funktioniert nur mit einzelnen Verzeichnissen
Namen, daher ist das Einfügen von Dateipfadtrennzeichen nicht der Fall
erlaubt. Verwenden Sie --fullpath und --not-match-d=
um einen regulären Ausdruck bereitzustellen, der zu mehreren Unterverzeichnissen passt.
--exclude-ext=[,[...]]
Zählen Sie keine Dateien mit dem angegebenen Dateinamen
Erweiterungen.
--exclude-lang=[,L2[...]]
Schließen Sie die angegebenen durch Kommas getrennten Sprachen aus
L1, L2, L3 usw. werden nicht gezählt.
--exclude-list-file= Ignoriert Dateien und/oder Verzeichnisse, deren Namen
erscheinen in . sollte eine Datei enthalten
Name pro Zeile. Nur genaue Übereinstimmungen werden ignoriert;
Relative Pfadnamen werden ab aufgelöst
das Verzeichnis, in dem cloc aufgerufen wird.
Siehe auch --list-file.
--fullpath Ändert das Verhalten von --match-f, --not-match-f,
und --not-match-d, um den Pfad der Datei einzuschließen
im regulären Ausdruck, nicht nur der Basisname der Datei.
(Dadurch wird nicht jede Datei um ihre Datei erweitert
absoluter Pfad, stattdessen wird so viel davon verwendet
der Pfad, wie er an cloc übergeben wird.)
Hinweis: --match-d betrachtet immer das Ganze
Pfad und wird daher von --fullpath nicht beeinflusst.
--include-ext=[,ext2[...]]
Zählen Sie nur Sprachen, die das angegebene Komma haben
getrennte Dateierweiterungen. Verwenden Sie --show-ext, um
Sehen Sie sich die erkannten Erweiterungen an.
--include-lang=[,L2[...]]
Zählt nur die angegebenen durch Kommas getrennten Sprachen
L1, L2, L3 usw. Verwenden Sie --show-lang, um es anzuzeigen
die Liste der anerkannten Sprachen.
--match-d= Zählt nur Dateien in Verzeichnissen, die mit Perl übereinstimmen
Regex. Zum Beispiel
--match-d='/(src|include)/'
Zählt nur Dateien in Verzeichnissen, die enthalten
/src/ oder /include/. Im Gegensatz zu --not-match-d,
--match-f und --not-match-f, --match-d immer
vergleicht den vollständig qualifizierten Pfad mit dem
Regex.
--not-match-d= Zählt alle Dateien außer denen in Verzeichnissen
passend zum Perl-Regex. Nur das Nachlaufen
Der Verzeichnisname wird beispielsweise verglichen, wenn
Wenn man in /usr/local/lib zählt, ist nur 'lib' vorhanden
im Vergleich zum regulären Ausdruck.
Fügen Sie --fullpath hinzu, um übergeordnete Verzeichnisse zu vergleichen
der reguläre Ausdruck.
Fügen Sie keine Dateipfad-Trennzeichen ein
Anfang oder Ende des regulären Ausdrucks.
--match-f= Zählt nur Dateien, deren Basisnamen mit dem Perl übereinstimmen
Regex. Zum Beispiel
--match-f='^[Ww]idget'
zählt nur Dateien, die mit Widget oder widget beginnen.
Fügen Sie --fullpath hinzu, um übergeordnete Verzeichnisse einzuschließen
im regulären Ausdruck anstelle nur des Basisnamens.
--not-match-f= Zählt alle Dateien außer denen, deren Basisnamen
Entspricht dem Perl-Regex. Fügen Sie --fullpath zum Einschließen hinzu
übergeordnete Verzeichnisse im regulären Ausdruck statt nur
der Basisname.
--skip-archive= Ignoriert Dateien, die mit dem angegebenen Perl-Regular enden
Ausdruck. Zum Beispiel, wenn gegeben
--skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
Der Code überspringt Dateien, die mit .zip enden.
.tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz und
.tar.7z.
--skip-win-hidden Ignorieren Sie unter Windows versteckte Dateien.
Debug-Optionen
-Categorized = Dateigrößen in Bytes speichern, identifizierte Sprachen
und Namen von kategorisierten Dateien zu .
-Counted = Namen von verarbeiteten Quelldateien in speichern.
--diff-alignment = Schreiben Sie in eine Liste von Dateien und Dateipaaren
zeigen, welche Dateien hinzugefügt, entfernt wurden und/oder
verglichen während eines Laufs mit -diff. Dieser Schalter
erzwingt den -diff -Modus ein.
-explain = Drucken Sie die Filter aus, mit denen Kommentare für entfernen wurden
Language und beenden. In einigen Fällen die
Filter beziehen sich eher auf Perl -Unterprogramme als auf Perl -Unterprogramm
reguläre Ausdrücke. Eine Untersuchung der
Quellcode kann zur weiteren Erläuterung erforderlich sein.
-Help diese Nutzungsinformationen und beenden Sie.
-Found = Namen jeder Datei speichern, die in gefunden wurde.
--Indored = Namen ignorierter Dateien und den Grund speichern, warum sie
wurden zu ignoriert.
-Print-Filter-Stadien-Stadien vor und nach und nachher drucken gedruckten Quellcode
Jeder Filter wird angewendet.
--Show-Outd [= ] Informationen über alle Bekannten (oder nur die
gegeben) Dateierweiterungen und Beenden.
--show-Lang [= ] Druckinformationen über alle Bekannten (oder nur die
Gegeben) Sprachen und Beenden.
--Show-OS Drucken Sie den Wert des Betriebssystemmodus
und verlassen. Siehe auch --unix, -Windows.
-V [= ] ausführlicher Switch (optionaler numerischer Wert).
-Verbose [= ] Langform von -v.
--Version drucken Sie die Version dieses Programms und Ausgangs.
---Write-Lang-def = schreibt in die Sprachverarbeitungsfilter
dann verlässt. Nützlich als erster Schritt zum Erstellen
benutzerdefinierte Sprachdefinitionen. Hinweis: Sprachen welche
Die Karte zur gleichen Dateierweiterung wird ausgeschlossen.
(Siehe auch-Force-Lang-Def,-read-lang-def).
---Write-Lang-Def-incl-dup =
Gleich wie-write-Lang-Def, enthält aber dupliziert
Erweiterungen. Dies erzeugt eine problematische Sprache
Definitionsdatei, da CLOC sich weigern, die Verwendung zu verwenden
Es bis zur Entfernung von Duplikaten.
Ausgabeoptionen
-3 Sprachausgabe der dritten Generation drucken.
(Diese Option kann dazu führen, dass die Berichtsüberschreitung fehlschlägt
Wenn einige Berichte mit dieser Option erstellt wurden
während andere ohne sie produziert wurden.)
-von Prozent X anstelle von Kommentaren und leeren Zeilenzählungen, zeigen Sie
Diese Werte als Prozentsätze basieren auf dem Wert
von x im Nenner:
X = 'C' -> # Codezeilen
X = 'CM' -> # Codezeilen + Kommentare
X = 'CB' -> # Code -Zeilen + Rohlinge
X = 'CMB' -> # Codezeilen + Kommentare + Rohlinge
Zum Beispiel, wenn die Methode 'C' und Ihr Code verwendet werden
hat doppelt so viele Kommentare wie Zeilen
von Code wird der Wert in der Spalte Kommentarspalte
200%sein. Die Codespalte bleibt eine Zeilenzahl.
-CSV schreiben die Ergebnisse als Komma-Trennwerte.
-CSV-Delimiter = Verwenden Sie das Zeichen als Trennzeichen für Comma
getrennte Dateien statt ,. Dieser Schalter ist eingeschaltet.
-file-coding = Ausgabedateien schreiben mit der codierung anstelle von
Der Standard-ASCII ( = 'UTF-7'). Beispiele: 'UTF-16',
'EUC-kr', 'ISO-8859-16'. Bekannte Kodierungen können sein
gedruckt mit
perl -mencode -e 'drucken join (" n", codieren-> codiert (": alle"), " n"' ''
-Hide-Rate zeigen keine Zeilen- und Dateiverarbeitungsraten in der
Ausgangsheader. Dies macht Output deterministisch.
-Json schreiben die Ergebnisse als JavaScript-Objektnotation
(JSON) Formatierte Ausgabe.
-MD schreiben die Ergebnisse als Markdown-formatierter Text.
-out = Synonym für-report-file = .
-Progress-rate = Fortschritts-Update anzeigen Nach jeder -Dateien
verarbeitet (Standard = 100). Setzen Sie auf 0 auf
Die Fortschrittsausgabe unterdrücken (nützlich bei der Umleitung
Ausgabe zu stdout).
-Quiet unterdrücken alle Informationsnachrichten mit Ausnahme von
Der Abschlussbericht.
-Report-file = Schreiben Sie die Ergebnisse in anstelle von STDOut.
-SQL = Schreiben Sie Ergebnisse als SQL-Erstellen und Einfügen von Anweisungen
die von einem Datenbankprogramm wie gelesen werden können wie z.
Sqlite. Wenn ist -wird die Ausgabe an stdout gesendet.
--SQL-append Append SQL Einfügenanweisungen in die angegebene Datei
durch - -sql und generieren Sie keine Tabellenerstellung
Aussagen. Nur gültig mit der Option -SQL.
--sql-project = Verwenden Sie als Projektkennung für die
Aktueller Lauf. Nur gültig mit der Option -SQL.
-SQL-Style =
