cloc
v2.02
Compter les lignes de code
cloc compte les lignes vides, les lignes de commentaires et les lignes physiques de 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.
É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
Réduction 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 ..
cloc compte les lignes vides, les lignes de commentaires et les lignes physiques de 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.
docker run --rm -v $PWD :/tmp aldanial/clocdocker run --rm -v " / $( pwd -W ) " :/tmp aldanial/clocEn 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.
https://github.com/AlDanial/cloc/releases/latest
https://github.com/AlDanial/cloc/raw/master/cloc
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.
cloc possède de nombreuses fonctionnalités qui la rendent facile à utiliser, complète, extensible et portable :
Si Cloc ne répond pas à vos besoins, voici d'autres compteurs disponibles gratuitement à considérer :
Autres références :
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.
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 .
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/
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.
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.
invite> cloc --help
Utilisation : cloc [options] <fichier(s)/dir(s)/git hash(es)> | <ensemble 1> <ensemble 2> | <fichiers de rapport>
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=<cmd> 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 <cmd> 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=<fichier> Amener la liste des noms de fichiers et/ou de répertoires à
processus à partir de <file>, 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 <fichier>
to - pour lire les noms de fichiers à partir d'un tube STDIN.
Voir aussi --exclude-list-file.
--diff-list-file=<fichier> Prendre les paires de noms de fichiers à partir desquels la comparaison est effectuée
<fichier>, 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=<VCS> Invoque un appel système à <VCS> pour obtenir une liste de
fichiers sur lesquels travailler. Si <VCS> 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 <VCS> 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, <VCS> 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 <VCS>. 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 <VCS> 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 <file> Lire les commutateurs de ligne de commande depuis <file> 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 a la priorité sur les entrées lues depuis
le fichier.
--count-and-diff <ensemble1> <ensemble2>
Effectuez d’abord un décompte direct du code du ou des fichiers source.
de <set1> et <set2> 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 <set1> <set2> Calcule les différences de code et de commentaires entre
fichier(s) source de <set1> et <set2>. 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 <N> Ignorer les fichiers qui prennent plus de <N> secondes
à traiter. La valeur par défaut est de 10 secondes. Paramètre <N>
à 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=<lang>[,<ext>]
Traite tous les fichiers qui ont une extension <ext>
avec le compteur de langue <lang>. 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 <ext> est omis, chaque fichier sera compté
avec le compteur <lang>. Cette option peut être
spécifié plusieurs fois (mais ce n'est que
utile lorsque <ext> est donné à chaque fois).
Voir aussi --script-lang, --lang-no-ext.
--force-lang-def=<fichier> Charger les filtres de traitement du langage depuis <fichier>,
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=<lang> Compter les fichiers sans extensions en utilisant le <lang>
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=<Mo> Ignorer les fichiers de plus de <Mo> mégaoctets lorsque
parcourir des répertoires. Par défaut, <Mo>=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=<file> Charger de nouveaux filtres de traitement de langage à partir de <file>
et fusionnez-les avec ceux déjà connus pour cloc.
Si <file> 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=<lang>,<s> Traitez tous les fichiers qui appellent <s> comme un # !
langage de script avec le compteur de langue
<langage>. 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, <s>,
doit avoir le bon cas. Cette option peut être
spécifié plusieurs fois. Voir aussi --force-lang,
--lang-no-ext.
--sdir=<dir> Utiliser <dir> 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' correspondant
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::Recherche dans les répertoires stat pour obtenir le
décompte correct. La vitesse de recherche des fichiers diminuera.
Voir aussi --follow-links.
--stdin-name=<file> 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=<ext> 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 .<ext>.
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 <N> Ignorer les fichiers qui prennent plus de <N> 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 <N> 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=<regex> Ne compte que les fichiers contenant du texte qui correspond au
étant donné une expression régulière.
--exclude-content=<regex> Exclure les fichiers contenant du texte qui correspond au
expression régulière.
--exclude-dir=<D1>[,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 inclure des séparateurs de chemin de fichier n'est pas
autorisé. Utilisez --fullpath et --not-match-d=<regex>
pour fournir une expression régulière correspondant à plusieurs sous-répertoires.
--exclude-ext=<ext1>[,<ext2>[...]]
Ne comptez pas les fichiers portant le nom de fichier donné
extensions.
--exclude-lang=<L1>[,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=<fichier> Ignorer les fichiers et/ou répertoires dont les noms
apparaître dans <fichier>. <file> 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=<ext1>[,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=<L1>[,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=<regex> 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=<regex> 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=<regex> 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=<regex> 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=<regex> 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é = <fichier> Enregistrer les tailles de fichiers en octets, langues identifiées
et les noms des fichiers catégorisés en <Fichier>.
--Courted = <Fichier> Enregistrer les noms des fichiers source traités à <Fichier>.
--diff-alignement = <Fichier> Écrivez à <Fichier> 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 = <gnang> Imprimez les filtres utilisés pour supprimer les commentaires pour
Langue <angle> 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 = <Fichier> Enregistrer les noms de chaque fichier trouvé dans <Fichier>.
--Insed = <Fichier> Enregistrer les noms des fichiers ignorés et la raison pour laquelle ils
ont été ignorés en <fichier>.
- Print-Filter-Stages Imprimer le code source traité avant et après
Chaque filtre est appliqué.
--show-axt [= <st>] Imprimez des informations sur tous les connus (ou juste le
donné) Extensions de fichiers et sortie.
--show-Lang [= <ngorde>] 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 [= <n>] Switch Verbose (valeur numérique facultative).
-Verbose [= <n>] Forme longue de -v.
- Version Imprimez la version de ce programme et sortant.
--WRITE-LANG-DEF = <Fichier> Écrit dans <Fichier> 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 = <Fichier>
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 = <c> Utilisez le caractère <c> comme délimiteur pour la virgule
Fichiers séparés au lieu de ,. Ce commutateur force - CSV à être allumé.
--file-coding = <e> écriture de fichiers de sortie en utilisant le codage <e> au lieu de
L'ASCII par défaut (<e> = '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 Ne montrez 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 = <Fichier> Synonyme pour --Report-File = <Fichier>.
--Progress-rate = <n> Afficher la mise à jour de progression après que chaque <n> fichiers soit
traité (par défaut <n> = 100). Définir <n> 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 = <Fichier> Écrivez les résultats à <Fichier> au lieu de stdout.
--sql = <fichier> É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 <Fichier> 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 = <name> use <name> comme identifiant de projet pour le
Exécution actuelle. Seulement valide avec l'option --SQL.
--SQL-Style = <ystyle> É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 = <fichier> Référence <Fichier> En tant que feuille de style XSL dans
la sortie XML. Si <Fichier> 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.
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
