cloc Télécharger - cloc Téléchargement du code source

cloche

Compter les lignes de code

cloc compte les lignes vides, les lignes de commentaires et les lignes physiques du code source dans de nombreux langages de programmation.

Dernière version : v2.02 (2 août 2024)

cloc a migré vers GitHub en septembre 2015 après avoir été hébergé sur http://cloc.sourceforge.net/ depuis août 2006.

Démarrage rapide
Aperçu
Télécharger
- Installer via le gestionnaire de paquets
- Version stable
- Version de développement
Licence
Pourquoi utiliser Cloc ?
Autres compteurs
Construire un exécutable Windows
Utilisation de base
Possibilités
Langues reconnues
Comment ça marche
Utilisation avancée
- Supprimer les commentaires du code source
- Travailler avec des archives compressées
- Différences
- Créer des définitions de langage personnalisées
- Combiner les rapports
- SQL
- Sortie de colonne personnalisée
- Envelopper le cloc dans d'autres scripts
- chemins git et UTF8
- Facteurs d'échelle linguistique de troisième génération
- fichier de configuration options.txt
- Interface de programmation Java
Limite de récursion des sous-expressions régulières complexes
Limites
Demander de l'assistance pour des langues supplémentaires
Signaler des problèmes
Citation
Remerciements
Droit d'auteur

Démarrage rapide ▲

Étape 1 : Téléchargez cloc (plusieurs méthodes, voir ci-dessous) ou exécutez l'image docker de cloc. L'exécutable Windows n'a aucune exigence. La version source de cloc nécessite un interpréteur Perl et la version Docker de cloc nécessite une installation Docker.

Étape 2 : Ouvrez un terminal ( cmd.exe sous Windows).

Étape 3 : Invoquez cloc pour compter vos fichiers sources, répertoires, archives ou commits git. Le nom de l'exécutable diffère selon que vous utilisez la version source de développement ( cloc ), la source d'une version publiée ( cloc-2.02.pl ) ou un exécutable Windows ( cloc-2.02.exe ).

Sur cette page, cloc est le terme générique utilisé pour désigner l'un d'entre eux.

Include Security propose une vidéo YouTube montrant les étapes en action.

un fichier

 invite> cloc bonjour.c
       1 fichier texte.
       1 fichier unique.
       0 fichiers ignorés.

https://github.com/AlDanial/cloc v 1,65 T=0,04 s (28,3 fichiers/s, 340,0 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
C 1 0 7 5
-------------------------------------------------- -----------------------------

un répertoire

 invite> cloc gcc-5.2.0/gcc/c
      16 fichiers texte.
      15 fichiers uniques.
       3 fichiers ignorés.

https://github.com/AlDanial/cloc v 1,65 T=0,23 s (57,1 fichiers/s, 188914,0 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
C10 4680 6621 30812
En-tête C/C++ 3 99 286 496
-------------------------------------------------- -----------------------------
SOMME : 13 4779 6907 31308
-------------------------------------------------- -----------------------------

une archive

Nous allons extraire le fichier zip source de cloc de GitHub, puis compter le contenu :

 invite> wget https://github.com/AlDanial/cloc/archive/master.zip

invite> cloc master.zip
https://github.com/AlDanial/cloc v 1,65 T=0,07 s (26,8 fichiers/s, 141370,3 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
Perl2 725 1103 8713
-------------------------------------------------- -----------------------------
SOMME : 2 725 1103 8713
-------------------------------------------------- -----------------------------

un dépôt git, utilisant un commit spécifique

Cet exemple utilise le code de PuDB, un fantastique débogueur Python.

 invite> git clone https://github.com/inducer/pudb.git

invite> cd pudb

invite> cloc 6be804e07a5db
      48 fichiers texte.
      41 fichiers uniques.                              
       8 fichiers ignorés.

github.com/AlDanial/cloc v 1,99 T=0,04 s (1054,9 fichiers/s, 189646,8 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
Python 28 1519 728 4659
texte restructuré 6 102 20 203
YAML 2 9 2 75
Coquille Bourne 3 6 0 17
Texte 1 0 0 11
faire 1 4 6 10
-------------------------------------------------- -----------------------------
SOMME : 41 1640 756 4975
-------------------------------------------------- -----------------------------

chaque sous-répertoire d'un répertoire particulier

Supposons que vous ayez un répertoire avec trois projets différents gérés par git, Project0, Project1 et Project2. Vous pouvez utiliser la capacité de bouclage de votre shell pour compter le code dans chacun. Cet exemple utilise bash (faites défiler vers le bas pour l'exemple cmd.exe) :

 invite> pour d dans ./*/ ; faire (cd "$d" && echo "$d" && cloc --vcs git); fait
./Projet0/
7 fichiers texte.
       7 fichiers uniques.
       1 fichier ignoré.

github.com/AlDanial/cloc v 1,71 T=0,02 s (390,2 fichiers/s, 25687,6 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
D 4 61 32 251
Démarquage 1 9 0 38
faire 1 0 0 4
-------------------------------------------------- -----------------------------
SOMME : 6 70 32 293
-------------------------------------------------- -----------------------------
./Projet1/
       7 fichiers texte.
       7 fichiers uniques.
       0 fichiers ignorés.

github.com/AlDanial/cloc v 1,71 T=0,02 s (293,0 fichiers/s, 52107,1 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
Allez au 7 165 282 798
-------------------------------------------------- -----------------------------
SOMME : 7 165 282 798
-------------------------------------------------- -----------------------------
./Projet2/
      49 fichiers texte.
      47 fichiers uniques.
      13 fichiers ignorés.

github.com/AlDanial/cloc v 1,71 T=0,10 s (399,5 fichiers/s, 70409,4 lignes/s)
-------------------------------------------------- -----------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- -----------------------------
Python33 1226 1026 3017
C4 327 337 888
Démarquage 1 11 0 28
YAML 1 0 2 12
-------------------------------------------------- -----------------------------
SOMME : 39 1564 1365 3945
-------------------------------------------------- -----------------------------

chaque sous-répertoire d'un répertoire particulier (Windows/cmd.exe)

 pour /D %I dans (.*) do cd %I && cloc --vcs git && cd ..

Aperçu ▲

cloc compte les lignes vides, les lignes de commentaires et les lignes physiques du code source dans de nombreux langages de programmation. Étant donné deux versions d'une base de code, cloc peut calculer les différences entre les lignes vides, les commentaires et la source. Il est entièrement écrit en Perl, sans dépendances en dehors de la distribution standard de Perl v5.6 et versions ultérieures (le code de certains modules externes est intégré dans cloc) et est donc assez portable. cloc est connu pour fonctionner sur de nombreuses versions de Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX, z/OS et Windows. (Pour exécuter la version source Perl de cloc sur Windows, il faut ActiveState Perl 5.6.1 ou supérieur, Strawberry Perl, le sous-système Windows pour Linux, Cygwin, MobaXTerm avec le plug-in Perl installé, ou un environnement et un terminal Mingw tels que ceux fournis par Git pour Windows. Vous pouvez également utiliser le binaire Windows de cloc généré avec PAR::Packer pour fonctionner sur des ordinateurs Windows qui n'ont ni Perl ni Cygwin.)

En plus de compter le code dans les fichiers texte individuels, les répertoires et les référentiels git, cloc peut également compter le code dans les fichiers d'archives tels que .tar (y compris les versions compressées), .zip , Python wheel .whl , Jupyter notebook .ipynb , source RPMs .rpm ou .src (nécessite rpm2cpio ) et les fichiers Debian .deb (nécessite dpkg-deb ).

cloc contient le code de SLOCCount de David Wheeler, du module Perl Regexp::Common de Damian Conway et Abigail, du module Perl Win32::Autoglob de Sean M. Burke et du module Perl de Tye McQueen Algorithm::Diff. Les facteurs d'échelle linguistique ont été dérivés du site Web de Mayes Consulting, LLC http://softwareestimator.com/IndustryData2.htm.

Les nouvelles versions paraissent nominalement tous les six mois.

Exécuter via Docker

docker run --rm -v $PWD :/tmp aldanial/cloc

Exécuter via docker sur git-bash

docker run --rm -v " / $( pwd -W ) " :/tmp aldanial/cloc

Installer via le gestionnaire de paquets

En fonction de votre système d'exploitation, l'une de ces méthodes d'installation peut fonctionner pour vous (toutes les entrées pour Windows, sauf les deux dernières, nécessitent un interpréteur Perl) :

 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

Remarque : je ne contrôle aucun de ces packages. Si vous rencontrez un bogue dans cloc en utilisant l'un des packages ci-dessus, essayez avec cloc extrait de la dernière version stable ici sur GitHub (le lien suit ci-dessous) avant de soumettre un rapport de problème.

Version stable

https://github.com/AlDanial/cloc/releases/latest

Version de développement

https://github.com/AlDanial/cloc/raw/master/cloc

Licence ▲

cloc est sous licence GNU General Public License, v 2, à l'exclusion des parties copiées à partir d'autres sources. Le code copié à partir des modules Regexp::Common, Win32::Autoglob et Algorithm::Diff Perl est soumis à la licence artistique.

Pourquoi utiliser Cloc ? ▲

cloc possède de nombreuses fonctionnalités qui la rendent facile à utiliser, complète, extensible et portable :

Existe sous la forme d'un fichier unique et autonome qui nécessite un effort d'installation minimal : il suffit de télécharger le fichier et de l'exécuter.
Peut lire les définitions de commentaires de langage à partir d'un fichier et ainsi potentiellement travailler avec des langages informatiques qui n'existent pas encore.
Permet de résumer les résultats de plusieurs exécutions par langue et par projet.
Peut produire des résultats dans une variété de formats : texte brut, Markdown, SQL, JSON, XML, YAML, valeurs séparées par des virgules.
Peut compter le code dans les archives compressées (balles tar, fichiers Zip, fichiers Java .ear).
Possède de nombreuses options de dépannage.
Gère les noms de fichiers et de répertoires avec des espaces et autres caractères inhabituels.
N'a aucune dépendance en dehors de la distribution Perl standard.
Fonctionne sur les systèmes Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX et z/OS dotés de Perl 5.6 ou supérieur. La version source fonctionne sous Windows avec le plugin ActiveState Perl, Strawberry Perl, Cygwin ou MobaXTerm+Perl. Alternativement, sous Windows, vous pouvez exécuter le binaire Windows qui n'a aucune dépendance.

Autres compteurs ▲

Si Cloc ne répond pas à vos besoins, voici d'autres compteurs disponibles gratuitement à considérer :

lieu
gloc
gocloc
Ohcompte
scc
sclc
Compte SLOC
Sonar
tokéi
Nombre de codes unifiés

Autres références :

Le répertoire QSM des outils de comptage de codes.
L'entrée Wikipedia pour le nombre de lignes de code source.

Regexp :: Common, Digest :: MD5, Win32 :: Autoglob, Algorithme :: Diff

Bien que cloc n'ait pas besoin de modules Perl en dehors de ceux trouvés dans la distribution standard, cloc s'appuie sur quelques modules externes. Le code de trois de ces modules externes (Regexp::Common, Win32::Autoglob et Algorithm::Diff) est intégré dans cloc. Un quatrième module, Digest::MD5, n'est utilisé que s'il est disponible. Si cloc trouve Regexp::Common ou Algorithm::Diff installé localement, il utilisera ces installations. Si ce n'est pas le cas, cloc installera les parties de Regexp::Common et/ou Algorithm:Diff dont il a besoin dans les répertoires temporaires qui sont créés au début d'une exécution cloc puis supprimés une fois l'exécution terminée. Le code nécessaire de Regexp::Common v2.120 et Algorithm::Diff v1.1902 est intégré dans le code source de cloc (voir les sous-programmes Install_Regexp_Common() et Install_Algorithm_Diff() ). Seules trois lignes sont nécessaires à partir de Win32::Autoglob et celles-ci sont incluses directement dans cloc.

De plus, cloc utilisera Digest :: MD5 pour valider l'unicité parmi les fichiers d'entrée de taille égale si Digest :: MD5 est installé localement.

Une option de traitement parallèle, --processes= N , a été introduite avec la version 1.76 de cloc pour permettre des exécutions plus rapides sur les machines multicœurs. Cependant, pour l'utiliser, il faut avoir installé le module Parallel::ForkManager. Ce module ne fonctionne pas de manière fiable sous Windows, le traitement parallèle ne fonctionnera donc que sur les systèmes d'exploitation de type Unix.

Le binaire Windows est construit sur un ordinateur sur lequel Regexp::Common et Digest::MD5 sont installés localement.

Construire un exécutable Windows ▲

Créez votre propre exécutable

L'option la plus robuste pour créer un exécutable Windows de cloc consiste à utiliser le kit de développement Perl d'ActiveState. Il comprend un utilitaire, perlapp , qui peut créer des binaires Windows, Mac et Linux autonomes du code source Perl.

perl2exe fera également l'affaire. Si vous disposez perl2exe , modifiez les lignes 84 à 87 du code source de cloc pour une modification mineure du code nécessaire pour rendre une cloc exécutable sous Windows.

Sinon, pour créer un exécutable Windows avec pp à partir de PAR::Packer , installez d'abord une distribution Perl basée sur Windows (par exemple Strawberry Perl ou ActivePerl) en suivant leurs instructions. Ensuite, ouvrez une invite de commande, alias une fenêtre DOS et installez le module PAR::Packer. Enfin, appelez la commande pp nouvellement installée avec le code source cloc pour créer un fichier .exe :

 C:> cpan -i Digest :: MD5
C:> cpan -i Regexp :: Commun
C:> cpan -i Algorithme ::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

Une variante des instructions ci-dessus est que si vous avez installé la version portable de Strawberry Perl, vous devrez d'abord exécuter portableshell.bat pour configurer correctement votre environnement.

L'exécutable Windows dans la section Releases, cloc-2.02.exe , a été créé sur un ordinateur Windows 10 64 bits à l'aide de Strawberry Perl 5.30.2 et PAR::Packer pour créer le .exe .

L’exécutable Windows est-il sûr à exécuter ? Est-ce qu'il contient des logiciels malveillants ?

Idéalement, personne n'aurait besoin de l'exécutable Windows car il dispose d'un interpréteur Perl installé sur ses machines et peut exécuter le fichier source cloc. Toutefois, sur les machines Windows d'entreprise gérées de manière centralisée, cela peut s'avérer difficile, voire impossible.

L'exécutable Windows distribué avec cloc est fourni au mieux d'un .exe exempt de virus et de logiciels malveillants. Nous vous encourageons à exécuter vos propres antivirus sur l'exécutable et à consulter également des sites tels que https://www.virustotal.com/ . Les entrées pour les versions récentes sont :

cloc-2.02-winget.exe : (inclut PR 850 pour permettre l'exécution à partir d'un lien symbolique sous Windows) 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/

Pourquoi l’exécutable Windows est-il si volumineux ?

Les exécutables Windows des versions 1.60 et antérieures de cloc, créés avec perl2exe comme indiqué ci-dessus, font environ 1,6 Mo, tandis que les versions 1.62 et 1.54, créées avec PAR::Packer , font 11 Mo. La version 1.66, construite avec une version plus récente de PAR::Packer , fait environ 5,5 Mo. Pourquoi les exécutables PAR::Packer sont-ils tellement plus gros que ceux construits avec perl2exe ? Ma théorie est que perl2exe utilise une logique d'élagage d'arbres plus intelligente que PAR::Packer , mais c'est de la pure spéculation.

Utilisation de base ▲

cloc est un programme en ligne de commande qui prend en entrée les noms de fichiers, de répertoires et/ou d'archives. Voici un exemple d'exécution de cloc sur la distribution source Perl v5.22.0 :

 invite> cloc perl-5.22.0.tar.gz
    5605 fichiers texte.
    5386 fichiers uniques.
    2176 fichiers ignorés.

https://github.com/AlDanial/cloc v 1,65 T=25,49 s (134,7 fichiers/s, 51980,3 lignes/s)
-------------------------------------------------- ---------------------------------
Code de commentaire vide des fichiers de langue
-------------------------------------------------- ---------------------------------
Perl 2892 136396 184362 536445
C130 24676 33684 155648
En-tête C/C++ 148 9766 16569 147858
Bourne Shell 112 4044 6796 42668
Pascal 8 458 1603 8592
XML33 142 0 2410
YAML 49 20 15 2078
C++10 313 277 2033
marque 4 426 488 1986
Prologue 12 438 2 1146
JSON 14 1 0 1037
yacc 1 85 76 998
Fichier de messages Windows 1 102 11 489
Lot DOS 14 92 41 389
Fichier de ressources Windows 3 10 0 85
J 1 5 7 8
Lisp 2 0 3 4
-------------------------------------------------- ---------------------------------
SOMME : 3434 176974 243934 903874
-------------------------------------------------- ---------------------------------

Pour exécuter cloc sur des ordinateurs Windows, ouvrez une fenêtre de commande (alias DOS) et invoquez cloc.exe à partir de la ligne de commande. Vous pouvez également essayer ClocViewer, le wrapper GUI autour de Cloc trouvé sur https://github.com/Roemer/ClocViewer.

Voir également https://github.com/jmensch1/codeflower pour un rendu graphique des résultats de cloc.

Possibilités ▲

invite> cloc --help

Utilisation : cloc [options] | |

Compter ou calculer les différences entre les lignes physiques du code source dans le
fichiers donnés (peut être des archives telles que des archives tar compressées ou des fichiers zip,
ou les hachages de commit git ou les noms de branches) et/ou de manière récursive en dessous du
répertoires donnés.

Options de saisie
--extract-with= Cette option n'est nécessaire que si cloc est incapable
pour comprendre comment extraire le contenu de
le(s) fichier(s) d'entrée par lui-même.
Utilisez pour extraire les fichiers d'archive binaires (par exemple :
.tar.gz, .zip, .Z). Utilisez le littéral '>FILE<' comme
un remplaçant pour le(s) fichier(s) réel(s) à être
extrait. Par exemple, pour compter les lignes de code
dans les fichiers d'entrée
gcc-4.2.tar.gz perl-5.8.8.tar.gz
sur une utilisation Unix
--extract-with='gzip -dc >FILE< | tarxf -'
ou, si vous avez GNU tar,
--extract-with='tar zxf >FILE<'
et sous Windows utilisez par exemple :
--extract-with=""c:Program FilesWinZipWinZip32.exe" -e -o >FILE< ."
(si WinZip y est installé).
--list-file= Amener la liste des noms de fichiers et/ou de répertoires à
processus à partir de , qui a un fichier/répertoire
nom par ligne. Seules les correspondances exactes sont comptées ;
les noms de chemin relatifs seront résolus à partir de
le répertoire où cloc est invoqué. Définir
to - pour lire les noms de fichiers à partir d'un tube STDIN.
Voir aussi --exclude-list-file.
--diff-list-file= Prend les paires de noms de fichiers à partir desquels la comparaison est effectuée
, dont le format correspond à la sortie de
--alignement-diff. (Exécutez avec cette option pour
voir un exemple.) L'identifiant de langue au niveau
la fin de chaque ligne est ignorée. Cela active --diff
et contourne la logique d’alignement des paires de fichiers.
--vcs= Invoque un appel système à pour obtenir une liste de
fichiers sur lesquels travailler. Si est 'git', alors
invoquez 'git ls-files' pour obtenir une liste de fichiers et
'git submodule status' pour obtenir une liste des sous-modules
dont le contenu sera ignoré. Voir aussi --git
qui accepte les hachages de commit git et les noms de branches.
Si est « svn », alors il invoquera « svn list -R ».
Le principal avantage est que Cloc sautera alors
fichiers explicitement exclus par l'outil de gestion de versions
en question, c'est-à-dire ceux de .gitignore ou qui ont le
svn: ignorer la propriété.
Alternativement, peut être n'importe quelle commande système
qui génère une liste de fichiers.
Remarque : cloc doit être dans un répertoire pouvant lire
les fichiers tels qu'ils sont renvoyés par . cloc va
ne pas télécharger de fichiers à partir de référentiels distants.
'svn list -R' peut faire référence à un référentiel distant
pour obtenir les noms de fichiers (et peut donc nécessiter
authentification au référentiel distant), mais
les fichiers eux-mêmes doivent être locaux.
Définir sur « auto » permet de sélectionner entre « git »
et 'svn' (ou aucun des deux) selon la présence
d'un sous-répertoire .git ou .svn sous le répertoire
où cloc est invoqué.
--unicode Vérifiez les fichiers binaires pour voir s'ils contiennent Unicode
texte ASCII étendu. Cela entraîne une baisse des performances
baisser sensiblement.

Options de traitement
--autoconf Nombre de fichiers .in (tels que traités par GNU autoconf) de
langues reconnues. Voir aussi --no-autogen.
--by-file Rapporte les résultats pour chaque fichier source rencontré.
--by-file-by-lang Rapporte les résultats pour chaque fichier source rencontré
en plus des rapports par langue.
--config Lire les commutateurs de ligne de commande depuis au lieu de
l'emplacement par défaut de /home/al/.config/cloc/options.txt.
Le fichier doit contenir un commutateur, ainsi que
arguments (le cas échéant), par ligne. Lignes et lignes vides
commençant par '#' sont ignorés. Options proposées sur
la ligne de commande est prioritaire sur les entrées lues depuis
le fichier.
--count-and-diff
Effectuez d’abord un décompte direct du code du ou des fichiers source.
de et séparément, puis effectuez une comparaison
de ceux-ci. Les entrées peuvent être des paires de fichiers, de répertoires,
ou des archives. Si --out ou --report-file est donné,
trois fichiers de sortie seront créés, un pour chacun
des deux chefs d'accusation et un pour le diff. Voir aussi
--diff, --diff-alignement, --diff-timeout,
--ignore-case, --ignore-whitespace.
--diff Calcule les différences de code et de commentaires entre
fichier(s) source de et . Les entrées
peut être n'importe quel mélange de fichiers, répertoires, archives,
ou les hachages git commit. Utilisez --diff-alignment pour
générer une liste montrant quelles paires de fichiers où
comparé. Lors de la comparaison des branches git, seuls les fichiers
qui ont changé dans l’un ou l’autre commit sont comparés.
Voir aussi --git, --count-and-diff, --diff-alignment,
--diff-list-file, --diff-timeout, --ignore-case,
--ignore-espaces.
--diff-timeout Ignorer les fichiers qui prennent plus de secondes
à traiter. La valeur par défaut est de 10 secondes. Paramètre
à 0 permet un temps illimité. (Fichiers volumineux avec de nombreux
des lignes répétées peuvent provoquer Algorithm::Diff::sdiff()
cela prend des heures.) Voir aussi --timeout.
--docstring-as-code cloc considère les docstrings comme des commentaires, mais c'est
pas toujours correct car les docstrings représentent des éléments réguliers
chaînes lorsqu'elles apparaissent sur le côté droit d'un
affectation ou comme arguments de fonction. Ce commutateur
force les docstrings à être comptées comme du code.
--follow-links [Unix uniquement] Suivre les liens symboliques vers des répertoires
(les liens symboliques vers les fichiers sont toujours suivis).
Voir aussi --stat.
--force-lang=[,]
Traite tous les fichiers qui ont une extension
avec le compteur de langue . Pour
exemple, pour compter tous les fichiers .f avec le
Compteur Fortran 90 (qui attend que les fichiers
se termine par .f90) au lieu du Fortran 77 par défaut
compteur, utiliser
--force-lang="Fortran 90,f"
Si est omis, chaque fichier sera compté
avec le compteur . Cette option peut être
spécifié plusieurs fois (mais ce n'est que
utile lorsque est donné à chaque fois).
Voir aussi --script-lang, --lang-no-ext.
--force-lang-def= Charger les filtres de traitement du langage depuis ,
puis utilisez ces filtres au lieu des filtres intégrés
filtres. Remarque : langues qui correspondent aux mêmes
extension de fichier (par exemple :
MATLAB/Mathematica/Objective-C/MUMPS/Mercure ;
Pascal/PHP ; Lisp/OpenCL ; Lisp/Julia ; Perl/Prologue)
seront ignorés car ceux-ci nécessitent des
traitement qui n'est pas exprimé dans le langage
fichiers de définition. Utilisez --read-lang-def pour définir
nouveaux filtres de langue sans remplacer les filtres intégrés
filtres (voir aussi --write-lang-def,
--write-lang-def-incl-dup).
--git Force les entrées à être interprétées comme des cibles git
(hachages de validation, noms de branches, etc.) si ceux-ci
ne sont pas d'abord identifiés comme fichier ou répertoire
noms. Cette option remplace la logique --vcs=git
si cela est donné ; en d'autres termes, --git obtient son
liste des fichiers sur lesquels travailler directement depuis git en utilisant
le hachage ou le nom de la branche plutôt que de
'git ls-files'. Cette option peut être utilisée avec
--diff pour effectuer des différences de nombre de lignes entre git
commits, ou entre un git commit et un fichier,
répertoire ou archive. Utilisez -v/--verbose pour voir
le système git commande les problèmes de cloc.
--git-diff-rel Identique à --git --diff, ou simplement --diff si les entrées
sont reconnus comme cibles git. Seuls les fichiers qui
ont changé dans l’un ou l’autre commit sont comparés.
--git-diff-all Stratégie de comparaison Git n°2 : comparer tous les fichiers du
référentiel entre les deux commits.
--ignore-whitespace Ignorer les espaces blancs horizontaux lors de la comparaison de fichiers
avec --diff. Voir aussi --ignore-case.
--ignore-case Ignorer les changements de casse dans le contenu du fichier ;
considérer les lettres majuscules et minuscules comme équivalentes
lors de la comparaison de fichiers avec --diff. Voir aussi
--ignore-espaces.
--ignore-case-ext Ignorer la casse des extensions de nom de fichier. Cela va
poser des problèmes pour compter certaines langues
(plus précisément, .c et .C sont associés à C et
C++ ; ce commutateur compterait plutôt les fichiers .C comme C
que C++ sur les systèmes d'exploitation *nix). Nom de fichier
l'insensibilité à la casse est toujours vraie sous Windows.
--lang-no-ext= Compter les fichiers sans extensions en utilisant le
comptoir. Cette option remplace la logique interne
pour les fichiers sans extensions (où ces fichiers
sont vérifiés par rapport aux langages de script connus
en examinant la première ligne pour #!). Voir aussi
--force-lang, --script-lang.
--max-file-size= Ignorer les fichiers de plus de mégaoctets lorsque
parcourir des répertoires. Par défaut, =100.
les besoins en mémoire de Cloc sont environ vingt fois supérieurs
plus gros que le plus gros fichier, donc exécuté avec
fichiers de plus de 100 Mo sur un ordinateur avec moins
plus de 2 Go de mémoire poseront des problèmes.
Remarque : cette vérification ne s'applique pas aux fichiers
explicitement passés comme arguments de ligne de commande.
--no-autogen[=list] Ignorer les fichiers générés par les systèmes de production de code
comme GNU autoconf. Pour voir une liste de ces fichiers
(puis quittez), exécutez avec --no-autogen list
Voir aussi --autoconf.
--original-dir [Efficace uniquement en combinaison avec
--strip-comments] Écrire les fichiers supprimés
dans le même répertoire que les fichiers d'origine.
--read-binary-files Traite les fichiers binaires en plus des fichiers texte.
C'est généralement une mauvaise idée et ne devrait être
tenté avec des fichiers texte intégrés
données binaires.
--read-lang-def= Charger de nouveaux filtres de traitement de langage à partir de
et fusionnez-les avec ceux déjà connus pour cloc.
Si définit un langage que la cloc connaît déjà
à propos, la définition de cloc prévaudra.
Utilisez --force-lang-def pour remplacer les clocs
définitions (voir aussi --write-lang-def,
--write-lang-def-incl-dup).
--script-lang=, Traitez tous les fichiers qui appellent comme un # !
langage de script avec le compteur de langue
. Par exemple, les fichiers commençant par
#!/usr/local/bin/perl5.8.8
sera compté avec le compteur Perl en utilisant
--script-lang=Perl,perl5.8.8
Le nom de la langue n'est pas sensible à la casse mais le
nom de l'exécutable du langage de script, ,
doit avoir le bon cas. Cette option peut être
spécifié plusieurs fois. Voir aussi --force-lang,
--lang-no-ext.
--sdir= Utiliser comme répertoire de travail au lieu de
laisser File::Temp choisir l'emplacement. Fichiers
écrits à cet emplacement ne sont pas supprimés à
la fin de l'exécution (comme c'est le cas avec File::Temp).
--skip-uniciténess Ignore la vérification de l'unicité du fichier. Cela donnera
une amélioration des performances au détriment du comptage
fichiers avec un contenu identique plusieurs fois
(si de tels doublons existent).
--stat Certains systèmes de fichiers (AFS, CD-ROM, FAT, HPFS, SMB)
je n'ai pas de nombre de répertoires 'nlink' qui correspondent
le nombre de ses sous-répertoires. Par conséquent
cloc peut sous-estimer ou ignorer complètement le
contenu de ces systèmes de fichiers. Ce commutateur force
File::Rechercher dans les répertoires stat pour obtenir le
décompte correct. La vitesse de recherche des fichiers diminuera.
Voir aussi --follow-links.
--stdin-name= Donner un nom de fichier à utiliser pour déterminer la langue
pour une entrée standard. (Utilisez - comme nom d'entrée pour
recevoir le code source via STDIN.)
--strip-comments= Pour chaque fichier traité, écrivez dans le répertoire actuel
répertoire une version du fichier qui est vide
et lignes commentées supprimées (commentaires en ligne
persister). Le nom de chaque fichier supprimé est le
nom du fichier d'origine suivi de ..
Il est écrit dans le répertoire courant à moins que
--original-dir est activé.
--strip-str-comments Remplacez les marqueurs de commentaires intégrés dans les chaînes par
'xx'. Cela tente de contourner une limitation
dans Regexp :: Common :: Comment où les marqueurs de commentaire
intégrés dans les chaînes sont considérés comme de véritables commentaires
marqueurs et non des chaînes, ce qui entraîne souvent un
« Limite de récursion de sous-expression régulière complexe »
avertissement et comptes incorrects. Il y en a deux
inconvénients de l'utilisation de ce commutateur : 1/nombre de codes
les performances chutent, et 2/code généré avec
--strip-comments contiendra différentes chaînes
partout où se trouvent les commentaires intégrés.
--sum-reports Les arguments d'entrée sont des fichiers de rapport précédemment
créé avec l'option --report-file en clair
format (par exemple, pas JSON, YAML, XML ou SQL).
Crée un ensemble cumulatif de résultats contenant les
somme des données des fichiers de rapport individuels.
--timeout Ignorer les fichiers qui prennent plus de secondes
à traiter à n’importe quelle étape de filtrage du langage.
Le nombre maximum par défaut de secondes passées sur un
l'étape de filtrage est le nombre de lignes dans le fichier
divisé par mille. Le réglage de sur 0 permet
durée illimitée. Voir aussi --diff-timeout.
--processes=NUM [Disponible uniquement sur les systèmes dotés d'une version récente
du module Parallel::ForkManager. Pas
disponible sous Windows.] Définit le nombre maximum de
cœurs utilisés par Cloc. La valeur par défaut de 0
désactive le multitraitement.
--unix Remplacer la détection automatique du système d'exploitation
logique et exécuté en mode UNIX. Voir aussi
--windows, --show-os.
--use-sloccount Si SLOCCount est installé, utilisez son compilé
exécutables c_count, java_count, pascal_count,
php_count et xml_count au lieu de cloc
compteurs. Les compteurs compilés de SLOCCount sont
sensiblement plus rapide que les horloges et peut donner
une amélioration des performances lors du comptage des projets
avec des fichiers volumineux. Cependant, ces
les fonctionnalités ne seront pas disponibles : --diff,
--count-and-diff, --strip-comments, --unicode.
--windows Remplacer la détection automatique du système d'exploitation
logique et exécuté en mode Microsoft Windows.
Voir aussi --unix, --show-os.

Options de filtrage
--include-content= Ne compte que les fichiers contenant du texte qui correspond au
étant donné une expression régulière.
--exclude-content= Exclure les fichiers contenant du texte qui correspond au
expression régulière.
--exclude-dir=[,D2,] Exclure les répertoires donnés séparés par des virgules
D1, D2, D3, et cetera, ne sont pas scannés. Pour
exemple --exclude-dir=.cache, le test sera ignoré
tous les fichiers et sous-répertoires contenant /.cache/
ou /test/ comme répertoire parent.
Répertoires nommés .bzr, .cvs, .hg, .git, .svn,
et .snapshot sont toujours exclus.
Cette option ne fonctionne qu'avec un répertoire individuel
les noms, donc l'inclusion de séparateurs de chemin de fichier n'est pas
autorisé. Utilisez --fullpath et --not-match-d=
pour fournir une expression régulière correspondant à plusieurs sous-répertoires.
--exclude-ext=[,[...]]
Ne comptez pas les fichiers portant le nom de fichier donné
extensions.
--exclude-lang=[,L2[...]]
Exclure les langues données séparées par des virgules
L1, L2, L3, et cetera, ne sont pas comptés.
--exclude-list-file= Ignorer les fichiers et/ou répertoires dont les noms
apparaître dans . devrait avoir un fichier
nom par ligne. Seules les correspondances exactes sont ignorées ;
les noms de chemin relatifs seront résolus à partir de
le répertoire où cloc est invoqué.
Voir aussi --list-file.
--fullpath Modifie le comportement de --match-f, --not-match-f,
et --not-match-d pour inclure le chemin du fichier
dans l'expression régulière, pas seulement le nom de base du fichier.
(Cela ne développe pas chaque fichier pour inclure son
chemin absolu, il utilise à la place autant de
le chemin tel qu'il est transmis à cloc.)
Remarque : --match-d examine toujours l'intégralité
path et n’est donc pas affecté par --fullpath.
--include-ext=[,ext2[...]]
Ne compter que les langues ayant la virgule donnée
extensions de fichiers séparées. Utilisez --show-ext pour
voir les extensions reconnues.
--include-lang=[,L2[...]]
Comptez uniquement les langues données séparées par des virgules
L1, L2, L3, etc. Utilisez --show-lang pour voir
la liste des langues reconnues.
--match-d= Compte uniquement les fichiers dans les répertoires correspondant au Perl
expression régulière. Par exemple
--match-d='/(src|include)/'
ne compte que les fichiers dans les répertoires contenant
/src/ ou /include/. Contrairement à --not-match-d,
--match-f, et --not-match-f, --match-d toujours
compare le chemin pleinement qualifié avec le
expression régulière.
--not-match-d= Compte tous les fichiers sauf ceux des répertoires
correspondant à l'expression régulière Perl. Seule la fin
le nom du répertoire est comparé, par exemple, lorsque
en comptant dans /usr/local/lib, seul 'lib' est
par rapport à l'expression régulière.
Ajoutez --fullpath pour comparer les répertoires parents avec
l'expression régulière.
N'incluez pas de séparateurs de chemin de fichier au niveau du
début ou fin de l'expression régulière.
--match-f= Compte uniquement les fichiers dont les noms de base correspondent au Perl
expression régulière. Par exemple
--match-f='^[Ww]idget'
ne compte que les fichiers commençant par Widget ou widget.
Ajoutez --fullpath pour inclure les répertoires parents
dans l'expression régulière au lieu de simplement le nom de base.
--not-match-f= Compte tous les fichiers sauf ceux dont les noms de base
correspond à l'expression régulière Perl. Ajoutez --fulpath pour inclure
répertoires parents dans l'expression régulière au lieu de simplement
le nom de base.
--skip-archive= Ignorer les fichiers qui se terminent par le standard Perl donné
expression. Par exemple, si on donne
--skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
le code ignorera les fichiers se terminant par .zip,
.tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz et
.tar.7z.
--Skip-Win-Hidden sous Windows, ignorez les fichiers cachés.

Options de débogage
- catégorisé = Enregistrer les tailles de fichiers en octets, langues identifiées
et les noms des fichiers catégorisés en .
--Courted = Enregistrer les noms des fichiers source traités à .
--diff-alignement = Écrivez à une liste de fichiers et de paires de fichiers
affichant quels fichiers ont été ajoutés, supprimés et / ou
Comparé lors d'une course avec - Diff. Ce commutateur
Forces le mode - Diff sur.
--Explain = Imprimez les filtres utilisés pour supprimer les commentaires pour
Langue et sortie. Dans certains cas, le
les filtres se réfèrent aux sous-programmes perl plutôt que
expressions régulières. Un examen du
Le code source peut être nécessaire pour une explication plus approfondie.
--help Imprimez ces informations d'utilisation et sortez.
--Found = Enregistrer les noms de chaque fichier trouvé dans .
--Insed = Enregistrer les noms des fichiers ignorés et la raison pour laquelle ils
ont été ignorés en .
- Print-Filter-Stages Imprimer le code source traité avant et après
Chaque filtre est appliqué.
--show-axt [= ] Imprimez des informations sur tous les connus (ou juste le
donné) Extensions de fichiers et sortie.
--show-Lang [= ] Imprimez des informations sur toutes les connues (ou tout simplement
donné) les langues et la sortie.
--Show-OS imprime la valeur du mode système d'exploitation
et sortir. Voir aussi --Unix, - Windows.
-v [= ] Switch Verbose (valeur numérique facultative).
-Verbose [= ] Forme longue de -v.
- Version Imprimez la version de ce programme et sortant.
--WRITE-LANG-DEF = Écrit dans les filtres de traitement de la langue
puis sort. Utile comme première étape pour créer
définitions de langue personnalisée. Remarque: langues qui
La carte de la même extension de fichier sera exclue.
(Voir aussi --Force-Lang-def, - Read-Lang-def).
--Write-Lang-def-Incl-dup =
Identique à --Write-Lang-def, mais inclut dupliqué
extensions. Cela génère une langue problématique
Fichier de définition car CLOC refusera d'utiliser
il jusqu'à ce que les doublons soient supprimés.

Options de sortie
--3 Imprimez la sortie du langage de troisième génération.
(Cette option peut entraîner l'échec de la sommation des rapports
Si certains rapports étaient produits avec cette option
tandis que d'autres ont été produits sans lui.)
- par percent x au lieu de commentaire et de comptes de lignes vierges, montrez
ces valeurs en pourcentages en fonction de la valeur
de x dans le dénominateur:
X = 'c' -> # lignes de code
X = 'cm' -> # lignes de code + commentaires
X = 'cb' -> # lignes de code + blanc
X = 'cmb' -> # lignes de code + commentaires + blancs
Par exemple, si vous utilisez la méthode «C» et votre code
a deux fois plus de lignes de commentaires que les lignes
de code, la valeur de la colonne de commentaire
être 200%. La colonne de code reste un nombre de lignes.
--CSV Écrivez les résultats en tant que valeurs séparées par la virgule.
--CSV-Delimiter = Utilisez le caractère comme délimiteur pour la virgule
Fichiers séparés au lieu de ,. Ce commutateur force - CSV à être allumé.
--file-coding = écriture de fichiers de sortie en utilisant le codage au lieu de
L'ASCII par défaut ( = 'UTF-7'). Exemples: «UTF-16»,
«EUC-KR», «ISO-8859-16». Les encodages connus peuvent être
imprimé avec
perl -Mencode -e 'print join (" n", encode-> Encodings (": all")), " n"'
- Hide Rate n'afficher pas les taux de traitement des lignes et des fichiers dans le
En-tête de sortie. Cela rend la sortie déterministe.
--json Écrivez les résultats en tant que notation d'objet JavaScript
(JSON) Sortie formatée.
--MD Écrivez les résultats en tant que texte de marque de marque.
--out = Synonyme pour --Report-File = .
--Progress-rate = Afficher la mise à jour de progression après que chaque fichiers soit
traité (par défaut = 100). Définir sur 0 à
supprimer la sortie de progrès (utile lors de la redirection
sortie vers stdout).
- Crésiter tous les messages d'information, sauf
le rapport final.
--Report-file = Écrivez les résultats à au lieu de stdout.
--sql = Écrivez les résultats en tant que SQL Créer et insérer des instructions
qui peut être lu par un programme de base de données tels que
Sqlite. Si est -, la sortie est envoyée à STDOUT.
- SQL-APPEND APPEND SQL INSERT INSTERTS DANS LE FICHIER SPÉCIFIÉ
par --sql et ne générez pas de création de table
déclarations. Seulement valide avec l'option --SQL.
--sql-project = use comme identifiant de projet pour le
Exécution actuelle. Seulement valide avec l'option --SQL.
--SQL-Style = Écrivez des instructions SQL dans le style donné à la place
du format SQLite par défaut. Les styles incluent
«Oracle» et «Named_Columns».
--Um-one pour les rapports de texte brut, affichez la somme: ligne de sortie
Même si un seul fichier d'entrée est traité.
--xml Écrivez les résultats en XML.
--xsl = Référence En tant que feuille de style XSL dans
la sortie XML. Si est 1 (Numérique),
écrit une feuille de style par défaut, CloC.xsl (ou
Cloc-Diff.xsl si --Diff est également donné).
Ce commutateur force --xml sur.
- Yaml Écrivez les résultats dans Yaml.

Langues reconnues ▲

 Invite> Cloc --show-Lang

ABAP (ABAP)
ActionScript (AS)
Ada (Ada, ADB, publicités, pad)
ADSO / IDSM (ADSO)
Agda (Agda, Lagda)
Ample (ample, dofile, startup)
Ansprolog (LP)
Ant (build.xml, build.xml)
Grammaire antlr (G, G4)
Classe Apex (CLS)
Apex Trigger (Trigger)
APL (APL, APLA, APLC, APLF, APLI, APLN, APLO, DYLOG, DYAPP, MIPAGE)
Applescript (AppleScript)
Sketch Arduino (INO)
Arkts (ETS)
Arturo (art)
Asciidoc (adoc, asciidoc)
ASP (ASA, ASHX, ASP, AXD)
Asp.net (Asax, ASCX, ASMX, ASPX, Master, Sitemap, WebInfo)
Aspectj (AJ)
Assemblage (A51, ASM, NASM, S, S)
Astro (Astro)
Asymptote (asy)
AutoHotKey (Ahk, Ahkl)
awk (auk, awk, gawk, mawk, nawk)
Bazel (build)
Biztalk Orchestration (ODX)
Biztalk Pipeline (BTP)
Lame (lame, lame.php)
Bourne Again Shell (bash)
Bourne Shell (SH)
BrightScript (BRS)
builder (xml.builder)
C (C, Cats, EC, IDC, PGC)
C Shell (CSH, TCSH)
C # (CS)
C # Designer (Designer.CS)
C ++ (C, C ++, C ++ M, CC, CCM, CPP, CPP, CPPM, CXX, CXXM, H ++, INL, IPP, IXX, PCC, TCC, TPP)
En-tête C / C ++ (H, H, HH, HPP, HXX)
Caire (Caire)
Script de construction de gâteaux (gâteau)
Carbone (carbone)
CCS (CCS)
Chapelle (CHPL)
Circom (Circom)
Clean (DCL, ICL)
Clojure (Boot, Cl2, CLJ, CLJS.HL, CLJSCM, CLJX, HIC, RIEMAND.CONFIG)
Clojurec (CLJC)
Clojurescript (CLJS)
Cmake (cmake, cmake.in, cmakelists.txt)
COBOL (CBL, CBL, CCP, COB, COB, COBOL, CPY)
Cocoa 5 (C5, Cocoa5, Cocoa5Server, CPKG5)
CoffeeScript (_Coffee, Cakefile, CJSX, café, glacé)
Coldfusion (CFM, CFML)
ColdFusion CFScript (CFC)
Grammaire de contrainte (CG3, RLX)
Containerfile (ContainerFile)
Coq (v)
Crystal (CR)
CSON (CSON)
CSS (CSS)
CSV (CSV)
Concombre (fonctionnalité)
Cuda (cu, cuh)
Cython (PXD, PXI, PYX)
D (d)
Dafny (DFY)
Dal (da)
Fléchette (fléchette)
Delphi Form (DFM)
Denizenscript (DSC)
Derw (derw)
Dhall (dhall)
Diet (DT)
Diff (Diff, patch)
Dita (Dita)
Dockerfile (dockerfile, dockerfile)
Langue d'extension des portes (DXL)
DOS Batch (Bat, Bat, BTM, BTM, CMD, CMD)
Bave (DRL)
DTD (DTD)
dtrace (d)
ECPP (ECPP)
Eex (eex)
EJS (EJS)
Elixir (ex, exs)
Elm (orme)
Crystal intégré (ECR)
Erb (erb, erb)
Erlang (App.src, Emakefile, ERL, HRL, Rebar.Config, Rebar.config.lock, Rebar.lock, Xrl, Yrl)
Attendre (exp)
F # (FSI, FS, FS)
Script f # (FSX)
Fenouil (FNL)
Langue d'état finie (FSL, JSSM)
Coquille de poisson (poisson)
Flatbuffers (FBS)
Focus (FOCEXEC)
Forth (4th, E4, F83, FB, Forth, FPM, Fr, Frt, Ft, FTH, RX, FS, F, For)
FORTRAN 77 (F, F77, F77, pour, FTN, FTN, PFO, F, pour)
FORTRAN 90 (F90, F90)
FORTRAN 95 (F95, F95)
Modèle Freemarker (FTL)
Futhark (FUT)
FXML (FXML)
GDScript (GD)
Gencat NLS (MSG)
Glade (Glade, UI)
Lueur (lueur)
Glimmer Javascript (GJS)
Glimmer TypeScript (GTS)
GLSL (Comp, FP, FRAG, FRG, FSH, FSHADER, GEO, GEOM, GLSL, GLSLV, GSHADER, TESC, TESE, VERT, VRX, VSH, VSHADER)
Allez (allez, ʕ◔ϖ◔ʔ)
Godot Resource (TRES)
Godot Scene (TSCN)
Godot Shaders (GDShader)
Gradle (Gradle, Gradle.kts)
Graals (GSP)
GraphQL (GQL, GraphQL, GraphQLS)
Groovy (gant, groovy, grt, gtpl, gvy, jenkinsfile)
Haml (haml, haml.deface)
Guidon (guidon, HBS)
Port (HB)
Lièvre (ha)
Haskell (HS, HSC, LHS)
Haxe (HX, HXSL)
HCL (HCL, NOMAD, TF, TFVARS)
HLSL (CG, CGINC, FXH, HLSL, HLSLI, Shader)
Holyc (HC)
Hoon (Hoon)
HTML (HTM, HTML, HTML.HL, XHT)
Html eex (heex)
Idl (dlm, idl, pro)
Idris (IDR)
Igor Pro (IPF)
Imba (Imba)
INI (Buildozer.Spec, EditorConfig, INI, Lektorproject, préfs)
InstallerShield (ISM)
IPL (IPL)
Jai (Jai)
Janet (Janet)
Java (Java)
JavaScript (_JS, Bones, CJS, ES6, Jake, Jakefile, JS, JSB, JSCAD, JSFL, JSM, JSS, MJS, NJS, Pac, SJS, SSJS, XSJS, XSJSLIB)
Javaserver Faces (JSF)
JCL (JCL)
Template Jinja (J2, Jinja, Jinja2)
JSON (ARCCONFIG, AVSC, Composer.lock, Geojson, GLTF, HAR, HTMLHINTRC, JSON, JSON-TManguage, JSONL, McMeta, McMod.info, Tern-Config, Tern-Project, Tfstate, Tfstate.backup, Topojson, WatchManconfig, webApp, webmanifest, yyp)
JSON5 (JSON5)
Jsp (jsp, jspf)
JSX (JSX)
Julia (JL)
Juniper Junos (Junos)
Cahier Jupyter (IPYNB)
Kermit (KSC)
Korn Shell (KSH)
KOTLIN (KT, KTM, KTS)
Kvlang (KV)
Lean (Hlean, Lean)
Lem (lem)
Moins (moins)
Lex (L, Lex)
Lfe (lfe)
Script de linker (LD)
liquide (liquide)
LISP (ASD, EL, LISP, LSP, CL, JL)
Idris alphabétisé (lidr)
LifeLink Oscript (OScript)
LLVM IR (LL)
Logos (x, xm)
LogTalk (LGT, LogTalk)
Lua (Lua, NSE, P8, PD_LUA, RBXS, WLUA)
Luau (luau)
M4 (AC, M4)
Make (Am, GnumakeFile, GnumakeFile, Makefile, Makefile, MK)
Mako (Mako, Mao)
Markdown (Contents.LR, Markdown, MD, MDDOR, MDWN, MDX, MKD, MKDN, MKDOWN, RONN, CHAMBRE)
Mathematica (CDF, MA, Mathematica, MT, NBP, WL, WLT, M)
Matlab (m)
Maven (pom, pom.xml)
Meson (Meson.build)
Métal (métal)
Modelica (MO)
Modula3 (i3, ig, m3, mg)
Mojo (mojo,?)
Mojom (Mojom)
Script msbuild (btproj, csproj, msbuild, vcproj, wdproj, wixproj)
Oreillons (MPS, M)
Moustache (moustache)
MXML (MXML)
Script nant (build)
Nastran DMAP (DMAP)
Nemerle (n)
Netlogo (Nlogo, NLS)
Nickel (NCL)
Nim (Nim, Nim.Cfg, Nimble, Nimrod, Nims)
Nix (Nix)
Nunjucks (NJK)
Objectif-C (m)
Objectif-c ++ (mm)
OCAML (Eliom, Eliomi, ML, ML4, MLI, MLL, MLY)
Odin (Odin)
OpenCl (CL)
OpenSCAD (SCAD)
Oracle Forms (FMT)
Oracle PL / SQL (BOD, FNC, PRC, SPC, TRG)
Oracle Reports (REX)
P4 (P4)
Pascal (DPR, LPR, PAS, Pascal)
Pascal / Pawn (P)
Pascal / Puppet (PP)
Langue de commandement du patran (PCL, SES)
Pawn (pion, pwn)
PEG (PEG)
peg.js (pegjs)
Peggy (Peggy)
Perl (Ack, Al, Cpanfile, Makefile.pl, Perl, PH, PLH, PLX, PM, PSGI, Rexfile, PL, P6)
Pest (ravageur)
PHP (AW, CTP, PhakeFile, PHP, PHP3, PHP4, PHP5, PHP_CS, PHP_CS.DIST, PHPS, PHPT, PHTML)
PHP / Pascal / Fortran / Pawn (Inc)
Pig Latin (cochon)
PL / I (PL1)
PL / M (lit, PLM)
Plantuml (iuml, plantuml, pu, puml, wsd)
Fichier PO (PO)
Poney (poney)
PowerBuilder (PBT, SRA, SRF, SRM, SRS, SRU, SRW)
PowerShell (PS1, PSD1, PSM1)
Schéma de prisma (prisma)
Traitement (PDE)
Proguard (Pro)
Prolog (P, Prolog, Yap, PL, P6, Pro)
Propriétés (propriétés)
Tampons de protocole (proto)
PRQL (PRQL)
Pug (Jade, Pug)
Purecript (Purs)
Python (buck, build.bazel, gclient, gyp, gypi, LMI, py, py3, pyde, pyi, pyp, pyt, pyw, conscript, sconstruct, file de serpent, tac, espace de travail, wscript, wsgi, xpy)
QML (QBS, QML)
QT (UI)
QT LINGUIST (TS)
Projet QT (Pro)
R (Expr-Dist, R, R, RD, RPROFILE, RSX)
Racket (RKT, RKTD, RKTL, SCHBL)
Raku (PM6, Raku, Rakumod)
Raku / Prolog (P6, P6)
RAML (RAML)
RapyDScript (PYJ)
Razor (cshtml, rasoir)
Reasonml (re, rei)
Rescript (res, resi)
restructuré (rest, rest.txt, premier, rst.txt)
Rexx (PPRX, Rexx)
Anneau (RForm, RH, Ring)
RMD (RMD)
RobotFramework (robot)
Ruby (évaluations, berksfile, brasse PuppetFile, Rabl, Rake, RB, RBuild, RBW, RBX, RU, Snapfile, Thor, Thorfile, Vagrantfile, Watchr)
Ruby HTML (Rhtml)
Rust (Rs, Rs.in)
Saltstack (SLS)
SAS (SAS)
Sass (Sass)
Scala (Kojo, SBT, Scala)
Schéma (SC, SCH, SCM, SLD, SPS, SS, SLS)
SCSS (SCSS)
SED (SED)
Compétence (IL)
Skill ++ (ILS)
Tranche (glace)
Slim (mince)
Slint (Slint)
Smalltalk (st, cs)
Smarty (Smarty, TPL)
Snakemake (règles, SMK)
SoftBridge Basic (SBL, SBL)
Solidity (SOL)
Sparforte (SP)
Specman e (e)
SQL (CQL, MySQL, PSQL, SQL, SQL, TAB, UDF, VIW)
DATA SQL (DATA.SQL)
Procédure stockée SQL (Spc.sql, Spoc.Sql, Sproc.Sql, UDF.SQL)
Écureuil (écrou)
ML standard (Fun, SIG, SML)
Starlark (Bazel, BZL)
Stata (ado, do, do, doh, ihlp, mata, matah, sthlp)
Stylus (styl)
Sugars (SSS)
Svelte (svelte)
SVG (SVG, SVG)
Swift (Swift)
Swig (i)
TableGen (TD)
TCL / TK (ITK, TCL, TK)
Sarcelle (sarcelle)
TeamCenter Met (Met)
TeamCenter MTH (MTH)
Templ (Templ)
TEX (AUX, BBX, BIB, BST, CBX, DTX, INS, LBX, LTX, MKII, MKIV, MKVI, STY, Tex, CLS)
Texte (texte, txt)
Thrift (Thrift)
Informations sur le fichier du projet Titan (TPD)
Feuille de style titane (TSS)
TLA + (TLA)
TNSDL (CII, CIN, IN1, IN2, IN3, IN4, INF, INTERFACE, ROU, SDL, SDT, SPD, SSC, SST)
Toml (Toml)
Tspeg (JSpeg, Tspeg)
Ttcn (ttcn, ttcn2, ttcn3, ttcnpp)
Brindille (brindille)
TypeScript (MTS, TSX, TS)
Typst (typ)
Umka (um)
Unity-Prefab (Mat, Prefab)
Vala (Vala)
En-tête Vala (vapi)
VB pour les applications (VBA, VBA)
Langue de modèle de vitesse (VM)
Verilog-Systemverilog (SV, SVH, V)
VHDL (VHD, VHD, VHDL, VHDL, VHF, VHI, VHO, VHS, VHT, VHW)
script vim (vim)
Visual Basic (BAS, BAS, CTL, DSR, FRM, FRX, FRX, VBHTML, VBHTML, VBP, VBW, CLS)
Visual Basic .NET (VB, VB, VBPROJ)
Script de base visuel (VBS, VBS)
Visual Fox Pro (SCA, SCA)
Solution Visual Studio (SLN)
VisualForce Component (composant)
Page VisualForce (page)
Composant Vuejs (VUE)
Vyper (Vy)
Description des services Web (WSDL)
WebAssembly (Wast, Wat)
WGSL (WGSL)
Fichier de messages Windows (MC)
Définition du module Windows (DEF)
Fichier de ressources Windows (RC, RC2)
Wix include (wxi)
Source WIX (WXS)
Wix String Localisation (WXL)
WXML (WXML)
WXSS (WXSS)
X ++ (xpo)
Xaml (xaml)
XBase (PRG, PRW)
En-tête XBase (CH)
Xhtml (xhtml)
XMI (XMI, XMI)
XML (ADML, ADMX, ANT, APP.CONFIG, AXML, BUIDS, CCPROJ, CCXML, CLASSPATH, CLIXML, CPROJET, CSCFG, CSDEF, CSL, CT, DEPROJ, DITAMAP, DITAVAL, DLL.CONFIG, DOTSETTISS, FILTERS, FSPROJ, GMX, GRXML, IML, IVY, Jelly, Jsproj, KML, Launch, MDPolicy, MJML, NATVIS, NDPROJ, NPROJ, NUGET.CONFIG, NUSPEC, ODD, OSM, Packages.config, PKGPROJ, PLIST, PROJ, Project, Props, Props, PS1XML, PSC1, PT, RDF, RESX, RSS, SCXML, Settings.stylecop, Sfproj, Shproj, SRDF, Storyboard, Sttheme, Sublime-Snippet Vcxproj, vSixManifest, vSettings, Vstemplate, vxml, web.config, web.debug.config, web.release.config, wsf, x3d, xacro, xib, xlf, xliff, xml, xml, xml.dist, xproj, xspec, Xul, ZCML)
XQuery (XQ, XQL, XQM, XQuery, XQY)
XSD (XSD, XSD)
XSLT (XSL, XSL, XSLT, XSLT)
Xtend (xtend)
yacc (y, yacc)
YAML (Clang-Format, Clang-Tidy, Gemrc, Glide.lock, Mir, Reek, Rviz, Sublime-Syntax, Syntax, Yaml, YAML-TManguage, YML, YML.MYSQL)
Yang (Yang)
Zig (zig)
Zsh (Zsh)

~~La liste ci-dessus peut être personnalisée en lisant les définitions de langage à partir d'un fichier avec les options --read-lang-def ou --force-lang-def .~~

~~Ces extensions de fichiers sont à plusieurs langues:~~

~~Les fichiers cl peuvent être LISP ou OpenCL~~
~~Les fichiers cls peuvent être Visual Basic, Tex ou Apex Class~~
~~Les fichiers cs peuvent être C # ou Smalltalk~~
~~Les fichiers d peuvent être d ou dTrace~~
~~Les fichiers f pourraient être FORTRAN 77 ou~~
~~Les fichiers fnc peuvent être Oracle PL ou SQL~~
~~for les fichiers pourraient être FORTRAN 77 ou~~
~~Les fichiers fs pourraient être F # ou Forth~~
~~Les fichiers inc pourraient être PHP ou Pascal~~
~~Les fichiers itk peuvent être TCL ou TK~~
~~Les fichiers jl pourraient être Lisp ou Julia~~
~~Les fichiers lit peuvent être PL ou M~~
~~Les fichiers m pourraient être MATLAB, Mathematica, Objective-C, oreills ou mercure~~
~~Les fichiers p6 pourraient être Perl ou Prolog~~
~~Les fichiers pl pourraient être Perl ou Prolog~~
~~Les fichiers PL pourraient être Perl ou Prolog~~
~~Les fichiers pp peuvent être Pascal ou Puppet~~
~~Les fichiers pro pourraient être IDL, QT Project, Prolog ou Proguard~~
~~Les fichiers ts peuvent être linguistes de typeScript ou QT~~
~~Les fichiers ui peuvent être QT ou Glade~~
~~Les fichiers v peuvent être Verilog-Systemverilog ou CoQ~~

CLOC a des sous-programmes qui tentent d'identifier la langue correcte en fonction du contenu du fichier pour ces cas spéciaux. La précision d'identification du langage est une fonction de la quantité de code que contient le fichier; Les fichiers .m avec seulement une ou deux lignes, par exemple, ont rarement suffisamment d'informations pour distinguer correctement Matlab, Mercury, Humps ou Objective-C.

Les langues avec des collisions d'extension de fichiers sont difficiles à personnaliser avec --read-lang-def ou --force-lang-def car elles n'ont pas de mécanisme pour identifier les langues avec des extensions communes. Dans cette situation, il faut modifier le code source CLOC.

Comment ça marche ▲

La méthode de fonctionnement de CLOC ressemble à SlocCount: Tout d'abord, créez une liste de fichiers à considérer. Ensuite, essayez de déterminer si les fichiers trouvés contiennent ou non le code source du langage informatique reconnu. Enfin, pour les fichiers identifiés comme fichiers source, invoquez des routines spécifiques à la langue pour compter le nombre de lignes source.

~~Une description plus détaillée:~~

Si le fichier d'entrée est une archive (comme un fichier .tar.gz ou .zip), créez un répertoire temporaire et développez l'archive là-bas à l'aide d'un appel système vers un utilitaire sous-jacent approprié (TAR, BZIP2, unzip, etc.) Ce répertoire temporaire comme l'une des entrées. (Cela fonctionne de manière plus fiable sur UNIX que sur Windows.)
~~Utilisez un fichier :: Rechercher pour descendance récursivement les répertoires d'entrée et faire une liste des noms de fichiers candidats. Ignorez des fichiers binaires et de taille zéro.~~
Assurez-vous que les fichiers de la liste des candidats ont un contenu unique (d'abord en comparant les tailles de fichiers, puis, pour les fichiers de taille similaire, comparez les hachages MD5 du contenu du fichier avec Digest :: MD5). Pour chaque ensemble de fichiers identiques, supprimez tout sauf la première copie, tel que déterminé par un type lexical, de fichiers identiques de l'ensemble. Les fichiers supprimés ne sont pas inclus dans le rapport. (Le commutateur --skip-uniqueness désactive les tests d'unicité et force toutes les copies des fichiers à inclure dans le rapport.) Voir aussi le --ignored= Switch pour voir quels fichiers ont été ignorés et pourquoi.
Analysez la liste des fichiers candidats pour les extensions de fichiers que CLOC s'associe aux langages de programmation (voir les options --show-lang et --show-ext ). Les fichiers qui correspondent sont classés comme contenant du code source pour cette langue. Chaque fichier sans extension est ouvert et sa première ligne lue pour voir s'il s'agit d'un script de shell Unix (tout ce qui commence par #!). S'il s'agit de script shell, le fichier est classé par cette langue de script (si la langue est reconnue). Si le fichier n'a pas d'extension reconnue ou n'est pas une langue de script reconnue, le fichier est ignoré.
~~Tous les fichiers restants dans la liste des candidats doivent désormais être des fichiers source pour les langages de programmation connus. Pour chacun de ces fichiers:~~
1. ~~Lisez l'intégralité du fichier en mémoire.~~
2. ~~Comptez le nombre de lignes (= l _original ).~~
3. ~~Retirez les lignes vierges, puis comptez à nouveau (= l _{non_blank} ).~~
4. Boucle sur les filtres de commentaires définis pour cette langue. (Par exemple, C ++ a deux filtres: (1) Supprimer les lignes qui commencent par l'espace blanc facultatif suivi de // et (2) supprimer le texte entre / * et * /) appliquer chaque filtre au code pour supprimer les commentaires. Comptez les lignes gauche sur les lignes (= l du _code ).
5. Enregistrez les comptes pour cette langue:
  lignes vierges = l _original - l _{non_blank}
  lignes de commentaires = l _{non_blank} - l _code
  lignes de code = l _code

Les options modifient légèrement l'algorithme. L'option --read-lang-def , par exemple, permet à l'utilisateur de lire les définitions des filtres de commentaires, les extensions de fichiers connues et les langages de script connus à partir d'un fichier. Le code de cette option est traité entre les étapes 2 et 3.

Utilisation avancée ▲

Supprimer les commentaires du code source ▲

Comment savoir si la CLOC identifie correctement les commentaires? Une façon de vous convaincre CLOC est de faire la bonne chose est d'utiliser son option --strip-comments pour supprimer les commentaires et les lignes vierges des fichiers, puis comparer les fichiers dépouillés aux originaux.

~~Essayons cela avec la fusion SQLite, un fichier C contenant tout le code nécessaire pour créer la bibliothèque SQLite avec un fichier d'en-tête:~~

 Invite> Tar Zxf Sqlite-Amalgamation-3.5.6.tar.gz
Invite> CD Sqlite-3.5.6 /
Invite> CLOC - Strip-Comment = NC Sqlite.c
       1 fichier texte.
       1 fichier unique.
A écrit sqlite3.c.nc
       0 fichiers ignorés.

http://cloc.sourceforge.net v 1.03 t = 1.0 s (1.0 fichiers / s, 82895.0 lignes / s)
-------------------------------------------------- -----------------------------
Fichiers linguistiques Code de commentaire vide Échelle de 3e génération. équivalent
-------------------------------------------------- -----------------------------
C 1 5167 26827 50901 x 0,77 = 39193,77
-------------------------------------------------- -----------------------------

~~L'argument d'extension donné à - Strip-Comements est arbitraire; Ici, NC a été utilisée comme abréviation pour "aucun commentaire".~~

~~CLOC a supprimé plus de 31 000 lignes du fichier:~~

 invite> wc -l sqlite3.c sqlite3.c.nc
  82895 sqlite3.c
  50901 SQLITE3.C.NC
 133796 Total
Invite> Echo "82895 - 50901" | avant JC
31994

Nous pouvons maintenant comparer le fichier d'origine, sqlite3.c et celui dépouillé de commentaires, sqlite3.c.nc avec des outils comme Diff ou Vimdiff et voir exactement ce que CLOC a considéré les commentaires et les lignes vierges. Une preuve rigoureuse que le fichier dépouillé contient le même code C que l'original consiste à compiler ces fichiers et à comparer les sommes de contrôle des fichiers d'objet résultants.

~~Tout d'abord, le fichier source d'origine:~~

 Invite> gcc -c sqlite3.c
Invite> MD5SUM SQLITE3.O
CCE5F1A2EA27C7E44B2E1047E2588B49 SQLITE3.O

~~Ensuite, la version sans commentaires:~~

 Invite> MV SQLITE3.C.NC SQLITE3.c
Invite> gcc -c sqlite3.c
Invite> MD5SUM SQLITE3.O
CCE5F1A2EA27C7E44B2E1047E2588B49 SQLITE3.O

~~La CLOC a supprimé plus de 31 000 lignes de commentaires et de blancs mais n'a pas modifié le code source de manière significative puisque le fichier d'objet résultant correspond à l'original.~~

Travailler avec des archives compressées ▲

Les versions de la CLOC avant V1.07 ont nécessité une option --extract-with=CMD pour dire à CLOC comment développer un fichier d'archive. En commençant par V1.07, cette extraction est tentée automatiquement. À l'heure actuelle, la méthode d'extraction automatique fonctionne raisonnablement bien sur Unix-Type OS pour les types de fichiers suivants: .tar.gz , .tar.bz2 , .tar.xz , .tgz , .zip , .ear , .deb . Certaines de ces extensions fonctionnent sur Windows si l'on a installé Winzip dans l'emplacement par défaut ( C:Program FilesWinZipWinZip32.exe ). De plus, avec des versions plus récentes de Winzip, le [http://www.winzip.com/downcl.htm est nécessaire de la ligne de commande) est nécessaire pour un fonctionnement correct; Dans ce cas, on invoquerait la cloc avec quelque chose comme

 --extract-with = "" c:  programme files  winzip  wzunzip  "-e -o> file <."

~~Réf. http://sourceforge.net/projects/cloc/forums/forum/600963/topic/4021070?Message=8938196~~

Dans les situations où l'extraction automatique échoue, on peut essayer l'option --extract-with=CMD pour compter les lignes de code dans les fichiers TAR, les fichiers zip ou d'autres archives compressées pour lesquelles on a un outil d'extraction. CLOC prend la commande d'extraction fournie par l'utilisateur et étend l'archive dans un répertoire temporaire (créé avec Fichier :: Temp), compte les lignes de code dans le répertoire temporaire, puis supprime ce répertoire. Bien qu'il ne soit pas particulièrement utile lorsque vous traitez avec une seule archive compressée (après tout, si vous allez taper la commande d'extraction de toute façon, pourquoi ne pas simplement développer manuellement les archives?) Cette option est pratique pour travailler avec plusieurs archives à la fois.

~~Par exemple, disons que vous avez la source de tarball suivante sur une machine Unix~~

 perl-5.8.5.tar.gz
Python-2.4.2.tar.gz

~~Et vous voulez compter tout le code en eux. La commande serait~~

 CLOC --extract-with = 'gzip -dc> fichier <| Tar XF - 'Perl-5.8.5.Tar.gz Python-2.4.2.tar.gz

~~Si cette machine Unix a un goudron GNU (qui peut se compresser et extraire en une seule étape), la commande peut être raccourcie à~~

 CLOC --Extract-with = 'Tar Zxf> Fichier <' perl-5.8.5.tar.gz python-2.4.2.tar.gz

~~Sur un ordinateur Windows avec Winzip installé dans c:Program FilesWinZip la commande ressemblerait à~~

 CLOC.EXE --extract-with = "" C:  Program Files  Winzip  Winzip32.exe  "-e -o> Fichier <." perl-5.8.5.tar.gz python-2.4.2.tar.gz

Les fichiers Java .ear sont des fichiers zip contenant des fichiers zip supplémentaires. La CLOC peut gérer les archives compressées imbriquées sans difficulté - fourni tous ces fichiers sont compressés et archivés de la même manière. Exemples de comptage d'un fichier Java .ear dans Unix et Windows:

 UNIX> CLOC --Extract-with = "Unzip -d.> Fichier <" Project.ear
Dos> cloc.exe --extract-with = "" c:  programme files  winzip  winzip32.exe  "-e -o> file <." Projeter

Différences ▲

Le commutateur --diff permet de mesurer le changement relatif du code source et les commentaires entre deux versions d'un fichier, d'un répertoire ou d'une archive. Les différences révèlent bien plus que les dénombrements de code absolus de deux versions de fichiers. Par exemple, disons qu'un fichier source a 100 lignes et son développeur fournit une version plus récente avec 102 lignes. Le développeur a-t-il ajouté deux lignes de commentaires, ou supprimé dix-sept lignes source et ajouté quatorze lignes source et cinq lignes de commentaires, ou le développeur a-t-il fait une réécriture complète, jetant les 100 lignes originales et en ajoutant 102 lignes de toute nouvelle source? L'option DIFF indique combien de lignes de source ont été ajoutées, supprimées, modifiées ou restées les mêmes, et combien de lignes de commentaires ont été ajoutées, supprimées, modifiées ou restées les mêmes.

Les différences dans les lignes vides sont manipulées beaucoup plus grossièrement car elles sont dépouillées par la CLOC au début. À moins qu'une paire de fichiers ne soit identique, la CLOC ne rapportera que des différences dans les comptes absolus de lignes vides. En d'autres termes, on peut s'attendre à ne voir que des entrées pour «ajouter» si le deuxième fichier a plus de blancs que le premier, et «supprimé» si la situation est inversée. L'entrée pour «même» ne sera pas nul uniquement lorsque les deux fichiers sont identiques.

En plus des paires de fichiers, on peut donner des paires de répertoires CLOC, ou des paires d'archives de fichiers, ou une archive de fichiers et un répertoire. CLOC essaiera d'aligner des paires de fichiers dans les répertoires ou les archives et comparer les diff pour chaque paire. Par exemple, pour voir ce qui a changé entre GCC 4.4.0 et 4.5.0

 CLOC - Diff GCC-4.4.0.tar.bz2 GCC-4.5.0.tar.bz2

~~Soyez prêt à attendre un certain temps pour les résultats; L'option --diff fonctionne beaucoup plus lentement qu'un nombre de code absolu.~~

~~Pour voir comment CLOC aligne les fichiers entre les deux archives, utilisez l'option de --diff-alignment~~

 CLOC - Diff-Alignment = Align.txt GCC-4.4.0.tar.bz2 gcc-4.5.0.tar.bz2

Pour produire le fichier align.txt qui affiche les paires de fichiers ainsi que les fichiers ajoutés et supprimés. Les symboles == et != Avant chaque paire de fichiers indiquent si les fichiers sont identiques ( == ) ou s'ils ont un contenu différent ( != ).

~~Voici un exemple de sortie montrant la différence entre les versions Python 2.6.6 et 2.7:~~

 Invite> Cloc --Diff Python-2.7.9.Tgz Python-2.7.10.tar.xz
    4315 Fichiers texte.
    4313 Fichiers texte.S
    2173 fichiers ignorés.

4 erreurs:
Error diff, délai dépassé: /tmp/8toganb9y1/python-2.7.9/mac/modules/qt/_qtmodule.c
Erreur de diff, délai dépassé: /tmp/m6ldvsgaoq/python-2.7.10/mac/modules/qt/_qtmodule.c
Error de diff (commentaires cités?): /Tmp/8Toganb9y1/python-2.7.9/mac/modules/qd/qdsupport.py
Error dif (commentaires cités?): /Tmp/m6ldvsgaoq/python-2.7.10/mac/modules/qd/qdsupport.py

https://github.com/aldanial/cloc v 1,65 t = 298,59 s (0,0 fichiers / s, 0,0 lignes / s)
-------------------------------------------------- ---------------------------
Fichiers linguistiques Code de commentaires vierges
-------------------------------------------------- ---------------------------
Visual Basic
 même 2 0 1 12
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
faire
 même 11 0 340 2952
 modifié 1 0 0 1
 ajouté 0 0 0 0
 supprimé 0 0 0 0
différence
 Même 1 0 87 105
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
CSS
 même 0 0 19 327
 modifié 1 0 0 1
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Objectif-c
 Même 7 0 61 635
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Script nant
 même 2 0 0 30
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
XML
 même 3 0 2 72
 modifié 1 0 0 1
 ajouté 0 0 0 1
 supprimé 0 1 0 0
Fichier de ressources Windows
 même 3 0 56 206
 modifié 1 0 0 1
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Attendre
 Même 6 0 161 565
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
HTML
 Même 14 0 11 2344
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
script vim
 même 1 0 7 106
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
C++
 même 2 0 18 128
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Définition du module Windows
 même 7 0 187 2080
 modifié 2 0 0 0
 ajouté 0 0 0 1
 supprimé 0 1 0 2
Prolog
 même 1 0 0 24
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Javascript
 Même 3 0 49 229
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Assemblée
 Même 51 0 6794 12298
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Obus de Bourne
 Même 41 0 7698 45024
 modifié 1 0 0 3
 ajouté 0 13 2 64
 supprimé 0 0 0 0
Lot DOS
 Même 29 0 107 494
 modifié 1 0 0 9
 ajouté 0 1 0 3
 supprimé 0 0 0 0
Script msbuild
 Même 77 0 3 38910
 modifié 0 0 0 0
 ajouté 0 0 0 0
 supprimé 0 0 0 0
Python
 Même 1947 0 109012 430335
 modifié 192 0 94 950
 ajouté 2 323 283 2532
 enlevé 2 55 58 646
M4
 même 18 0 191 15352
 modifié 1 0 0 2
 ajouté 1 31 0 205
 supprimé 0 0 0 0
C
 Même 505 0 37439 347837
 modifié 45 0 13 218
 ajouté 0 90 33 795
 supprimé 0 9 2 148
En-tête C / C ++
 Même 255 0 10361 66635
 modifié 5 0 5 7
 ajouté 0 1 3 300
 supprimé 0 0 0 0
-------------------------------------------------- -------------------
SOMME:
 Même 2986 0 172604 966700
 modifié 251 0 112 1193
 ajouté 3 459 321 3901
 supprimé 2 66 60 796
-------------------------------------------------- -------------------

Une paire d'erreurs s'est produite. La première paire a été causée par la synchronisation lors du calcul des difficultés du fichier Python-X/Mac/Modules/qt/_Qtmodule.c dans chaque version python. Ce fichier a> 26 000 lignes de code C et prend plus de 10 secondes - la durée maximale par défaut pour diffuser un seul fichier - sur mon ordinateur lent. (Remarque: Cela fait référence à des différences effectuées avec la fonction sdiff() dans le module Perl Algorithm::Diff , pas l'utilitaire diff de la ligne de commande.) Cette erreur peut être surmontée en augmentant le temps pour, disons, 20 secondes avec --diff-timeout 20 .

La deuxième erreur est plus problématique. Les fichiers Python-X/Mac/Modules/qd/qdsupport.py incluent python docstring (texte entre des paires de citations triples) contenant c commentaires. CLOC traite les docstrings comme des commentaires et les gère en les convertissant d'abord en commentaires C, puis en utilisant le commentaire C supprimant l'expression régulière. Les commentaires C imbriqués donnent cependant des résultats erronés.

Créer des définitions de langage personnalisé ▲

CLOC peut écrire ses définitions de commentaires de langue dans un fichier ou peut lire les définitions des commentaires à partir d'un fichier, passant les définitions intégrées. Cela peut être utile lorsque vous souhaitez utiliser la CLOC pour compter les lignes d'une langue non encore incluse, pour modifier l'association des extensions de fichiers vers les langues, ou pour modifier la façon dont les langues existantes sont comptées.

~~Le moyen le plus simple de créer un fichier de définition de langage personnalisé est de faire en sorte que CLOC écrive ses définitions dans un fichier, puis modifie ce fichier:~~

 UNIX> CLOC --WRITE-LANG-DEF = MY_DEFINITIONS.TXT

Crée le fichier my_definitions.txt qui peut être modifié, puis relisez avec l'option --read-lang-def ou --force-lang-def . La différence entre les options est l'ancienne fusion des définitions de langue du fichier donné dans les définitions internes de CLOC avec la priorité de CLOC en cas de chevauchement. L'option --force-lang-def , en revanche, remplace complètement les définitions de CLOC. Cette option présente un désavantage dans l'empêche de CLOC de compter les langues dont les extensions se mortent à plusieurs langues car ces langues nécessitent une logique supplémentaire qui n'est pas facilement exprimée dans un fichier de définitions.

 UNIX> CLOC - Read-Lang-def = MY_DEFINITIONS.TXT FILE1 FILE2 DIR1 ...

~~Chaque entrée de langue a quatre parties:~~

~~Le nom de la langue commençant dans la colonne 1.~~
~~Un ou plusieurs filtres de commentaires à partir de la colonne 5.~~
~~Une ou plusieurs extensions de nom de fichier à partir de la colonne 5.~~
Un facteur d'échelle de 3e génération commençant dans la colonne 5. Cette entrée doit être fournie, mais sa valeur n'est pas importante à moins que vous ne vouliez comparer votre langage à un langage de programmation hypothétique de troisième génération.

~~Un filtre définit une méthode pour supprimer le texte de commentaire du fichier source. Par exemple, l'entrée pour C ++ ressemble à ceci~~

 C++
    filtre call_regexp_common C ++
    Filtre Remove_inline //.*$
    Extension C
    Extension C ++
    Extension CC
    extension cpp
    Extension CXX
    Extension PCC
    3rd_gen_scale 1.51
    end_of_line_continuation \ $

C ++ a deux filtres: Premièrement, supprimer les lignes correspondant à Regexp :: Common C ++ Commentaire Regex. Le deuxième filtre à l'aide de Remove_inline est actuellement inutilisé. Son intention est d'identifier les lignes avec le code et les commentaires et il peut être implémenté à l'avenir.

Une discussion plus complète des différentes options de filtre peut apparaître ici à l'avenir. La sortie de l'option --write-lang-def de CLOC doit fournir suffisamment d'exemples pour que les individus motivés modifient ou étendent les définitions de langage de CLOC.

Combiner les rapports ▲

Si vous gérez plusieurs projets logiciels, vous pourriez être intéressé à voir les comptes de lignes par projet, pas seulement par la langue. Supposons que vous gérez trois projets logiciels appelés MARIADB, PostgreSQL et SQLite. Les équipes responsables de chacun de ces projets exécutent la CLOC sur leur code source et vous fournissent la sortie. Par exemple, l'équipe MariADB fait

 Cloc --out mariaDB-10.1.txt MariaDB-Server-10.1.zip

~~and provides you with the file mariadb-10.1.txt . The contents of the three files you get are~~

 Unix> cat mariadb-10.1.txt
https://github.com/AlDanial/cloc v 1.65 T=45.36 s (110.5 files/s, 66411.4 lines/s)
-------------------------------------------------- ---------------------------------
Language files blank comment code
-------------------------------------------------- ---------------------------------
C++ 1613 225338 290077 983026
C 853 62442 73017 715018
C/C++ Header 1327 48300 114577 209394
Bourne Shell 256 10224 10810 61943
Perl 147 10342 8305 35562
Pascal 107 4907 5237 32541
HTML 56 195 6 16489
Javascript 5 3309 3019 15540
m4 30 1599 359 14215
CMake 190 1919 4097 12206
XML 35 648 56 5210
Ruby 59 619 184 4998
Puppet 10 0 1 3848
make 134 724 360 3631
SQL 23 306 377 3405
Python 34 371 122 2545
Bourne Again Shell 27 299 380 1604
Windows Module Definition 37 27 13 1211
lex 4 394 166 991
yacc 2 152 64 810
DOS Batch 19 89 82 700
Prolog 1 9 40 448
RobotFramework 1 0 0 441
CSS 2 33 155 393
JSON 5 0 0 359
dtrace 9 59 179 306
Windows Resource File 10 61 89 250
Assembly 2 70 284 237
WiX source 1 18 10 155
Visual Basic 6 0 0 88
YAML 2 4 4 65
PHP 1 11 2 24
SKILL 1 8 15 16
sed 2 0 0 16
Windows Message File 1 2 8 6
diff 1 1 4 4
D 1 4 11 4
-------------------------------------------------- ---------------------------------
SUM: 5014 372484 512110 2127699
-------------------------------------------------- ---------------------------------

Unix> cat sqlite-3081101.txt
https://github.com/AlDanial/cloc v 1.65 T=1.22 s (3.3 files/s, 143783.6 lines/s)
-------------------------------------------------- -----------------------------
Language files blank comment code
-------------------------------------------------- -----------------------------
C 2 11059 53924 101454
C/C++ Header 2 211 6630 1546
-------------------------------------------------- -----------------------------
SUM: 4 11270 60554 103000
-------------------------------------------------- -----------------------------

Unix> cat postgresql-9.4.4.txt
https://github.com/AlDanial/cloc v 1.65 T=22.46 s (172.0 files/s, 96721.6 lines/s)
-------------------------------------------------- ---------------------------------
Language files blank comment code
-------------------------------------------------- ---------------------------------
HTML 1254 3725 0 785991
C 1139 139289 244045 736519
C/C++ Header 667 12277 32488 57014
SQL 410 13400 8745 51926
yacc 8 3163 2669 28491
Bourne Shell 41 2647 2440 17170
Perl 81 1702 1308 9456
lex 9 792 1631 4285
make 205 1525 1554 4114
m4 12 218 25 1642
Windows Module Definition 13 4 17 1152
XSLT 5 76 55 294
DOS Batch 7 29 30 92
CSS 1 20 7 69
Assembly 3 17 38 69
D 1 14 14 66
Windows Resource File 3 4 0 62
Lisp 1 1 1 16
sed 1 1 7 15
Python 1 5 0 13
Bourne Again Shell 1 8 6 10
Windows Message File 1 0 0 5
-------------------------------------------------- ---------------------------------
SUM: 3864 178917 295080 1698471
-------------------------------------------------- ---------------------------------

~~While these three files are interesting, you also want to see the combined counts from all projects. That can be done with cloc's --sum_reports option:~~

 Unix> cloc --sum-reports --out=databases mariadb-10.1.txt sqlite-3081101.txt postgresql-9.4.4.txt
Wrote databases.lang
Wrote databases.file

~~The report combination produces two output files, one for sums by programming language ( databases.lang ) and one by project ( databases.file ). Their contents are~~

 Unix> cat databases.lang
https://github.com/AlDanial/cloc v 1.65
-------------------------------------------------- -------------------------------
Language files blank comment code
-------------------------------------------------- -------------------------------
C 1994 212790 370986 1552991
C++ 1613 225338 290077 983026
HTML 1310 3920 6 802480
C/C++ Header 1996 60788 153695 267954
Bourne Shell 297 12871 13250 79113
SQL 433 13706 9122 55331
Perl 228 12044 9613 45018
Pascal 107 4907 5237 32541
yacc 10 3315 2733 29301
m4 42 1817 384 15857
Javascript 5 3309 3019 15540
CMake 190 1919 4097 12206
make 339 2249 1914 7745
lex 13 1186 1797 5276
XML 35 648 56 5210
Ruby 59 619 184 4998
Puppet 10 0 1 3848
Python 35 376 122 2558
Windows Module Definition 50 31 30 2363
Bourne Again Shell 28 307 386 1614
DOS Batch 26 118 112 792
CSS 3 53 162 462
Prolog 1 9 40 448
RobotFramework 1 0 0 441
JSON 5 0 0 359
Windows Resource File 13 65 89 312
Assembly 5 87 322 306
dtrace 9 59 179 306
XSLT 5 76 55 294
WiX source 1 18 10 155
Visual Basic 6 0 0 88
D 2 18 25 70
YAML 2 4 4 65
sed 3 1 7 31
PHP 1 11 2 24
SKILL 1 8 15 16
Lisp 1 1 1 16
Windows Message File 2 2 8 11
diff 1 1 4 4
-------------------------------------------------- -------------------------------
SUM: 8882 562671 867744 3929170
-------------------------------------------------- -------------------------------

Unix> cat databases.file
-------------------------------------------------- --------------------------------
File files blank comment code
-------------------------------------------------- --------------------------------
mariadb-10.1.txt 5014 372484 512110 2127699
postgresql-9.4.4.txt 3864 178917 295080 1698471
sqlite-3081101.txt 4 11270 60554 103000
-------------------------------------------------- --------------------------------
SUM: 8882 562671 867744 3929170
-------------------------------------------------- --------------------------------

Report files themselves can be summed together. Say you also manage development of Perl and Python and you want to keep track of those line counts separately from your database projects. First create reports for Perl and Python separately:

 cloc --out perl-5.22.0.txt perl-5.22.0.tar.gz
cloc --out python-2.7.10.txt Python-2.7.10.tar.xz

~~then sum these together with~~

 Unix> cloc --sum-reports --out script_lang perl-5.22.0.txt python-2.7.10.txt
Wrote script_lang.lang
Wrote script_lang.file

Unix> cat script_lang.lang
https://github.com/AlDanial/cloc v 1.65
-------------------------------------------------- -----------------------------
Language files blank comment code
-------------------------------------------------- -----------------------------
Perl 2892 136396 184362 536445
C 680 75566 71211 531203
Python 2141 89642 109524 434015
C/C++ Header 408 16433 26938 214800
Bourne Shell 154 11088 14496 87759
MSBuild script 77 0 3 38910
m4 20 1604 191 15559
Assembly 51 3775 6794 12298
Pascal 8 458 1603 8592
make 16 897 828 4939
XML 37 198 2 2484
HTML 14 393 11 2344
C++ 12 338 295 2161
Windows Module Definition 9 171 187 2081
YAML 49 20 15 2078
Prolog 12 438 2 1146
JSON 14 1 0 1037
yacc 1 85 76 998
DOS Batch 44 199 148 895
Objective-C 7 98 61 635
Expect 6 104 161 565
Windows Message File 1 102 11 489
CSS 1 98 19 328
Windows Resource File 7 55 56 292
Javascript 3 31 49 229
vim script 1 36 7 106
diff 1 17 87 105
NAnt script 2 1 0 30
IDL 1 0 0 24
Visual Basic 2 1 1 12
D 1 5 7 8
Lisp 2 0 3 4
-------------------------------------------------- -----------------------------
SUM: 6674 338250 417148 1902571
-------------------------------------------------- -----------------------------

Unix> cat script_lang.file
-------------------------------------------------- -----------------------------
File files blank comment code
-------------------------------------------------- -----------------------------
python-2.7.10.txt 3240 161276 173214 998697
perl-5.22.0.txt 3434 176974 243934 903874
-------------------------------------------------- -----------------------------
SUM: 6674 338250 417148 1902571
-------------------------------------------------- -----------------------------

~~Finally, combine the combination files:~~

 Unix> cloc --sum-reports --report_file=everything databases.lang script_lang.lang
Wrote everything.lang
Wrote everything.file

Unix> cat everything.lang
https://github.com/AlDanial/cloc v 1.65
-------------------------------------------------- -------------------------------
Language files blank comment code
-------------------------------------------------- -------------------------------
C 2674 288356 442197 2084194
C++ 1625 225676 290372 985187
HTML 1324 4313 17 804824
Perl 3120 148440 193975 581463
C/C++ Header 2404 77221 180633 482754
Python 2176 90018 109646 436573
Bourne Shell 451 23959 27746 166872
SQL 433 13706 9122 55331
Pascal 115 5365 6840 41133
MSBuild script 77 0 3 38910
m4 62 3421 575 31416
yacc 11 3400 2809 30299
Javascript 8 3340 3068 15769
make 355 3146 2742 12684
Assembly 56 3862 7116 12604
CMake 190 1919 4097 12206
XML 72 846 58 7694
lex 13 1186 1797 5276
Ruby 59 619 184 4998
Windows Module Definition 59 202 217 4444
Puppet 10 0 1 3848
YAML 51 24 19 2143
DOS Batch 70 317 260 1687
Bourne Again Shell 28 307 386 1614
Prolog 13 447 42 1594
JSON 19 1 0 1396
CSS 4 151 181 790
Objective-C 7 98 61 635
Windows Resource File 20 120 145 604
Expect 6 104 161 565
Windows Message File 3 104 19 500
RobotFramework 1 0 0 441
dtrace 9 59 179 306
XSLT 5 76 55 294
WiX source 1 18 10 155
diff 2 18 91 109
vim script 1 36 7 106
Visual Basic 8 1 1 100
D 3 23 32 78
sed 3 1 7 31
NAnt script 2 1 0 30
IDL 1 0 0 24
PHP 1 11 2 24
Lisp 3 1 4 20
SKILL 1 8 15 16
-------------------------------------------------- -------------------------------
SUM: 15556 900921 1284892 5831741
-------------------------------------------------- -------------------------------

Unix> cat everything.file
-------------------------------------------------- -----------------------------
File files blank comment code
-------------------------------------------------- -----------------------------
databases.lang 8882 562671 867744 3929170
script_lang.lang 6674 338250 417148 1902571
-------------------------------------------------- -----------------------------
SUM: 15556 900921 1284892 5831741
-------------------------------------------------- -----------------------------

~~One limitation of the --sum-reports feature is that the individual counts must be saved in the plain text format. Counts saved as XML, JSON, YAML, or SQL will produce errors if used in a summation.~~

SQL ▲

Cloc can write results in the form of SQL table create and insert statements for use with relational database programs such as SQLite, MySQL, PostgreSQL, Oracle, or Microsoft SQL. Once the code count information is in a database, the information can be interrogated and displayed in interesting ways.

~~A database created from cloc SQL output has two tables, metadata and t :~~

~~Table metadata :~~

Champ Taper
identifiant integer primary key
horodatage texte
projet texte
elapsed_s texte
Table t :
Champ Taper
projet texte
langue texte
déposer texte
nBlank entier
nComment entier
nCode entier
nScaled réel
foreign key (id) references metadata (id)
The metadata table contains information about when the cloc run was made. Run time is stored two ways: as Unix epoch seconds in id and as an ISO 8601 formatted text string in the local time zone (for example 2024-03-01 14:19:41 ) in timestamp . The --sql-append switch allows one to combine many runs in a single database; each run adds a row to the metadata table. The code count information resides in table t . The id key makes it easy to associate a run's code count with its metadata.
Let's repeat the code count examples of Perl, Python, SQLite, MySQL and PostgreSQL tarballs shown in the Combine Reports example above, this time using the SQL output options and the SQLite database engine.
The --sql switch tells cloc to generate output in the form of SQL table create and insert commands. The switch takes an argument of a file name to write these SQL statements into, or, if the argument is 1 (numeric one), streams output to STDOUT. Since the SQLite command line program, sqlite3 , can read commands from STDIN, we can dispense with storing SQL statements to a file and use --sql 1 to pipe data directly into the SQLite executable:
cloc --sql 1 --sql-project mariadb mariadb-server-10.1.zip | sqlite3 code.db
The --sql-project mariadb part is optional; there's no need to specify a project name when working with just one code base. However, since we'll be adding code counts from four other tarballs, we'll only be able to identify data by input source if we supply a project name for each run.
Now that we have a database we will need to pass in the --sql-append switch to tell cloc not to wipe out this database but instead add more data:
cloc --sql 1 --sql-project postgresql --sql-append postgresql-9.4.4.tar.bz2 | sqlite3 code.db cloc --sql 1 --sql-project sqlite --sql-append sqlite-amalgamation-3081101.zip | sqlite3 code.db cloc --sql 1 --sql-project python --sql-append Python-2.7.10.tar.xz | sqlite3 code.db cloc --sql 1 --sql-project perl --sql-append perl-5.22.0.tar.gz | sqlite3 code.db
Now the fun begins--we have a database, code.db , with lots of information about the five projects and can query it for all manner of interesting facts.
Which is the longest file over all projects?
prompt> sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t where nL = (select max(nBlank+nComment+nCode) from t)' sqlite|sqlite-amalgamation-3081101/sqlite3.c|161623
sqlite3 's default output format leaves a bit to be desired. We can add an option to the program's rc file, ~/.sqliterc , to show column headers:
.header on
One might be tempted to also include
.mode column
in ~/.sqliterc but this causes problems when the output has more than one row since the widths of entries in the first row govern the maximum width for all subsequent rows. Often this leads to truncated output--not at all desirable. One option is to write a custom SQLite output formatter such as sqlite_formatter , included with cloc.
To use it, simply pass sqlite3 's STDOUT into sqlite_formatter via a pipe:
prompt> sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t where nL = (select max(nBlank+nComment+nCode) from t)' | ./sqlite_formatter -- Loading resources from ~/.sqliterc Project File nL _______ _____________________________________ ______ sqlite sqlite-amalgamation-3081101/sqlite3.c 161623
If the "Project File" line doesn't appear, add .header on to your ~/.sqliterc file as explained above.
What is the longest file over all projects?
prompt> sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t where nL = (select max(nBlank+nComment+nCode) from t)' | sqlite_formatter Project File nL _______ _____________________________________ ______ sqlite sqlite-amalgamation-3081101/sqlite3.c 161623
What is the longest file in each project?
prompt> sqlite3 code.db 'select project,file,max(nBlank+nComment+nCode) as nL from t group by project order by nL;' | sqlite_formatter Project File nL __________ ________________________________________________________________ ______ python Python-2.7.10/Mac/Modules/qt/_Qtmodule.c 28091 postgresql postgresql-9.4.4/src/interfaces/ecpg/preproc/preproc.c 54623 mariadb server-10.1/storage/mroonga/vendor/groonga/lib/nfkc.c 80246 perl perl-5.22.0/cpan/Locale-Codes/lib/Locale/Codes/Language_Codes.pm 100747 sqlite sqlite-amalgamation-3081101/sqlite3.c 161623
Which files in each project have the most code lines?
prompt> sqlite3 code.db 'select project,file,max(nCode) as nL from t group by project order by nL desc;' | sqlite_formatter Project File nL __________ ________________________________________________________________ ______ perl perl-5.22.0/cpan/Locale-Codes/lib/Locale/Codes/Language_Codes.pm 100735 sqlite sqlite-amalgamation-3081101/sqlite3.c 97469 mariadb server-10.1/storage/mroonga/vendor/groonga/lib/nfkc.c 80221 postgresql postgresql-9.4.4/src/interfaces/ecpg/preproc/preproc.c 45297 python Python-2.7.10/Mac/Modules/qt/_Qtmodule.c 26705
Which C source files with more than 300 lines have a comment ratio below 1%?
prompt> sqlite3 code.db 'select project, file, nCode, nComment, (100.0*nComment)/(nComment+nCode) as comment_ratio from t where language="C" and nCode > 300 and comment_ratio < 1 order by comment_ratio;' | sqlite_formatter Project File nCode nComment comment_ratio __________ _______________________________________________________________________________________________ _____ ________ __________________ mariadb server-10.1/storage/mroonga/vendor/groonga/lib/nfkc.c 80221 14 0.0174487443135789 python Python-2.7.10/Python/graminit.c 2175 1 0.0459558823529412 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_turkish.c 2095 1 0.0477099236641221 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_french.c 1211 1 0.0825082508250825 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_french.c 1201 1 0.0831946755407654 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_hungarian.c 1182 1 0.084530853761623 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_hungarian.c 1178 1 0.0848176420695505 mariadb server-10.1/strings/ctype-eucjpms.c 67466 60 0.0888546633889169 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_english.c 1072 1 0.0931966449207828 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_english.c 1064 1 0.0938967136150235 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_spanish.c 1053 1 0.094876660341556 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_spanish.c 1049 1 0.0952380952380952 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_italian.c 1031 1 0.0968992248062016 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_italian.c 1023 1 0.09765625 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_portuguese.c 981 1 0.10183299389002 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_portuguese.c 975 1 0.102459016393443 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_romanian.c 967 1 0.103305785123967 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_2_romanian.c 961 1 0.103950103950104 mariadb server-10.1/strings/ctype-ujis.c 67177 79 0.117461639110265 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_finnish.c 720 1 0.13869625520111 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_porter.c 717 1 0.139275766016713 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_finnish.c 714 1 0.13986013986014 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_porter.c 711 1 0.140449438202247 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_KOI8_R_russian.c 660 1 0.151285930408472 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_russian.c 654 1 0.152671755725191 python Python-2.7.10/Mac/Modules/qt/_Qtmodule.c 26705 42 0.157026956294164 python Python-2.7.10/Mac/Modules/icn/_Icnmodule.c 1521 3 0.196850393700787 mariadb server-10.1/strings/ctype-extra.c 8282 18 0.216867469879518 postgresql postgresql-9.4.4/src/bin/psql/sql_help.c 3576 8 0.223214285714286 mariadb server-10.1/strings/ctype-sjis.c 34006 86 0.252258594391646 python Python-2.7.10/Python/Python-ast.c 6554 17 0.258712524729874 mariadb server-10.1/strings/ctype-cp932.c 34609 92 0.265122042592432 perl perl-5.22.0/keywords.c 2815 8 0.283386468296139 python Python-2.7.10/Mac/Modules/menu/_Menumodule.c 3263 10 0.305530094714329 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_dutch.c 596 2 0.334448160535117 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_dutch.c 586 2 0.340136054421769 mariadb server-10.1/strings/ctype-gbk.c 10684 38 0.354411490393583 python Python-2.7.10/Mac/Modules/qd/_Qdmodule.c 6694 24 0.357249181303959 python Python-2.7.10/Mac/Modules/win/_Winmodule.c 3056 11 0.358656667753505 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_german.c 476 2 0.418410041841004 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_german.c 470 2 0.423728813559322 mariadb server-10.1/strings/ctype-euc_kr.c 9956 44 0.44 postgresql postgresql-9.4.4/src/backend/utils/fmgrtab.c 4815 23 0.475403059115337 python Python-2.7.10/Mac/Modules/ctl/_Ctlmodule.c 5442 28 0.511882998171846 python Python-2.7.10/Mac/Modules/ae/_AEmodule.c 1347 7 0.51698670605613 python Python-2.7.10/Mac/Modules/app/_Appmodule.c 1712 9 0.52295177222545 mariadb server-10.1/strings/ctype-gb2312.c 6377 35 0.54585152838428 mariadb server-10.1/storage/tokudb/ft-index/third_party/xz-4.999.9beta/src/liblzma/lzma/fastpos_table.c 516 3 0.578034682080925 python Python-2.7.10/Mac/Modules/evt/_Evtmodule.c 504 3 0.591715976331361 python Python-2.7.10/Modules/expat/xmlrole.c 1256 8 0.632911392405063 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_danish.c 312 2 0.636942675159236 postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_danish.c 310 2 0.641025641025641 python Python-2.7.10/Mac/Modules/res/_Resmodule.c 1621 12 0.734843845682792 python Python-2.7.10/Mac/Modules/drag/_Dragmodule.c 1046 8 0.759013282732448 python Python-2.7.10/Mac/Modules/list/_Listmodule.c 1021 8 0.777453838678329 python Python-2.7.10/Mac/Modules/te/_TEmodule.c 1198 10 0.827814569536424 python Python-2.7.10/Mac/Modules/cg/_CGmodule.c 1190 10 0.833333333333333 python Python-2.7.10/Modules/clmodule.c 2379 23 0.957535387177352 python Python-2.7.10/Mac/Modules/folder/_Foldermodule.c 306 3 0.970873786407767
What are the ten longest files (based on code lines) that have no comments at all? Exclude header, .html, and YAML files.
prompt> sqlite3 code.db 'select project, file, nCode from t where nComment = 0 and language not in ("C/C++ Header", "YAML", "HTML") order by nCode desc limit 10;' | sqlite_formatter Project File nCode _______ ____________________________________________________________________ _____ perl perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/ja.pl 1938 python Python-2.7.10/PCbuild/pythoncore.vcproj 1889 python Python-2.7.10/PC/VS8.0/pythoncore.vcproj 1889 mariadb server-10.1/mysql-test/extra/binlog_tests/mysqlbinlog_row_engine.inc 1862 perl perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/zh_strk.pl 1589 perl perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/zh_zhu.pl 1563 mariadb server-10.1/storage/mroonga/vendor/groonga/configure.ac 1526 perl perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/zh_pin.pl 1505 mariadb server-10.1/mysql-test/suite/funcs_1/storedproc/storedproc_02.inc 1465 python Python-2.7.10/PC/VS8.0/_bsddb.vcproj 1463
What are the most popular languages (in terms of lines of code) in each project?
prompt> sqlite3 code.db 'select project, language, sum(nCode) as SumCode from t group by project,language order by project,SumCode desc;' | sqlite_formatter Project Language SumCode __________ _________________________ _______ mariadb C++ 983026 mariadb C 715018 mariadb C/C++ Header 209394 mariadb Bourne Shell 61943 mariadb Perl 35562 mariadb Pascal 32541 mariadb HTML 16489 mariadb Javascript 15540 mariadb m4 14215 mariadb CMake 12206 mariadb XML 5210 mariadb Ruby 4998 mariadb Puppet 3848 mariadb make 3631 mariadb SQL 3405 mariadb Python 2545 mariadb Bourne Again Shell 1604 mariadb Windows Module Definition 1211 mariadb lex 991 mariadb yacc 810 mariadb DOS Batch 700 mariadb Prolog 448 mariadb RobotFramework 441 mariadb CSS 393 mariadb JSON 359 mariadb dtrace 306 mariadb Windows Resource File 250 mariadb Assembly 237 mariadb WiX source 155 mariadb Visual Basic 88 mariadb YAML 65 mariadb PHP 24 mariadb SKILL 16 mariadb sed 16 mariadb Windows Message File 6 mariadb D 4 mariadb diff 4 perl Perl 536445 perl C 155648 perl C/C++ Header 147858 perl Bourne Shell 42668 perl Pascal 8592 perl XML 2410 perl YAML 2078 perl C++ 2033 perl make 1986 perl Prolog 1146 perl JSON 1037 perl yacc 998 perl Windows Message File 489 perl DOS Batch 389 perl Windows Resource File 85 perl D 8 perl Lisp 4 postgresql HTML 785991 postgresql C 736519 postgresql C/C++ Header 57014 postgresql SQL 51926 postgresql yacc 28491 postgresql Bourne Shell 17170 postgresql Perl 9456 postgresql lex 4285 postgresql make 4114 postgresql m4 1642 postgresql Windows Module Definition 1152 postgresql XSLT 294 postgresql DOS Batch 92 postgresql Assembly 69 postgresql CSS 69 postgresql D 66 postgresql Windows Resource File 62 postgresql Lisp 16 postgresql sed 15 postgresql Python 13 postgresql Bourne Again Shell 10 postgresql Windows Message File 5 python Python 434015 python C 375555 python C/C++ Header 66942 python Bourne Shell 45091 python MSBuild script 38910 python m4 15559 python Assembly 12298 python make 2953 python HTML 2344 python Windows Module Definition 2081 python Objective-C 635 python Expect 565 python DOS Batch 506 python CSS 328 python Javascript 229 python Windows Resource File 207 python C++ 128 python vim script 106 python diff 105 python XML 74 python NAnt script 30 python Prolog 24 python Visual Basic 12 sqlite C 101454 sqlite C/C++ Header 1546
Custom Column Output ▲
Cloc's default output is a text table with five columns: language, file count, number of blank lines, number of comment lines and number of code lines. The switches --by-file , --3 , and --by-percent generate additional information but sometimes even those are insufficient.
The --sql option described in the previous section offers the ability to create custom output. This section has a pair of examples that show how to create custom columns. The first example includes an extra column, Total , which is the sum of the numbers of blank, comment, and code lines. The second shows how to include the language name when running with --by-file .
Example 1: Add a "Totals" column.
The first step is to run cloc and save the output to a relational database, SQLite in this case:
cloc --sql 1 --sql-project x yaml-cpp-yaml-cpp-0.5.3.tar.gz | sqlite3 counts.db
(the tar file comes from the YAML-C++ project).
Second, we craft an SQL query that returns the regular cloc output plus an extra column for totals, then save the SQL statement to a file, query_with_totals.sql :
-- file query_with_totals.sql select Language, count(File) as files , sum(nBlank) as blank , sum(nComment) as comment , sum(nCode) as code , sum(nBlank)+sum(nComment)+sum(nCode) as Total from t group by Language order by code desc;
Third, we run this query through SQLite using the counts.db database. We'll include the -header switch so that SQLite prints the column names:
> cat query_with_totals.sql | sqlite3 -header counts.db Language|files|blank|comment|code|Total C++|141|12786|17359|60378|90523 C/C++ Header|110|8566|17420|51502|77488 Bourne Shell|10|6351|6779|38264|51394 m4|11|2037|260|17980|20277 Python|30|1613|2486|4602|8701 MSBuild script|11|0|0|1711|1711 CMake|7|155|285|606|1046 make|5|127|173|464|764 Markdown|2|30|0|39|69
The extra column for Total is there but the format is unappealing. Running the output through sqlite_formatter yields the desired result:
> cat query_with_totals.sql | sqlite3 -header counts.db | sqlite_formatter Language files blank comment code Total ______________ _____ _____ _______ _____ _____ C++ 141 12786 17359 60378 90523 C/C++ Header 110 8566 17420 51502 77488 Bourne Shell 10 6351 6779 38264 51394 m4 11 2037 260 17980 20277 Python 30 1613 2486 4602 8701 MSBuild script 11 0 0 1711 1711 CMake 7 155 285 606 1046 make 5 127 173 464 764 Markdown 2 30 0 39 69
The next section, Wrapping cloc in other scripts, shows one way these commands can be combined into a new utility program.
Example 2: Include a column for "Language" when running with --by-file .
Output from --by-file omits each file's language to save screen real estate; file paths for large projects can be long and including an extra 20 or so characters for a Language column can be excessive.
As an example, here are the first few lines of output using the same code base as in Example 1:
> cloc --by-file yaml-cpp-yaml-cpp-0.5.3.tar.gz github.com/AlDanial/cloc v 1.81 T=1.14 s (287.9 files/s, 221854.9 lines/s) -------------------------------------------------- -------------------------------------------------- --------------------------------------------- File blank comment code -------------------------------------------------- -------------------------------------------------- --------------------------------------------- yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/configure 2580 2264 13691 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/configure 2541 2235 13446 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/fused-src/gtest/gtest.h 1972 4681 13408 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/fused-src/gmock/gmock.h 1585 3397 9216 yaml-cpp-yaml-cpp-0.5.3/test/integration/gen_emitter_test.cpp 999 0 8760 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/aclocal.m4 987 100 8712 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/m4/libtool.m4 760 65 7176 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/build-aux/ltmain.sh 959 1533 7169 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/fused-src/gmock-gtest-all.cc 1514 3539 6390 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/fused-src/gtest/gtest-all.cc 1312 2896 5384 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/test/gtest_unittest.cc 1226 1091 5098 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/include/gtest/internal/gtest-param-util-generated.h 349 235 4559
The absence of language identification for each file is a bit disappointing, but this can be remedied with a custom column solution.
The first step, creating a database, matches that from Example 1 so we'll go straight to the second step of creating the desired SQL query. We'll store this one in the file by_file_with_language.sql :
-- file by_file_with_language.sql select File, Language, nBlank as blank , nComment as comment, nCode as code from t order by code desc;
Our desired extra column appears when we pass this custom SQL query through our database:
> cat by_file_with_language.sql | sqlite3 -header counts.db | sqlite_formatter File Language blank comment code __________________________________________________________________________________________________ ______________ _____ _______ _____ yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/configure Bourne Shell 2580 2264 13691 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/configure Bourne Shell 2541 2235 13446 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/fused-src/gtest/gtest.h C/C++ Header 1972 4681 13408 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/fused-src/gmock/gmock.h C/C++ Header 1585 3397 9216 yaml-cpp-yaml-cpp-0.5.3/test/integration/gen_emitter_test.cpp C++ 999 0 8760 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/aclocal.m4 m4 987 100 8712 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/m4/libtool.m4 m4 760 65 7176 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/build-aux/ltmain.sh Bourne Shell 959 1533 7169 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/fused-src/gmock-gtest-all.cc C++ 1514 3539 6390 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/fused-src/gtest/gtest-all.cc C++ 1312 2896 5384 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/test/gtest_unittest.cc C++ 1226 1091 5098 yaml-cpp-yaml-cpp-0.5.3/test/gmock-1.7.0/gtest/include/gtest/internal/gtest-param-util-generated.h C/C++ Header 349 235 4559
*
Wrapping cloc in other scripts ▲
More complex code counting solutions are possible by wrapping cloc in scripts or programs. The "total lines" column from example 1 of Custom Column Output could be simplified to a single command with this shell script (on Linux):
#!/bin/sh # # These commands must be in the user's $PATH: # cloc # sqlite3 # sqlite_formatter # if test $# -eq 0 ; alors echo "Usage: $0 [cloc arguments]" echo " Run cloc to count lines of code with an additional" echo " output column for total lines (code+comment+blank)." sortie fi DBFILE=`tempfile` cloc --sql 1 --sql-project x $@ | sqlite3 ${DBFILE} SQL="select Language, count(File) as files , sum(nBlank) as blank , sum(nComment) as comment , sum(nCode) as code , sum(nBlank)+sum(nComment)+sum(nCode) as Total from t group by Language order by code desc; " echo ${SQL} | sqlite3 -header ${DBFILE} | sqlite_formatter rm ${DBFILE}
Saving the lines above to total_columns.sh and making it executable ( chmod +x total_columns.sh ) would let us do
./total_columns.sh yaml-cpp-yaml-cpp-0.5.3.tar.gz
to directly get
Language files blank comment code Total ______________ _____ _____ _______ _____ _____ C++ 141 12786 17359 60378 90523 C/C++ Header 110 8566 17420 51502 77488 Bourne Shell 10 6351 6779 38264 51394 m4 11 2037 260 17980 20277 Python 30 1613 2486 4602 8701 MSBuild script 11 0 0 1711 1711 CMake 7 155 285 606 1046 make 5 127 173 464 764 Markdown 2 30 0 39 69
Autres exemples :
Count code from a specific branch of a web-hosted git repository and send the results as a .csv email attachment: https://github.com/dannyloweatx/checkmarx
git and UTF8 pathnames ▲
cloc's --git option may fail if you work with directory or file names with UTF-8 characters (for example, see issue 457). The solution, https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window, is to apply this git configuration command :
git config --global core.quotepath off
Your console's font will need to be capable of displaying Unicode characters.
Third Generation Language Scale Factors ▲
cloc versions before 1.50 by default computed, for the provided inputs, a rough estimate of how many lines of code would be needed to write the same code in a hypothetical third-generation computer language. To produce this output one must now use the --3 switch.
Scale factors were derived from the 2006 version of language gearing ratios listed at Mayes Consulting web site, http://softwareestimator.com/IndustryData2.htm, using this equation:
cloc scale factor for language X = 3rd generation default gearing ratio / language X gearing ratio
For example, cloc 3rd generation scale factor for DOS Batch = 80 / 128 = 0.625.
The biggest flaw with this approach is that gearing ratios are defined for logical lines of source code not physical lines (which cloc counts). The values in cloc's 'scale' and '3rd gen. equiv.' columns should be taken with a large grain of salt.
options.txt configuration file ▲
If you find yourself using the same command line switches every time you invoke cloc, you can save some typing by adding those switches to the options.txt runtime configuration file. cloc will look for this file in the following default locations:
# Linux, NetBSD, FreeBSD, macOS: /home/USERNAME/.config/cloc/options.txt # Windows C:UsersUSERNAMEAppDataRoamingcloc
If you run cloc with --help , cloc will tell you where it expects to find this config file file. The information appears by the explanation of the --config switch after the text the default location of . On Unix-like operating systems, this can be simplified to
> cloc --help | grep "default location" the default location of /home/al/.config/cloc/options.txt.
and in a Windows cmd terminal with
> cloc --help | findstr default | findstr location the default location of C:UsersalAppDataRoamingcloc
Place each switch and arguments, if any, on a line by itself. Lines prefixed with # symbol are ignored as comments and blank lines are skipped. Leading hyphens on the switches are optional. Here's a sample file:
# options.txt --vcs git v # verbose level 1 exclude-ext svg,html
The path to the options.txt file can also be specified with the --config FILE switch.
Finally, if cloc finds an options.txt file in the same directory as files given by any of these switches (in the listed priority), it will use that configuration file from that location:
--list-file
--exclude-list-file
--read-lang-def
--force-lang-def
--diff-list-file
Run with --verbose to have cloc tell you which, if any, options.txt file it uses.
Java Programmatic Interface ▲
Ozren Dabić created a Java programmatic interface to cloc. It is available at https://github.com/seart-group/jcloc
Complex regular subexpression recursion limit ▲
cloc relies on the Regexp::Common module's regular expressions to remove comments from source code. If comments are malformed, for example the /* start comment marker appears in a C program without a corresponding */ marker, the regular expression engine could enter a recursive loop, eventually triggering the warning Complex regular subexpression recursion limit .
The most common cause for this warning is the existence of comment markers in string literals. While language compilers and interpreters are smart enough to recognize that "/*" (for example) is a string and not a comment, cloc is fooled. File path globs, as in this line of JavaScript
var paths = globArray("**/*.js", {cwd: srcPath});
are frequent culprits.
In an attempt to overcome this problem, a different algorithm which removes comment markers in strings can be enabled with the --strip-str-comments switch. Doing so, however, has drawbacks: cloc will run more slowly and the output of --strip-comments will contain strings that no longer match the input source.
Limitations ▲
Identifying comments within source code is trickier than one might expect. Many languages would need a complete parser to be counted correctly. cloc does not attempt to parse any of the languages it aims to count and therefore is an imperfect tool. The following are known problems:
Lines containing both source code and comments are counted as lines of code.
Comment markers within strings or here-documents are treated as actual comment markers and not string literals. For example the following lines of C code
printf(" /* "); for (i = 0; i < 100; i++) { a += i; } printf(" */ ");
look to cloc like this:
printf(" xxxxxxx xxxxxxx xxxxxxx xxxxxxx xxxxxxx ");
where xxxxxxx represents cloc's view of commented text. Therefore cloc counts the five lines as two lines of C code and three lines of comments (lines with both code and comment are counted as code).
If you suspect your code has such strings, use the switch --strip-str-comments to switch to the algorithm which removes embedded comment markers. Its use will render the five lines above as
printf(" "); for (i = 0; i < 100; i++) { a += i; } printf(" ");
and therefore return a count of five lines of code. See the previous section on drawbacks to using --strip-str-comments .
Embedded languages are not recognized. For example, an HTML file containing JavaScript will be counted entirely as HTML.
Python docstrings can serve several purposes. They may contain documentation, comment out blocks of code, or they can be regular strings (when they appear on the right hand side of an assignment or as a function argument). cloc is unable to infer the meaning of docstrings by context; by default cloc treats all docstrings as comments. The switch --docstring-as-code treats all docstrings as code.
Language definition files read with --read-lang-def or --force-lang-def must be plain ASCII text files.
cloc treats compiler pragma's, for example #if / #endif , as code even if these are used to block lines of source from being compiled; the blocked lines still contribute to the code count.
On Windows, cloc will fail with Can't cd to ... No such file or directory at /File/Find.pm if the code being scanned has file paths longer than 255 characters. A work-around is to run cloc from the Windows Subsystem for Linux (WSL).
cloc's comment match code uses regular expressions which cannot properly account for nested comments using the same comment markers (such as /* /* */ */ ).
XML comments embedded within CDATA blocks are counted as comments rather than code.
Requesting Support for Additional Languages ▲
If cloc does not recognize a language you are interested in counting, create a GitHub issue requesting support for your language. Include this information:
File extensions associated with the language. If the language does not rely on file extensions and instead works with fixed file names or with `#!` style program invocations, explain what those are.
A description of how comments are defined.
Links to sample code.
Reporting Problems ▲
If you encounter a problem with cloc, first check to see if you're running with the latest version of the tool:
cloc --version
If the version is older than the most recent release at https://github.com/AlDanial/cloc/releases, download the latest version and see if it solves your problem.
If the problem happens with the latest release, submit a new issue at https://github.com/AlDanial/cloc/issues only if you can supply enough information for anyone reading the issue report to reproduce the problem. That means providing
the operating system you're running on
the cloc command with all options
the code you are counting (URL to a public git repo or zip file or tar file, et cetera)
The last item is generally problematic. If the code base is proprietary or amounts to more than a few dozen kilobytes, you'll need to try to reconstruct similar inputs or demonstrate the problem with an existing public code base.
Problem reports that cannot be reproduced will be ignored and eventually closed.
Citation ▲
Please use the following bibtex entry to cite cloc in a publication:
@software{adanial_cloc, author = {Albert Danial}, title = {cloc: v1.92}, month = dec, year = 2021, publisher = {Zenodo}, version = {v1.92}, doi = {10.5281/zenodo.5760077}, url = {https://doi.org/10.5281/zenodo.5760077} }
(Update the version number and corresponding year if this entry is outdated.)
Acknowledgments ▲
Wolfram Rösler provided most of the code examples in the test suite. These examples come from his Hello World collection.
Ismet Kursunoglu found errors with the MUMPS counter and provided access to a computer with a large body of MUMPS code to test cloc.
Tod Huggins gave helpful suggestions for the Visual Basic filters.
Anton Demichev found a flaw with the JSP counter in cloc v0.76 and wrote the XML output generator for the --xml option.
Reuben Thomas pointed out that ISO C99 allows // as a comment marker, provided code for the --no3 and --stdin-name options, counting the m4 language, and suggested several user-interface enhancements.
Michael Bello provided code for the --opt-match-f , --opt-not-match-f , --opt-match-d , and --opt-not-match-d options.
Mahboob Hussain inspired the --original-dir and --skip-uniqueness options, found a bug in the duplicate file detection logic and improved the JSP filter.
Randy Sharo found and fixed an uninitialized variable bug for shell scripts having only one line.
Steven Baker found and fixed a problem with the YAML output generator.
Greg Toth provided code to improve blank line detection in COBOL.
Joel Oliveira provided code to let --exclude-list-file handle directory name exclusion.
Blazej Kroll provided code to produce an XSLT file, cloc-diff.xsl , when producing XML output for the --diff option.
Denis Silakov enhanced the code which generates cloc.xsl when using --by-file and --by-file-by-lang options, and provided an XSL file that works with --diff output.
Andy ([email protected]) provided code to fix several bugs: correct output of --counted so that only files that are used in the code count appear and that results are shown by language rather than file name; allow --diff output from multiple runs to be summed together with --sum-reports .
Jari Aalto created the initial version of cloc.1.pod and maintains the Debian package for cloc.
Mikkel Christiansen ([email protected]) provided counter definitions for Clojure and ClojureScript.
Vera Djuraskovic from Webhostinggeeks.com provided the Serbo-Croatian translation.
Gill Ajoft of Ajoft Software provided the Bulgarian translation.
The Knowledge Team provided the Slovakian translation.
Erik Gooven Arellano Casillas provided an update to the MXML counter to recognize ActionScript comments.
Gianluca Casati created the cloc CPAN package.
Ryan Lindeman implemented the --by-percent feature.
Kent C. Dodds, @kentcdodds, created and maintains the npm package of cloc.
Viktoria Parnak provided the Ukrainian translation.
Natalie Harmann provided the Belarussian translation.
Nithyal at Healthcare Administration Portal provided the Tamil translation.
Patricia Motosan provided the Romanian translation.
Gajk Melikyan provided the provided the Armenian translation for http://studybay.com.
Hungarian translation courtesy of Zsolt Boros.
Sietse Snel implemented the parallel processing capability available with the --processes= N switch.
The development of cloc was partially funded by the Northrop Grumman Corporation.
Copyright ▲
Copyright (c) 2006-2024, Al Danial