un reloj

reloj

Contar líneas de código

---

cloc cuenta líneas en blanco, líneas de comentarios y líneas físicas de código fuente en muchos lenguajes de programación.

Última versión: v2.02 (2 de agosto de 2024)

cloc se mudó a GitHub en septiembre de 2015 después de estar alojado en http://cloc.sourceforge.net/ desde agosto de 2006.

• Inicio rápido
• Descripción general
• Descargar
  • Instalar a través del administrador de paquetes
  • Liberación estable
  • Versión de desarrollo
• Licencia
• ¿Por qué utilizar cloc?
• Otros contadores
• Construyendo un ejecutable de Windows
• Uso básico
• Opciones
• Idiomas reconocidos
• Cómo funciona
• Uso avanzado
  • Eliminar comentarios del código fuente
  • Trabajar con archivos comprimidos
  • Diferencias
  • Crear definiciones de idioma personalizadas
  • Combinar informes
  • SQL
  • Salida de columna personalizada
  • Envolver cloc en otros scripts
  • nombres de ruta de git y UTF8
  • Factores de escala de lenguaje de tercera generación
  • archivo de configuración options.txt
  • Interfaz programática Java
• Límite de recursividad de subexpresiones regulares complejas
• Limitaciones
• Solicitar soporte para idiomas adicionales
• Problemas de informes
• Citación
• Expresiones de gratitud
• Derechos de autor

Inicio rápido ▲

Paso 1: descargue cloc (varios métodos, consulte a continuación) o ejecute la imagen acoplable de cloc. El ejecutable de Windows no tiene requisitos. La versión fuente de cloc requiere un intérprete de Perl y la versión Docker de cloc requiere una instalación de Docker.

Paso 2: abra una terminal ( cmd.exe en Windows).

Paso 3: Invoca cloc para contar tus archivos fuente, directorios, archivos o confirmaciones de git. El nombre del ejecutable difiere dependiendo de si utiliza la versión fuente de desarrollo ( cloc ), la fuente de una versión publicada ( cloc-2.02.pl ) o un ejecutable de Windows ( cloc-2.02.exe ).

En esta página, cloc es el término genérico utilizado para referirse a cualquiera de estos.

Include Security tiene un vídeo de YouTube que muestra los pasos en acción.

un archivo

 símbolo> cloc hola.c
       1 archivo de texto.
       1 archivo único.
       0 archivos ignorados.

https://github.com/AlDanial/cloc v 1,65 T=0,04 s (28,3 archivos/s, 340,0 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
C 1 0 7 5
-------------------------------------------------- -----------------------

un directorio

 símbolo> cloc gcc-5.2.0/gcc/c
      16 archivos de texto.
      15 archivos únicos.
       3 archivos ignorados.

https://github.com/AlDanial/cloc v 1,65 T=0,23 s (57,1 archivos/s, 188914,0 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
C 10 4680 6621 30812
Encabezado C/C++ 3 99 286 496
-------------------------------------------------- -----------------------
SUMA: 13 4779 6907 31308
-------------------------------------------------- -----------------------

un archivo

Extraeremos el archivo zip fuente de cloc de GitHub y luego contaremos el contenido:

 símbolo> wget https://github.com/AlDanial/cloc/archive/master.zip

símbolo> cloc master.zip
https://github.com/AlDanial/cloc v 1,65 T=0,07 s (26,8 archivos/s, 141370,3 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Perla 2 725 1103 8713
-------------------------------------------------- -----------------------
SUMA: 2 725 1103 8713
-------------------------------------------------- -----------------------

un repositorio de git, usando una confirmación específica

Este ejemplo utiliza código de PuDB, un fantástico depurador de Python.

 símbolo> git clone https://github.com/inducer/pudb.git

símbolo> cd pudb

mensaje> reloj 6be804e07a5db
      48 archivos de texto.
      41 archivos únicos.                              
       8 archivos ignorados.

github.com/AlDanial/cloc v 1,99 T=0,04 s (1054,9 archivos/s, 189646,8 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Pitón 28 1519 728 4659
Texto reestructurado 6 102 20 203
YAML 2 9 2 75
Bourne Shell 3 6 0 17
Texto 1 0 0 11
hacer 1 4 6 10
-------------------------------------------------- -----------------------
SUMA: 41 1640 756 4975
-------------------------------------------------- -----------------------

cada subdirectorio de un directorio en particular

Supongamos que tiene un directorio con tres proyectos diferentes administrados por git, Proyecto0, Proyecto1 y Proyecto2. Puede utilizar la capacidad de bucle de su shell para contar el código en cada uno. Este ejemplo usa bash (desplácese hacia abajo para ver el ejemplo de cmd.exe):

 símbolo> para d en ./*/; hacer (cd "$d" && echo "$d" && cloc --vcs git); hecho
./Proyecto0/
7 archivos de texto.
       7 archivos únicos.
       1 archivo ignorado.

github.com/AlDanial/cloc v 1.71 T=0.02 s (390.2 archivos/s, 25687.6 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
D 4 61 32 251
Rebaja 1 9 0 38
hacer 1 0 0 4
-------------------------------------------------- -----------------------
SUMA: 6 70 32 293
-------------------------------------------------- -----------------------
./Proyecto1/
       7 archivos de texto.
       7 archivos únicos.
       0 archivos ignorados.

github.com/AlDanial/cloc v 1.71 T=0.02 s (293.0 archivos/s, 52107.1 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Ir 7 165 282 798
-------------------------------------------------- -----------------------
SUMA: 7 165 282 798
-------------------------------------------------- -----------------------
./Proyecto2/
      49 archivos de texto.
      47 archivos únicos.
      13 archivos ignorados.

github.com/AlDanial/cloc v 1.71 T=0.10 s (399.5 archivos/s, 70409.4 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Pitón 33 1226 1026 3017
C 4 327 337 888
Rebaja 1 11 0 28
YAML 1 0 2 12
-------------------------------------------------- -----------------------
SUMA: 39 1564 1365 3945
-------------------------------------------------- -----------------------

cada subdirectorio de un directorio particular (Windows/cmd.exe)

 para /D %I en (.*) hacer cd %I && cloc --vcs git && cd ..

Descripción general ▲

cloc cuenta líneas en blanco, líneas de comentarios y líneas físicas de código fuente en muchos lenguajes de programación. Dadas dos versiones de un código base, cloc puede calcular diferencias en líneas en blanco, comentarios y fuente. Está escrito completamente en Perl sin dependencias fuera de la distribución estándar de Perl v5.6 y superiores (el código de algunos módulos externos está integrado en cloc) y, por lo tanto, es bastante portátil. Se sabe que cloc se ejecuta en muchas versiones de Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX, z/OS y ​​Windows. (Para ejecutar la versión fuente de Perl de cloc en Windows se necesita ActiveState Perl 5.6.1 o superior, Strawberry Perl, Subsistema de Windows para Linux, Cygwin, MobaXTerm con el complemento Perl instalado o un entorno y terminal mingw como los proporcionados por Git para Windows Alternativamente, se puede usar el binario de Windows de cloc generado con PAR::Packer para ejecutarlo en computadoras con Windows que no tienen Perl ni Cygwin).

Además de contar código en archivos de texto individuales, directorios y repositorios de git, cloc también puede contar código en archivos como .tar (incluidas las versiones comprimidas), .zip , Python wheel .whl , Jupyter notebook .ipynb y RPM de origen .rpm o .src (requiere rpm2cpio ) y archivos Debian .deb (requiere dpkg-deb ).

cloc contiene código de SLOCCount de David Wheeler, Regexp::Common del módulo Perl de Damian Conway y Abigail, Win32::Autoglob del módulo Perl de Sean M. Burke y Algorithm::Diff del módulo Perl de Tye McQueen. Los factores de escala de idioma se derivaron del sitio web de Mayes Consulting, LLC http://softwareestimator.com/IndustryData2.htm.

Los nuevos lanzamientos aparecen nominalmente cada seis meses.

Ejecutar a través de la ventana acoplable

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

Ejecutar a través de Docker en git-bash

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

Instalar a través del administrador de paquetes

Dependiendo de su sistema operativo, uno de estos métodos de instalación puede funcionar para usted (todos excepto los dos últimos para Windows requieren un intérprete de 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

Nota : No controlo ninguno de estos paquetes. Si encuentra un error en cloc al usar uno de los paquetes anteriores, intente con cloc extraído de la última versión estable aquí en GitHub (el enlace se encuentra a continuación) antes de enviar un informe de problema.

Liberación estable

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

Versión de desarrollo

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

Licencia ▲

cloc tiene la licencia GNU General Public License, v 2, excluyendo partes que se copian de otras fuentes. El código copiado de los módulos Regexp::Common, Win32::Autoglob y Algorithm::Diff Perl está sujeto a la licencia artística.

¿Por qué utilizar cloc? ▲

cloc tiene muchas características que lo hacen fácil de usar, completo, extensible y portátil:

1. Existe como un archivo único e independiente que requiere un esfuerzo de instalación mínimo: simplemente descargue el archivo y ejecútelo.
2. Puede leer definiciones de comentarios de idiomas de un archivo y, por lo tanto, trabajar potencialmente con lenguajes de computadora que aún no existen.
3. Permite sumar los resultados de múltiples ejecuciones por idioma y por proyecto.
4. Puede producir resultados en una variedad de formatos: texto sin formato, Markdown, SQL, JSON, XML, YAML, valores separados por comas.
5. Puede contar código dentro de archivos comprimidos (tar bolas, archivos Zip, archivos Java .ear).
6. Tiene numerosas opciones de solución de problemas.
7. Maneja nombres de archivos y directorios con espacios y otros caracteres inusuales.
8. No tiene dependencias fuera de la distribución estándar de Perl.
9. Se ejecuta en sistemas Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX y z/OS que tienen Perl 5.6 o superior. La versión fuente se ejecuta en Windows con el complemento ActiveState Perl, Strawberry Perl, Cygwin o MobaXTerm+Perl. Alternativamente, en Windows se puede ejecutar el binario de Windows que no tiene dependencias.

Otros contadores ▲

Si cloc no se adapta a sus necesidades, aquí hay otros contadores disponibles gratuitamente que puede considerar:

• loc
• gcloc
• gocloc
• Oh cuenta
• cc
• sccl
• SLOCCount
• Sonar
• tokio
• Recuento de códigos unificados

Otras referencias:

• Directorio de herramientas de conteo de códigos de QSM.
• La entrada de Wikipedia para el recuento de líneas del código fuente.

Regexp::Común, Resumen::MD5, Win32::Autoglob, Algoritmo::Diff

Aunque cloc no necesita módulos Perl fuera de los que se encuentran en la distribución estándar, cloc sí depende de algunos módulos externos. El código de tres de estos módulos externos (Regexp::Common, Win32::Autoglob y Algorithm::Diff) está integrado en cloc. Un cuarto módulo, Digest::MD5, se utiliza sólo si está disponible. Si cloc encuentra Regexp::Common o Algorithm::Diff instalado localmente, utilizará esa instalación. Si no es así, cloc instalará las partes de Regexp::Common y/o Algorithm:Diff que necesita en los directorios temporales que se crean al inicio de una ejecución de cloc y luego se eliminan cuando se completa la ejecución. El código necesario de Regexp::Common v2.120 y Algorithm::Diff v1.1902 está integrado en el código fuente de cloc (consulte las subrutinas Install_Regexp_Common() e Install_Algorithm_Diff() ). Sólo se necesitan tres líneas desde Win32::Autoglob y éstas se incluyen directamente en cloc.

Además, cloc utilizará Digest::MD5 para validar la unicidad entre archivos de entrada del mismo tamaño si Digest::MD5 está instalado localmente.

Se introdujo una opción de procesamiento paralelo, --processes= N , con la versión 1.76 de cloc para permitir ejecuciones más rápidas en máquinas multinúcleo. Sin embargo, para usarlo, es necesario tener instalado el módulo Parallel::ForkManager. Este módulo no funciona de manera confiable en Windows, por lo que el procesamiento paralelo solo funcionará en sistemas operativos tipo Unix.

El binario de Windows está integrado en una computadora que tiene Regexp::Common y Digest::MD5 instalados localmente.

Construyendo un ejecutable de Windows ▲

Crea tu propio ejecutable

La opción más sólida para crear un ejecutable de cloc en Windows es utilizar el kit de desarrollo Perl de ActiveState. Incluye una utilidad, perlapp , que puede crear binarios independientes de código fuente Perl para Windows, Mac y Linux.

perl2exe también funcionará. Si tiene perl2exe , modifique las líneas 84-87 en el código fuente de cloc para realizar una modificación menor del código que es necesaria para convertir un cloc en ejecutable de Windows.

De lo contrario, para crear un ejecutable de Windows con pp de PAR::Packer , primero instale una distribución Perl basada en Windows (por ejemplo, Strawberry Perl o ActivePerl) siguiendo sus instrucciones. A continuación, abra un símbolo del sistema, también conocido como ventana de DOS e instale el módulo PAR::Packer. Finalmente, invoque el comando pp recién instalado con el código fuente cloc para crear un archivo .exe :

 C:> cpan -i Resumen::MD5
C:> cpan -i Regexp::Común
C:> cpan -i Algoritmo::Diff
C:> cpan -i PAR::Empaquetador
C:> cpan -i Win32::LongPath
C:> pp -M Win32::LongPath -M Codificación::Unicode -M Digest::MD5 -c -x -o cloc-2.02.exe cloc-2.02.pl

Una variación de las instrucciones anteriores es que si instaló la versión portátil de Strawberry Perl, primero deberá ejecutar portableshell.bat para configurar correctamente su entorno.

El ejecutable de Windows en la sección Lanzamientos, cloc-2.02.exe , se creó en una computadora con Windows 10 de 64 bits usando Strawberry Perl 5.30.2 y PAR::Packer para compilar el .exe .

¿Es seguro ejecutar el ejecutable de Windows? ¿Tiene malware?

Idealmente, nadie necesitaría el ejecutable de Windows porque tienen un intérprete de Perl instalado en sus máquinas y pueden ejecutar el archivo fuente cloc. Sin embargo, en máquinas Windows corporativas administradas centralmente, esto puede resultar difícil o imposible.

El ejecutable de Windows distribuido con cloc se proporciona como el mejor esfuerzo de un .exe libre de virus y malware. Le recomendamos que ejecute sus propios escáneres de virus contra el ejecutable y también consulte sitios como https://www.virustotal.com/. Las entradas para versiones recientes son:

cloc-2.02-winget.exe: (incluye PR 850 para permitir la ejecución desde un enlace simbólico en 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/

¿Por qué el ejecutable de Windows es tan grande?

Los ejecutables de Windows de las versiones 1.60 y anteriores de cloc, creados con perl2exe como se indicó anteriormente, pesan aproximadamente 1,6 MB, mientras que las versiones 1.62 y 1.54, creadas con PAR::Packer , pesan 11 MB. La versión 1.66, creada con una versión más reciente de PAR::Packer , ocupa aproximadamente 5,5 MB. ¿Por qué los ejecutables PAR::Packer son mucho más grandes que los creados con perl2exe? Mi teoría es que perl2exe utiliza una lógica de poda de árboles más inteligente que PAR::Packer , pero eso es pura especulación.

Uso básico ▲

cloc es un programa de línea de comandos que toma nombres de archivos, directorios y/o archivos comprimidos como entradas. A continuación se muestra un ejemplo de ejecución de cloc en la distribución fuente de Perl v5.22.0:

 símbolo> cloc perl-5.22.0.tar.gz
    5605 archivos de texto.
    5386 archivos únicos.
    2176 archivos ignorados.

https://github.com/AlDanial/cloc v 1,65 T=25,49 s (134,7 archivos/s, 51980,3 líneas/s)
-------------------------------------------------- ---------------------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- ---------------------------------
Perl2892 136396 184362 536445
C 130 24676 33684 155648
Encabezado C/C++ 148 9766 16569 147858
Bourne Shell 112 4044 6796 42668
Pascual 8 458 1603 8592
XML 33 142 0 2410
YAML 49 20 15 2078
C++ 10 313 277 2033
hacer 4 426 488 1986
Prólogo 12 438 2 1146
JSON14 1 0 1037
yacc 1 85 76 998
Archivo de mensajes de Windows 1 102 11 489
Lote DOS 14 92 41 389
Archivo de recursos de Windows 3 10 0 85
D 1 5 7 8
Ceceo 2 0 3 4
-------------------------------------------------- ---------------------------------
SUMA: 3434 176974 243934 903874
-------------------------------------------------- ---------------------------------

Para ejecutar cloc en computadoras con Windows, abra una ventana de comando (también conocida como DOS) e invoque cloc.exe desde la línea de comando allí. Alternativamente, pruebe ClocViewer, el contenedor GUI de cloc que se encuentra en https://github.com/Roemer/ClocViewer.

Consulte también https://github.com/jmensch1/codeflower para obtener una representación gráfica de los resultados de cloc.

Opciones ▲

 símbolo> cloc --ayuda

Uso: cloc [opciones]  |   | 

 Contar o calcular diferencias de líneas físicas de código fuente en el
 archivos dados (pueden ser archivos como archivos tar comprimidos o archivos zip,
 o git commit hashes o nombres de ramas) y/o recursivamente debajo del
 directorios dados.

 Opciones de entrada
   --extract-with= Esta opción solo es necesaria si cloc no puede
                             para descubrir cómo extraer el contenido de
                             los archivos de entrada por sí solo.
                             Utilice  para extraer archivos binarios (por ejemplo:
                             .tar.gz, .zip, .Z). Utilice el literal '>FILE<' como
                             un sustituto para los archivos reales que se van a
                             extraído. Por ejemplo, para contar líneas de código.
                             en los archivos de entrada
                                gcc-4.2.tar.gz perl-5.8.8.tar.gz
                             sobre el uso de Unix
                               --extract-with='gzip -dc >ARCHIVO< | alquitrán xf -'
                             o, si tienes GNU tar,
                               --extract-with='tar zxf >ARCHIVO<'
                             y en uso de Windows, por ejemplo:
                               --extract-with=""c:Program FilesWinZipWinZip32.exe" -e -o >ARCHIVO< ."
                             (si WinZip está instalado allí).
   --list-file= Lleva la lista de nombres de archivos y/o directorios a
                             proceso desde , que tiene un archivo/directorio
                             nombre por línea. Sólo se cuentan las coincidencias exactas;
                             Los nombres de ruta relativos se resolverán a partir de
                             el directorio donde se invoca cloc. Establecer 
                             a - para leer nombres de archivos desde una tubería STDIN.
                             Consulte también --exclude-list-file.
   --diff-list-file= Tome los pares de nombres de archivos a diferenciar
                             , cuyo formato coincide con la salida de
                             --alineación diferencial. (Ejecute con esa opción para
                             ver un ejemplo.) El identificador de idioma en el
                             Se ignora el final de cada línea. Esto habilita --diff
                             modo y omite la lógica de alineación de pares de archivos.
   --vcs= Invoca una llamada al sistema a  para obtener una lista de
                             archivos para trabajar. Si  es 'git', entonces
                             invoca 'git ls-files' para obtener una lista de archivos y
                             'git submodule status' para obtener una lista de submódulos
                             cuyo contenido será ignorado. Ver también --git
                             que acepta hashes de confirmación de git y nombres de ramas.
                             Si  es 'svn', invocará 'svn list -R'.
                             El principal beneficio es que cloc se saltará
                             archivos excluidos explícitamente por la herramienta de control de versiones
                             en cuestión, es decir, aquellos en .gitignore o tienen la
                             svn: ignorar la propiedad.
                             Alternativamente,  puede ser cualquier comando del sistema.
                             que genera una lista de archivos.
                             Nota: cloc debe estar en un directorio que pueda leer
                             los archivos tal como los devuelve . cloc voluntad
                             No descargar archivos de repositorios remotos.
                             'svn list -R' puede hacer referencia a un repositorio remoto
                             para obtener nombres de archivos (y por lo tanto puede requerir
                             autenticación en el repositorio remoto), pero
                             los archivos en sí deben ser locales.
                             Configurar  en 'auto' selecciona entre 'git'
                             y 'svn' (o ninguno) dependiendo de la presencia
                             de un subdirectorio .git o .svn debajo del directorio
                             donde se invoca cloc.
   --unicode Comprueba los archivos binarios para ver si contienen Unicode
                             texto ASCII ampliado. Esto hace que el rendimiento
                             bajar notablemente.

 Opciones de procesamiento
   --autoconf Contar archivos .in (procesados ​​por GNU autoconf) de
                             lenguas reconocidas. Véase también --no-autogen.
   --by-file Informa los resultados de cada archivo fuente encontrado.
   --by-file-by-lang Informar los resultados de cada archivo fuente encontrado
                             además de informar por idioma.
   --config  Leer la línea de comando cambia desde  en lugar de
                             la ubicación predeterminada de /home/al/.config/cloc/options.txt.
                             El archivo debe contener un modificador, junto con
                             argumentos (si los hay), por línea. Líneas y líneas en blanco.
                             que comienzan con '#' se omiten. Opciones dadas en
                             la línea de comando tiene prioridad sobre las entradas leídas desde
                             el archivo.
   --count-and-diff  
                             Primero realice recuentos de código directo de los archivos fuente
                             de  y  por separado, luego realice una diferenciación
                             de estos. Las entradas pueden ser pares de archivos, directorios,
                             o archivos. Si se proporciona --out o --report-file,
                             Se crearán tres archivos de salida, uno para cada
                             de los dos conteos y uno para la diferencia. Ver también
                             --diff, --diff-alignment, --diff-timeout,
                             --ignore-case, --ignore-whitespace.
   --diff   Calcula las diferencias en el código y los comentarios entre
                             archivo(s) fuente de  y . las entradas
                             puede ser cualquier combinación de archivos, directorios, archivos,
                             o git commit hashes. Utilice --diff-alignment para
                             generar una lista que muestre qué pares de archivos dónde
                             comparado. Al comparar ramas de git, solo archivos
                             Se comparan los que han cambiado en cualquiera de las confirmaciones.
                             Véase también --git, --count-and-diff, --diff-alignment,
                             --diff-list-file, --diff-timeout, --ignore-case,
                             --ignorar-espacios en blanco.
   --diff-timeout  Ignora archivos que tardan más de  segundos
                             para procesar. El valor predeterminado es 10 segundos. Configuración 
                             a 0 permite tiempo ilimitado. (Archivos grandes con muchos
                             las líneas repetidas pueden causar Algoritmo::Diff::sdiff()
                             tomar horas.) Consulte también --timeout.
   --docstring-as-code cloc considera que las cadenas de documentos son comentarios, pero esto es
                             no siempre es correcto ya que las cadenas de documentos representan regulares
                             cadenas cuando aparecen en el lado derecho de una
                             asignación o como argumentos de función. Este interruptor
                             obliga a que las cadenas de documentos se cuenten como código.
   --follow-links [solo Unix] Sigue enlaces simbólicos a directorios
                             (Siempre se siguen los enlaces simbólicos a los archivos).
                             Véase también --stat.
   --force-lang=[,]
                             Procesar todos los archivos que tengan una extensión 
                             con el contador del idioma . Para
                             Por ejemplo, para contar todos los archivos .f con el
                             Contador Fortran 90 (que espera que los archivos
                             terminar con .f90) en lugar del Fortran 77 predeterminado
                             contador, uso
                               --force-lang="Fortran 90,f"
                             Si se omite , se contarán todos los archivos
                             con el contador . Esta opción puede ser
                             especificado varias veces (pero eso es sólo
                             útil cuando se proporciona  cada vez).
                             Véase también --script-lang, --lang-no-ext.
   --force-lang-def= Cargar filtros de procesamiento de lenguaje desde ,
                             luego use estos filtros en lugar de los incorporados
                             filtros. Nota: idiomas que se asignan al mismo
                             extensión de archivo (por ejemplo:
                             MATLAB/Mathematica/Objective-C/MUMPS/Mercurio;
                             Pascal/PHP; Lisp/OpenCL; Ceceo/Julia; Perl/Prólogo)
                             serán ignorados ya que requieren
                             procesamiento que no se expresa en el lenguaje
                             archivos de definición. Utilice --read-lang-def para definir
                             Nuevos filtros de idioma sin reemplazar los incorporados.
                             filtros (ver también --write-lang-def,
                             --write-lang-def-incl-dup).
   --git Fuerza que las entradas se interpreten como objetivos de git
                             (confirmar hashes, nombres de ramas, etcétera) si estos
                             no se identifican primero como archivo o directorio
                             nombres. Esta opción anula la lógica --vcs=git
                             si esto se da; en otras palabras, --git obtiene su
                             lista de archivos para trabajar directamente desde git usando
                             el hash o el nombre de la rama en lugar de desde
                             'git ls-files'. Esta opción se puede utilizar con
                             --diff para realizar diferencias de recuento de líneas entre git
                             confirmaciones, o entre una confirmación de git y un archivo,
                             directorio o archivo. Utilice -v/--verbose para ver
                             el sistema git controla los problemas de cloc.
   --git-diff-rel Igual que --git --diff, o simplemente --diff si las entradas
                             son reconocidos como objetivos de git. Sólo archivos que
                             han cambiado en cualquiera de las confirmaciones.
   --git-diff-all Estrategia de diferenciación de Git n.° 2: comparar todos los archivos en el
                             repositorio entre las dos confirmaciones.
   --ignore-whitespace Ignora los espacios en blanco horizontales al comparar archivos
                             con --diff. Véase también --ignore-case.
   --ignore-case Ignora los cambios en mayúsculas y minúsculas dentro del contenido del archivo;
                             considere equivalentes las letras mayúsculas y minúsculas
                             al comparar archivos con --diff. Ver también
                             --ignorar-espacios en blanco.
   --ignore-case-ext Ignora mayúsculas y minúsculas en las extensiones de nombre de archivo. esto será
                             causar problemas para contar algunos idiomas
                             (específicamente, .c y .C están asociados con C y
                             C++; este cambio contaría los archivos .C como C en lugar
                             que C++ en sistemas operativos *nix). Nombre del archivo
                             La insensibilidad a mayúsculas y minúsculas siempre es cierta en Windows.
   --lang-no-ext= Cuente archivos sin extensiones usando 
                             encimera. Esta opción anula la lógica interna.
                             para archivos sin extensiones (cuando dichos archivos
                             se comparan con lenguajes de secuencias de comandos conocidos
                             examinando la primera línea para #!). Ver también
                             --force-lang, --script-lang.
   --max-file-size= Omitir archivos de más de  megabytes cuando
                             atravesando directorios. De forma predeterminada, =100.
                             El requisito de memoria de cloc es aproximadamente veinte veces mayor.
                             más grande que el archivo más grande, por lo que se ejecuta con
                             archivos de más de 100 MB en una computadora con menos
                             Más de 2 GB de memoria causarán problemas.
                             Nota: esta verificación no se aplica a los archivos.
                             pasado explícitamente como argumentos de línea de comando.
   --no-autogen[=list] Ignorar archivos generados por sistemas de producción de código
                             como GNU autoconf. Para ver una lista de estos archivos
                             (luego salga), ejecute con la lista --no-autogen
                             Véase también --autoconf.
   --original-dir [Solo efectivo en combinación con
                             --strip-comments] Escribe los archivos eliminados
                             al mismo directorio que los archivos originales.
   --read-binary-files Procesa archivos binarios además de archivos de texto.
                             Esto suele ser una mala idea y sólo debería
                             intentado con archivos de texto que tienen incrustados
                             datos binarios.
   --read-lang-def= Cargar nuevos filtros de procesamiento de lenguaje desde 
                             y fusionarlos con los que ya se sabe que cloc.
                             Si  define un idioma, cloc ya lo sabe
                             Al respecto, la definición de cloc tendrá prioridad.
                             Utilice --force-lang-def para anular los relojes
                             definiciones (ver también --write-lang-def,
                             --write-lang-def-incl-dup).
   --script-lang=, ¡Procesa todos los archivos que invocan  como #!
                             lenguaje de scripting con el contador de lenguaje
                             . Por ejemplo, archivos que comienzan con
                                #!/usr/local/bin/perl5.8.8
                             se contará con el contador de Perl utilizando
                                --script-lang=Perl,perl5.8.8
                             El nombre del idioma no distingue entre mayúsculas y minúsculas, pero el
                             nombre del ejecutable del lenguaje de script, ,
                             debe tener el caso correcto. Esta opción puede ser
                             especificado varias veces. Véase también --force-lang,
                             --lang-no-ext.
   --sdir= Utilice  como directorio temporal en lugar de
                             dejando que File::Temp elija la ubicación. Archivos
                             escritos en esta ubicación no se eliminan en
                             al final de la ejecución (como ocurre con File::Temp).
   --skip-uniqueness Omite la comprobación de unicidad del archivo. esto le dará
                             un aumento del rendimiento a expensas del conteo
                             archivos con contenido idéntico varias veces
                             (si existen dichos duplicados).
   --stat Algunos sistemas de archivos (AFS, CD-ROM, FAT, HPFS, SMB)
                             no tiene recuentos de directorio 'nlink' que coincidan
                             el número de sus subdirectorios. Como consecuencia
                             cloc puede subestimar o omitir por completo el
                             contenidos de dichos sistemas de archivos. Este interruptor fuerza
                             Archivo::Buscar directorios estadísticos para obtener el
                             recuento correcto. La velocidad de búsqueda de archivos disminuirá.
                             Ver también --follow-links.
   --stdin-name= Proporcione un nombre de archivo para determinar el idioma
                             para entrada estándar. (Utilice - como nombre de entrada para
                             recibir el código fuente a través de STDIN.)
   --strip-comments= Para cada archivo procesado, escriba en el actual
                             directorio una versión del archivo que tiene en blanco
                             y líneas comentadas eliminadas (comentarios en línea
                             persistir). El nombre de cada archivo eliminado es el
                             nombre de archivo original con . añadido.
                             Se escribe en el directorio actual a menos que
                             --original-dir está activado.
   --strip-str-comments Reemplazar marcadores de comentarios incrustados en cadenas con
                             'xx'. Esto intenta solucionar una limitación.
                             en Regexp::Common::Comentario donde los marcadores de comentarios
                             incrustados en cadenas se ven como comentarios reales
                             marcadores y no cadenas, lo que a menudo resulta en una
                             'Límite de recursividad de subexpresiones regulares complejas'
                             Advertencias y recuentos incorrectos. hay dos
                             desventajas de usar este interruptor: 1/recuento de códigos
                             caídas de rendimiento y 2/código generado con
                             --strip-comments contendrá cadenas diferentes
                             donde se encuentran los comentarios incrustados.
   --sum-reports Los argumentos de entrada son archivos de informes anteriores
                             creado con la opción --report-file en formato simple
                             formato (por ejemplo, no JSON, YAML, XML o SQL).
                             Crea un conjunto acumulativo de resultados que contienen
                             suma de datos de los archivos de informes individuales.
   --timeout  Ignora archivos que tardan más de  segundos
                             para procesar en cualquiera de las etapas de filtrado del idioma.
                             El número máximo predeterminado de segundos dedicados a una
                             la etapa de filtro es el número de líneas en el archivo
                             dividido por mil. Establecer  en 0 permite
                             tiempo ilimitado. Consulte también --diff-timeout.
   --processes=NUM [Disponible solo en sistemas con una versión reciente
                             del módulo Parallel::ForkManager. No
                             disponible en Windows.] Establece el número máximo de
                             núcleos que utiliza cloc. El valor predeterminado de 0
                             desactiva el multiprocesamiento.
   --unix Anula la detección automática del sistema operativo
                             lógica y ejecutarse en modo UNIX. Ver también
                             --ventanas, --show-os.
   --use-sloccount Si SLOCCount está instalado, use su compilado
                             ejecutables c_count, java_count, pascal_count,
                             php_count y xml_count en lugar de cloc
                             contadores. Los contadores compilados de SLOCCount son
                             sustancialmente más rápido que el de cloc y puede dar
                             una mejora del rendimiento al contar proyectos
                             con archivos grandes. Sin embargo, estos relojes específicos
                             las funciones no estarán disponibles: --diff,
                             --count-and-diff, --strip-comments, --unicode.
   --windows Anula la detección automática del sistema operativo
                             lógica y ejecutar en modo Microsoft Windows.
                             Véase también --unix, --show-os.

 Opciones de filtro
   --include-content= Solo cuenta los archivos que contienen texto que coincide con el
                             expresión regular dada.
   --exclude-content= Excluir archivos que contengan texto que coincida con el especificado
                             expresión regular.
   --exclude-dir=[,D2,] Excluir los directorios separados por comas proporcionados
                             D1, D2, D3, etcétera, de ser escaneados. Para
                             ejemplo --exclude-dir=.cache, la prueba se omitirá
                             todos los archivos y subdirectorios que tienen /.cache/
                             o /test/ como su directorio principal.
                             Directorios denominados .bzr, .cvs, .hg, .git, .svn,
                             y .snapshot siempre están excluidos.
                             Esta opción solo funciona con directorio individual.
                             nombres, por lo que incluir separadores de ruta de archivo no es
                             permitido. Utilice --fullpath y --not-match-d=
                             para proporcionar una expresión regular que coincida con varios subdirectorios.
   --exclude-ext=[,[...]]
                             No cuente los archivos que tengan el nombre de archivo indicado
                             extensiones.
   --exclude-lang=[,L2[...]]
                             Excluir los idiomas separados por comas
                             L1, L2, L3, etcétera, para que no se cuenten.
   --exclude-list-file= Ignora archivos y/o directorios cuyos nombres
                             aparecer en .  debe tener un archivo
                             nombre por línea. Sólo se ignoran las coincidencias exactas;
                             Los nombres de ruta relativos se resolverán a partir de
                             el directorio donde se invoca cloc.
                             Véase también --list-file.
   --fullpath Modifica el comportamiento de --match-f, --not-match-f,
                             y --not-match-d para incluir la ruta del archivo
                             en la expresión regular, no solo el nombre base del archivo.
                             (Esto no expande cada archivo para incluir su
                             ruta absoluta, en su lugar utiliza la mayor cantidad de
                             el camino cuando se pasa a cloc.)
                             Nota: --match-d siempre mira el archivo completo
                             ruta y por lo tanto no se ve afectada por --fullpath.
   --include-ext=[,ext2[...]]
                             Cuente solo los idiomas que tengan la coma dada
                             extensiones de archivos separadas. Utilice --show-ext para
                             ver las extensiones reconocidas.
   --include-lang=[,L2[...]]
                             Cuente solo los idiomas separados por comas
                             L1, L2, L3, etcétera. Utilice --show-lang para ver
                             la lista de idiomas reconocidos.
   --match-d= Solo cuenta archivos en directorios que coincidan con Perl
                             expresión regular. Por ejemplo
                               --match-d='/(src|incluir)/'
                             sólo cuenta archivos en directorios que contienen
                             /src/ o /include/. A diferencia de --not-match-d,
                             --match-f y --not-match-f, --match-d siempre
                             compara la ruta totalmente calificada con la
                             expresión regular.
   --not-match-d= Cuente todos los archivos excepto los de los directorios
                             que coincide con la expresión regular de Perl. Sólo el final
                             El nombre del directorio se compara, por ejemplo, cuando
                             contando en /usr/local/lib, sólo 'lib' es
                             en comparación con la expresión regular.
                             Agregue --fullpath para comparar los directorios principales con
                             la expresión regular.
                             No incluya separadores de ruta de archivo en el
                             principio o final de la expresión regular.
   --match-f= Solo cuenta los archivos cuyos nombres base coincidan con Perl
                             expresión regular. Por ejemplo
                               --match-f='^[Ww]idget'
                             sólo cuenta los archivos que comienzan con Widget o widget.
                             Agregue --fullpath para incluir directorios principales
                             en la expresión regular en lugar de solo el nombre base.
   --not-match-f= Cuente todos los archivos excepto aquellos cuyos nombres base
                             coincide con la expresión regular de Perl. Agregue --fullpath para incluir
                             directorios principales en la expresión regular en lugar de solo
                             el nombre base.
   --skip-archive= Ignorar archivos que terminan con el Perl regular dado
                             expresión. Por ejemplo, si se le da
                               --skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
                             el código omitirá los archivos que terminen en .zip,
                             .tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz y
                             .tar.7z.
   --skip-win-hidden En Windows, ignora los archivos ocultos.

 Opciones de depuración
   --categorized= Guardar tamaños de archivos en bytes, idiomas identificados
                             y nombres de archivos categorizados en .
   --contado =  Guardar nombres de los archivos de origen procesados ​​en .
   --Diff-Alignment =  Escribir en  Una lista de archivos y pares de archivos
                             mostrando qué archivos se agregaron, eliminaron y/o
                             comparado durante una carrera con --diff. Este interruptor
                             Fuerza el modo --diff.
   --explane =  Imprima los filtros utilizados para eliminar los comentarios para
                             Lenguaje  y salida. En algunos casos el
                             Los filtros se refieren a las subrutinas de Perl en lugar de
                             Expresiones regulares. Un examen de la
                             El código fuente puede ser necesario para una explicación adicional.
   -Help Imprime esta información y salida de uso.
   --found =  Guardar nombres de cada archivo encontrado en .
   --ignored =  Guardar nombres de archivos ignorados y la razón por la que
                             fueron ignorados a .
   -Código fuente procesado de impresión de filtros de huella de impresión
                             Se aplica cada filtro.
   --show-ext [= ] Imprimir información sobre todos los conocidos (o solo el
                             Dado) Extensiones de archivo y salida.
   --show-lang [= ] Imprima información sobre todos los conocidos (o solo el
                             dado) Idiomas y salida.
   --show-os imprime el valor del modo del sistema operativo
                             y salir. Ver también --unix, -Windows.
   -v [= ] interruptor de verbose (valor numérico opcional).
   -verbose [= ] forma larga de -v.
   -Versión Imprima la versión de este programa y salida.
   --Write-Lang-Def =  escribe en  Los filtros de procesamiento del lenguaje
                             luego sale. Útil como primer paso para crear
                             Definiciones de lenguaje personalizados. Nota: Idiomas que
                             Se excluirá el mapa a la misma extensión del archivo.
                             (Ver también --force-lang-des, --read-lang-des).
   --WRITE-LANG-DEF-INCL-DUP = 
                             Igual que--Write-Lang-Def, pero incluye duplicado
                             extensiones. Esto genera un lenguaje problemático
                             Archivo de definición porque CLOC se negará a usar
                             hasta que se eliminen los duplicados.

 Opciones de salida
   --3 Imprima la salida del idioma de tercera generación.
                             (Esta opción puede hacer que la suma de informes falle
                             Si se produjeron algunos informes con esta opción
                             mientras que otros fueron producidos sin él).
   -Por el porcentaje x en lugar de comentarios y recuentos de línea en blanco, mostrar
                             Estos valores como porcentajes basados ​​en el valor
                             de x en el denominador:
                                X = 'c' -> # líneas de código
                                X = 'cm' -> # líneas de código + comentarios
                                X = 'cb' -> # líneas de código + espacios en blanco
                                X = 'cmb' -> # líneas de código + comentarios + espacios en blanco
                             Por ejemplo, si se usa el método 'C' y su código
                             tiene el doble de líneas de comentarios que las líneas
                             de código, el valor en la columna de comentarios
                             ser 200%. La columna de código sigue siendo un recuento de líneas.
   --CSV escribe los resultados como valores separados por comas.
   --csv-delimiter =  use el carácter  como delimitador para la coma
                             archivos separados en lugar de ,. Este interruptor fuerza - -CSV para estar encendido.
   --file-ending =  Escribir archivos de salida utilizando la codificación  en lugar de
                             El ASCII predeterminado ( = 'UTF-7'). Ejemplos: 'UTF-16',
                             'EUC-KR', 'ISO-8859-16'. Las codificaciones conocidas pueden ser
                             impreso con
                               perl -mencode -e 'print Join (" n", encode-> codings (": all")), " n"'
   -Hide-thel no muestra tasas de procesamiento de línea y archivos en el
                             Encabezado de salida. Esto hace que la salida sea determinista.
   --json escribe los resultados como notación de objeto JavaScript
                             (JSON) Salida formateada.
   --MD Escriba los resultados como texto con formato de Markdown.
   --out =  sinónimo de --peport-file = .
   --progress-rate =  Mostrar actualización de progreso después de cada  archivos son
                             procesado (predeterminado  = 100). Establecer  a 0 a
                             suprimir la salida de progreso (útil al redirigir
                             salida a stdout).
   -Quite suprima todos los mensajes de información excepto para
                             El informe final.
   --Preport-File =  Escriba los resultados en  en lugar de STDOUT.
   --sql =  Escribir resultados como SQL Crear e insertar declaraciones
                             que puede ser leído por un programa de base de datos como
                             Sqlite. If  es -, la salida se envía a stdout.
   --sql-append append sql inserte las declaraciones en el archivo especificado
                             por --sql y no genere la creación de mesa
                             declaraciones. Solo válido con la opción --sql.
   --sql-project =  use  como el identificador del proyecto para el
                             ejecución actual. Solo válido con la opción --sql.
   --sql-style =  escribir declaraciones SQL en el estilo dado
                             del formato SQLite predeterminado. Los estilos incluyen
                             'Oracle' y 'named_columns'.
   --sum-one para informes de texto sin formato, muestre la suma: línea de salida
                             Incluso si solo se procesa un archivo de entrada.
   --xml Escriba los resultados en XML.
   --xsl =  reference  como una hoja de estilo XSL dentro de
                             la salida XML. Si  es 1 (numérico),
                             escribe una hoja de estilo predeterminada, cloc.xsl (o
                             CLOC-DIFF.XSL IF--DIFF también se da).
                             Este interruptor Fuerza -xml encendido.
   -yaml escriba los resultados en Yaml.

Idiomas reconocidos ▲

 indicador> cloc --show-lang

ABAP (ABAP)
ActionScript (as)
ADA (ADA, ADB, ADS, PAD)
ADSO/IDSM (ADSO)
Agda (Agda, Lagda)
Amplio (amplio, dofile, startup)
Ansprolog (LP)
Ant (build.xml, build.xml)
Gramática ANTLR (G, G4)
Clase APEX (CLS)
Disparador de apex (disparador)
APL (APL, APLA, APLC, APLF, APLI, APLN, APLO, DYALOG, DYAPP, MIPAGE)
AppleScript (AppleScript)
Sketch Arduino (INO)
Arkts (ETS)
Arturo (arte)
Asciidoc (ADOC, ASCIIDOC)
ASP (ASA, ASHX, ASP, AXD)
ASP.NET (ASAX, ASCX, ASMX, ASPX, Master, Sitemap, WebInfo)
AspectJ (AJ)
Ensamblaje (A51, ASM, NASM, S, S)
Astro (Astro)
Asíntota (asy)
Autohotkey (ahk, ahkl)
Awk (Auk, Awk, Bawk, Mawk, Nawk)
Bazel (construcción)
BizTalk Orchestration (ODX)
BizTalk Pipeline (BTP)
Blade (Blade, Blade.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)
Encabezado C/C ++ (H, H, HH, HPP, HXX)
El Cairo (El Cairo)
Script de construcción de pastel (pastel)
Carbono (carbono)
CCS (CCS)
Capilla (CHPL)
Circom (Circom)
Limpiar (DCL, ICL)
Clojure (Boot, CL2, CLJ, CLJS.HL, CLJSCM, CLJX, HIC, RIEMANN.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, Coffee, Iced)
Coldfusion (CFM, CFML)
Coldfusion CFScript (CFC)
Gramática de restricción (CG3, RLX)
ContainerFile (contenedor)
Coq (v)
Cristal (CR)
CSON (CSON)
CSS (CSS)
CSV (CSV)
Pepino (característica)
Cuda (Cu, Cuh)
Cython (PXD, PXI, PYX)
D (D)
Dafny (DFY)
Dal (DA)
Dardo (dardo)
Forma Delphi (DFM)
Denizenscript (DSC)
DERW (DERW)
Dhall (Dhall)
Dieta (DT)
diff (diff, parche)
Dita (dita)
Dockerfile (Dockerfile, Dockerfile)
Lenguaje de extensión de puertas (DXL)
DOS Batch (Bat, Bat, BTM, BTM, CMD, CMD)
Baba (DRL)
DTD (DTD)
dtrace (d)
ECPP (ECPP)
EEX (EEX)
EJS (EJS)
Elixir (ex, ex)
Elm (Elm)
Cristal incrustado (ECR)
ERB (ERB, ERB)
Erlang (App.Src, EMakeFile, Erl, HRL, ReRbar.Config, ReRar.Config.lock, ReRar.lock, XRL, YRL)
Espere (exp)
F# (FSI, FS, FS)
Script F# (FSX)
Hinojo (FNL)
Lenguaje de estado finito (FSL, JSSM)
Concha de pescado (pescado)
Flatbuffers (FBS)
Enfoque (FECEXEC)
Forth (4th, E4, F83, Fb, Forth, FPM, FR, FRT, FT, FTH, RX, FS, F, FOR)
FORTRAN 77 (F, F77, F77, para, FTN, FTN, PFO, F, FOR)
Fortran 90 (F90, F90)
Fortran 95 (F95, F95)
Plantilla de marca libre (FTL)
Futhark (FUT)
FXML (FXML)
Gdscript (GD)
Gencat NLS (MSG)
Glade (Glade, ui)
Brillo (brillo)
Glimmer JavaScript (GJS)
TypeScript de brillo (GTS)
GLSL (COMP, FP, FRAG, FRG, FSH, FSHADER, GEO, GEOM, GLSL, GLSLV, GSHADER, TESC, TESE, VERT, VRX, VSH, VSHADER)
Ve (vete, ʕ◔ϖ◔ʔ)
Recurso de Godot (Tres)
Escena de Godot (TSCN)
Godot Shaders (Gdshader)
Gradle (Gradle, Gradle.kts)
Grails (GSP)
GraphQL (GQL, GraphQL, GraphQLS)
Groovy (Gant, Groovy, GRT, GTPL, Gvy, Jenkinsfile)
Haml (Haml, Haml.deface)
Manillar (manillar, HBS)
Puerto (HB)
Liebre (ja)
Haskell (HS, HSC, LHS)
HAXE (HX, HXSL)
HCL (HCL, Nomad, TF, TFVARS)
HLSL (CG, CGINC, FXH, HLSL, HLSLI, sombreador)
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, prefs)
InstallShield (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)
Caras de Javaserver (JSF)
JCL (JCL)
Plantilla Jinja (J2, Jinja, Jinja2)
JSON (ArcConfig, AVSC, Composer.lock, GeoJson, Gltf, Har, Htmlhintrc, JSON, JSON-TMLanguage, 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)
Notebook Jupyter (ipynb)
Kermit (KSC)
Korn Shell (KSH)
Kotlin (KT, KTM, KTS)
Kvlang (KV)
Lean (Hlean, Lean)
Lem (Lem)
Menos (menos)
Lex (L, Lex)
LFE (LFE)
Script de enlazador (LD)
líquido (líquido)
Lisp (ASD, EL, LISP, LSP, CL, JL)
Idris alfabetizado (Lidr)
LiveLink OScript (Oscript)
LLVM IR (LL)
Logotipos (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, MDOWN, MDWN, MDX, MKD, MKDN, MKDOWN, RONN, LIBRO DE TRABAJO)
Mathematica (CDF, ​​MA, Mathematica, MT, NBP, WL, WLT, M)
Matlab (M)
Maven (POM, POM.XML)
Meson (Meson.Build)
Metal (metal)
Modelica (MO)
Modula3 (I3, IG, M3, Mg)
Mojo (Mojo,?)
Mojom (Mojom)
MSBuild Script (Btproj, CSProj, MSBUILD, VCPROJ, WDPROJ, WIXPROJ)
Pomitas (MPS, M)
Bigote (bigote)
MXML (MXML)
Script nant (compilación)
Nastran DMAP (DMAP)
Nemerle (n)
Netlogo (Nlogo, NLS)
Níquel (NCL)
Nim (Nim, Nim.CFG, Nimble, Nimrod, NIMS)
Nix (Nix)
Nunjucks (NJK)
Objetivo-C (M)
Objetivo-C ++ (mm)
Ocaml (Eliom, Eliomi, Ml, Ml4, Mli, ​​Mll, Mly)
Odin (Odin)
OpenCl (CL)
OpenScad (SCAD)
Formularios Oracle (FMT)
Oracle PL/SQL (BOD, FNC, PRC, SPC, TRG)
Oracle Reports (Rex)
P4 (P4)
Pascal (DPR, LPR, PAS, Pascal)
Pascal/peón (P)
Pascal/títere (pp)
Lenguaje de comando de Patrán (PCL, SES)
Peón (peón, pwn)
Peg (clavija)
PEG.JS (PEGJS)
Peggy (Peggy)
Perl (ACK, AL, CPANFILE, MAKEFILE.PL, PERL, PH, PLH, PLX, PM, PSGI, REXFILE, PL, P6)
Plaga (plaga)
PHP (AW, CTP, PhakeFile, PHP, PHP3, PHP4, PHP5, PHP_CS, PHP_CS.DIST, PHPS, PHPT, PHTML)
PHP/PASCAL/FORTRAN/PEAW (INC)
Pig Latin (cerdo)
PL/I (PL1)
PL/M (LIT, PLM)
Plantuml (IUML, Plantuml, PU, ​​Puml, WSD)
PO FILE (PO)
Pony (pony)
PowerBuilder (PBT, SRA, SRF, SRM, SRS, SRU, SRW)
PowerShell (PS1, PSD1, PSM1)
Esquema de prisma (prisma)
Procesamiento (PDE)
Proguard (Pro)
PROLOT (P, PROLOT, YAP, PL, P6, PRO)
Propiedades (propiedades)
Buffers de protocolo (Proto)
PRQL (PRQL)
Pug (Jade, Pug)
PureScript (PROB)
Python (Buck, Build.Bazel, Gclient, Gyp, Gypi, LMI, Py, Py3, Pyde, Pyi, Pyp, Pyt, Pyw, Sconscript, Sconstruct, SnakeFile, TAC, Workspace, WSCRIPT, WSGI, XPY)
QML (QBS, QML)
Qt (ui)
QT Lingüista (TS)
Proyecto QT (Pro)
R (Expr-Dist, R, R, Rd, Rprofile, RSX)
Racket (RKT, RKTD, RKTL, SCRBL)
Raku (PM6, Raku, Rakumod)
Raku/Prolog (P6, P6)
Raml (Raml)
Rapydscript (PYJ)
Razor (CSHTML, Razor)
Razonml (re, rei)
RECRIPT (RES, RESI)
reestructuredText (REST, REST.TXT, RST, RST.TXT)
Rexx (PPRX, Rexx)
Anillo (rform, rh, anillo)
RMD (RMD)
Robotframework (robot)
Ruby (evaluaciones, Berksfile, Brewfile, Builder, BuildFile, Capfile, DangerFile, Deliverfile, Eye, FastFile, Gemfile, GemFile.lock, Gemspec, God, GuardFile, Irbrc, Jarfile, JBuilder, Mavenfile, Mspec, Podfile, Podspec, Pryryrc, PRYRC, PRYRC, 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)
Esquema (SC, SCH, SCM, SLD, SPS, SS, SLS)
SCSS (SCSS)
sed (sed)
Habilidad (IL)
Habilidad ++ (ILS)
Rebanada (hielo)
Delgado (delgado)
Slint (Slint)
Smalltalk (ST, CS)
Smarty (Smarty, TPL)
Snakemake (Reglas, SMK)
Softbridge Basic (SBL, SBL)
Solidez (sol)
Sparforte (SP)
Specman E (E)
SQL (CQL, MySQL, PSQL, SQL, SQL, TAB, UDF, VIW)
Datos de SQL (data.sql)
Procedimiento almacenado SQL (SPC.SQL, SPOC.SQL, SPROC.SQL, UDF.SQL)
Ardilla (nuez)
ML estándar (Fun, SIG, SML)
Starlark (Bazel, BZL)
Stata (ADO, DO, DO, DOH, IHLP, MATA, MATAH, STHLP)
Lápiz (lápiz)
Sugarss (SSS)
Esbelto (esbelto)
SVG (SVG, SVG)
Swift (Swift)
Swig (i)
TableGen (TD)
TCL/TK (ITK, TCL, TK)
Verde azulado (verde azulado)
Teamcenter Met (Met)
Teamcenter MTH (MTH)
TEMPL (TEMPL)
Tex (Aux, BBX, BIB, BST, CBX, DTX, INS, LBX, LTX, MKII, MKIV, MKVI, STY, TEX, CLS)
Texto (texto, txt)
Ahorro (ahorro)
Información del archivo del proyecto Titan (TPD)
Hoja de estilo de titanio (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)
Ramita (ramita)
TypeScript (MTS, TSX, TS)
Typst (typ)
Umka (um)
Unity-prefab (Mat, Prefab)
Vala (Vala)
Cabezal de Vala (Vapi)
VB para aplicaciones (VBA, VBA)
Lenguaje de plantilla de velocidad (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 Visual Basic (VBS, VBS)
Visual Fox Pro (SCA, SCA)
Solución de Visual Studio (SLN)
Componente de Visualforce (componente)
Página de Visualforce (página)
Componente VueJS (Vue)
Vyper (Vy)
Descripción de los servicios web (WSDL)
WebAssembly (WAST, WAT)
WGSL (WGSL)
Archivo de mensajes de Windows (MC)
Definición del módulo de Windows (DEF)
Archivo de recursos de Windows (RC, RC2)
Wix incluye (WXI)
Fuente de Wix (WXS)
Localización de cadenas WIX (WXL)
WXML (WXML)
WXSS (WXSS)
X ++ (xpo)
XAML (XAML)
XBase (PRG, PRW)
encabezado XBase (CH)
Xhtml (xhtml)
XMI (XMI, XMI)
XML (ADML, ADMX, ANT, APP.CONFIG, AXML, BUILDS, CCPROJ, CCXML, CLASSPATH, CLIXML, CPROJECT, CSCFG, CSDEF, CTS, CT, DPOPROJ, DITAMAP, DITAVAL, DLL.CONFIG, DOTSETTINGS, FILTRES, FSPROJ, GMX, GRXML, IML, Ivy, Jelly, Jsproj, KML, Lanzada, Mdpolicy, MJML, Natvis, Ndproj, Nproj, Nuget.Config, Nuspec, Odd, OSM, Packages.Config, Pkgproj, Plist, Proj, Project, Props, Props, Props, PS1XML, PSC1, PT, RDF, Resx, RSS, SCXML, Settings.Stylecop, Sfproj, Shproj, Srdf, Storyboard, Sttheme, Sublime-Snippet, Targets, TMCommand, TML, TMLanguage, TMPreferences, TMSNIPPET, TMTHTEME, URDF, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX, UX. VCXPROJ, VSIXMANIFEST, VSSETTINGS, VSTECLATE, VXML, WEB.CONFIG, WEB.DEBUG.CONFIG, WEB.RELEASE.CONFIG, WSF, X3D, XACRO, XIB, XLF, XLIFF, XML, XML, XML.DIST, XPROJ, XPEC, 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, sintaxis, yaml, yaml-tmlanguage, yml, yml.mysql)
Yang (yang)
Zig (Zig)
ZSH (ZSH)

La lista anterior se puede personalizar leyendo definiciones de idioma de un archivo con las opciones --read-lang-def o --force-lang-def .

Estas extensiones de archivos se asignan a varios idiomas:

• Los archivos cl podrían ser LISP u OpenCl
• Los archivos cls podrían ser Visual Basic, Tex o Apex Class
• Los archivos cs podrían ser C# o SmallTalk
• Los archivos d podrían ser D o DTRACE
• Los archivos f podrían ser FORTRAN 77 o
• Los archivos fnc podrían ser Oracle PL o SQL
• for los archivos podrían ser fortran 77 o
• Los archivos fs podrían ser f# o
• Los archivos inc podrían ser PHP o PASCAL
• Los archivos itk podrían ser TCL o TK
• Los archivos jl podrían ser Lisp o Julia
• Los archivos lit pueden ser PL o M
• Los archivos m podrían ser Matlab, Mathematica, Objective-C, Pomuns o Mercury
• Los archivos p6 podrían ser Perl o Prolog
• Los archivos pl podrían ser Perl o Prolog
• Los archivos PL podrían ser Perl o Prolog
• Los archivos pp podrían ser Pascal o Puppet
• Los archivos pro podrían ser IDL, Proyecto QT, Prolog o Proguard
• Los archivos ts podrían ser TypeScript o QT Linguist
• Los archivos ui podrían ser Qt o Glade
• Los archivos v podrían ser Verilog-Systemverilog o CoQ

CLOC tiene subrutinas que intentan identificar el lenguaje correcto en función del contenido del archivo para estos casos especiales. La precisión de identificación del idioma es una función de cuánto código contiene el archivo; Los archivos .m con solo una o dos líneas, por ejemplo, rara vez tienen suficiente información para distinguir correctamente entre matlab, mercurio, paperas u objetivo-c.

Los idiomas con colisiones de extensión de archivos son difíciles de personalizar con --read-lang-def o --force-lang-def ya que no tienen mecanismo para identificar idiomas con extensiones comunes. En esta situación, uno debe modificar el código fuente de CLOC.

Cómo funciona ▲

El método de operación de CLOC se asemeja a Sloccount: Primero, cree una lista de archivos a considerar. A continuación, intente determinar si los archivos encontrados contienen o no el código fuente de lenguaje de computadora reconocido. Finalmente, para los archivos identificados como archivos de origen, invoque rutinas específicas del idioma para contar el número de líneas de origen.

Una descripción más detallada:

1. Si el archivo de entrada es un archivo (como un archivo .tar.gz o .zip), cree un directorio temporal y expanda el archivo allí utilizando una llamada del sistema a una utilidad subyacente apropiada (tar, bzip2, unzip, etc.) y luego agregue Este directorio temporal como una de las entradas. (Esto funciona de manera más confiable en Unix que en Windows).

2. Use archivo :: Buscar para descender recursivamente los directorios de entrada y hacer una lista de nombres de archivos candidatos. Ignorar archivos binarios y de tamaño cero.

3. Asegúrese de que los archivos en la lista de candidatos tengan contenidos únicos (primero comparando los tamaños de los archivos, luego, para archivos de tamaño similar, compare los hashes MD5 del contenido del archivo con Digest :: MD5). Para cada conjunto de archivos idénticos, elimine todos menos la primera copia, según lo determinado por un tipo léxico, de archivos idénticos del conjunto. Los archivos eliminados no están incluidos en el informe. (El interruptor --skip-uniqueness deshabilita las pruebas de singularidad y obliga a todas las copias de los archivos que se incluyen en el informe). Vea también el interruptor --ignored= para ver qué archivos se ignoraron y por qué.

4. Escanee la lista de archivos candidatos para las extensiones de archivos que CLOC se asocia con los lenguajes de programación (consulte las opciones --show-lang y --show-ext ). Los archivos que coinciden se clasifican como que contienen código fuente para ese idioma. Cada archivo sin una extensión se abre y su primera línea se lee para ver si es un script de shell Unix (¡cualquier cosa que comience con #!). Si es script shell, el archivo se clasifica por ese lenguaje de secuencias de comandos (si se reconoce el idioma). Si el archivo no tiene una extensión reconocida o no es un lenguaje de secuencias de comandos reconocido, se ignora el archivo.

5. Todos los archivos restantes en la lista de candidatos ahora deben ser archivos fuente para lenguajes de programación conocidos. Para cada uno de estos archivos:

   1. Lea todo el archivo en la memoria.
   2. Cuente el número de líneas (= L _Original ).
   3. Retire las líneas en blanco, luego cuente nuevamente (= l _{non_blank} ).
   4. Loce los filtros de comentarios definidos para este idioma. (Por ejemplo, C ++ tiene dos filtros: (1) Eliminar líneas que comienzan con espacios en blanco opcional seguido de // y (2) eliminar el texto entre / * y * /) Aplicar cada filtro al código para eliminar los comentarios. Cuente las líneas sobrantes (= L _Código ).
   5. Guardar los recuentos para este idioma:
      • Líneas en blanco = L _Original - L _{Non_Blank}
      • Líneas de comentarios = l _{non_blank} - l _código
      • Código de líneas = L _Código

Las opciones modifican ligeramente el algoritmo. La opción --read-lang-def , por ejemplo, permite al usuario leer definiciones de filtros de comentarios, extensiones de archivos conocidas y lenguajes de secuencias de comandos conocidos desde un archivo. El código para esta opción se procesa entre los pasos 2 y 3.

Uso avanzado ▲

Eliminar los comentarios del código fuente ▲

¿Cómo puede saber si CLOC identifica correctamente los comentarios? Una forma de convencerse al cloc es hacer lo correcto es usar su opción --strip-comments para eliminar los comentarios y las líneas en blanco de los archivos, luego comparar los archivos despojados con los originales.

Probemos esto con la amalgamación SQLite, un archivo C que contiene todo el código necesario para construir la biblioteca SQLite junto con un archivo de encabezado:

 indicador> tar zxf sqlite-amalgamation-3.5.6.tar.gz
Aviso> CD SQLite-3.5.6/
indicador> cloc--stripcomments = nc sqlite.c
       1 archivo de texto.
       1 archivo único.
Escribió sqlite3.c.nc
       0 archivos ignorados.

http://cloc.sourceforge.net v 1.03 t = 1.0 s (1.0 archivos/s, 82895.0 líneas/s)
-------------------------------------------------- -----------------------
Archivos de lenguaje Código de comentarios en blanco Escala de tercera generación. equivalente
-------------------------------------------------- -----------------------
C 1 5167 26827 50901 x 0.77 = 39193.77
-------------------------------------------------- -----------------------

El argumento de extensión dado a--Strip-Comments es arbitrario; Aquí NC fue utilizado como abreviatura de "sin comentarios".

CLOC eliminó más de 31,000 líneas del archivo:

 indicador> wc -l sqlite3.c sqlite3.c.nc
  82895 sqlite3.c
  50901 sqlite3.c.nc
 133796 Total
Aviso> Echo "82895 - 50901" | antes de Cristo
31994

Ahora podemos comparar el archivo original, sqlite3.c y el despojado de comentarios, sqlite3.c.nc con herramientas como DIFF o VIMDIFF y ver qué consideró exactamente los comentarios y las líneas en blanco. Una prueba rigurosa de que el archivo despojado contiene el mismo código C que el original es compilar estos archivos y comparar las suma de verificación de los archivos de objetos resultantes.

Primero, el archivo fuente original:

 indicador> GCC -C SQLITE3.C
indicador> MD5SUM SQLITE3.O
CCE5F1A2EA27C7E44B2E1047E2588B49 SQLITE3.O

A continuación, la versión sin comentarios:

 Solicitud> MV SQLITE3.C.NC SQLITE3.C
indicador> GCC -C SQLITE3.C
indicador> MD5SUM SQLITE3.O
CCE5F1A2EA27C7E44B2E1047E2588B49 SQLITE3.O

CLOC eliminó más de 31,000 líneas de comentarios y espacios en blanco, pero no modificó el código fuente de ninguna manera significativa ya que el archivo de objeto resultante coincide con el original.

Trabajar con archivos comprimidos ▲

Las versiones de CLOC antes de V1.07 requirieron una opción --extract-with=CMD para decirle a CLOC cómo expandir un archivo de archivo. Comenzando con V1.07, esta es la extracción se intenta automáticamente. En este momento, el método de extracción automática funciona razonablemente bien en los sistemas operativos de tipo Unix para los siguientes tipos de archivos: .tar.gz , .tar.bz2 , .tar.xz , .tgz , .zip , .ear , .deb . Algunas de estas extensiones funcionan en Windows si uno tiene WinZip instalado en la ubicación predeterminada ( C:Program FilesWinZipWinZip32.exe ). Además, con versiones más nuevas de WinZip, el [http://www.winzip.com/downcl.htmfont>(Command Line Add-on) es necesario para el funcionamiento correcto; En este caso, uno invocaría a los cloc con algo como

 --extract -with = "" c:  programas de programa  winzip  wzunzip  "-e -o> file <."
 

Árbitro. http://sourceforge.net/projects/cloc/forums/forum/600963/topic/4021070?Message=8938196

En situaciones en las que falla la extracción automática, se puede probar la opción --extract-with=CMD para contar líneas de código dentro de archivos TAR, archivos zip u otros archivos comprimidos para los cuales uno tiene una herramienta de extracción. CLOC toma el comando de extracción proporcionado por el usuario y expande el archivo a un directorio temporal (creado con archivo :: temp), cuenta las líneas de código en el directorio temporal, luego elimina ese directorio. Si bien no es especialmente útil cuando se trata de un solo archivo comprimido (después de todo, si va a escribir el comando de extracción de todos modos, ¿por qué no solo expandir manualmente el archivo?) Esta opción es útil para trabajar con varios archivos a la vez.

Por ejemplo, digamos que tiene los siguientes tarballs de origen en una máquina Unix

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

Y quieres contar todo el código dentro de ellos. El comando sería

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

Si esa máquina Unix tiene alquitrán GNU (que puede descomprimir y extraer en un solo paso), el comando se puede acortar a

 cloc --extract-with = 'tar zxf> file <' perl-5.8.5.tar.gz python-2.4.2.tar.gz

En una computadora de Windows con Winzip instalada en c:Program FilesWinZip el comando se vería como

 cloc.exe --extract -with = "" c:  programas de programa  winzip  winzip32.exe  "-e -o> file <." Perl-5.8.5.tar.gz Python-2.4.2.tar.gz

Los archivos Java .ear son archivos zip que contienen archivos zip adicionales. El CLOC puede manejar archivos comprimidos anidados sin dificultad, proporcionó que todos estos archivos están comprimidos y archivados de la misma manera. Ejemplos de contar un archivo .ear Java en UNIX y Windows:

 Unix> cloc --extract -with = "unzip -d.> File <" Project.ear
Dos> cloc.exe --extract -with = "" c:  archivos de programa  winzip  winzip32.exe  "-e -o> file <." Proyecto.ear

Diferencias ▲

El conmutador --diff permite medir el cambio relativo en el código fuente y los comentarios entre dos versiones de un archivo, directorio o archivo. Las diferencias revelan mucho más que los recuentos de código absoluto de dos versiones de archivo. Por ejemplo, por ejemplo, un archivo fuente tiene 100 líneas y su desarrollador ofrece una versión más nueva con 102 líneas. ¿El desarrollador agregó dos líneas de comentarios, o eliminó diecisiete líneas de origen y agregó catorce líneas fuente y cinco líneas de comentarios, o el desarrollador hizo una reescritura completa, descartando las 100 líneas originales y agregando 102 líneas de todas las nuevas fuentes? La opción DIFF indica cuántas líneas de fuente se agregaron, eliminaron, modificaron o permaneceron igual, y cuántas líneas de comentarios se agregaron, eliminaron, modificaron o se mantuvieron igual.

Las diferencias en las líneas en blanco se manejan mucho más gruesamente porque las CLOC se despojan desde el principio. A menos que un par de archivos sea idéntico, CLOC informará solo diferencias en los recuentos absolutos de líneas en blanco. En otras palabras, uno puede esperar ver solo entradas para 'agregar' si el segundo archivo tiene más espacios en blanco que el primero, y 'eliminado' si la situación se invierte. La entrada para 'misma' no será cero solo cuando los dos archivos sean idénticos.

Además de los pares de archivos, se puede dar pares de directorios de cloc, o pares de archivos de archivos, o un archivo de archivos y un directorio. CLOC intentará alinear los pares de archivos dentro de los directorios o archivos y comparar diferencias para cada par. Por ejemplo, para ver qué cambió entre GCC 4.4.0 y 4.5.0 uno podría hacer

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

Sin embargo, prepárese para esperar un tiempo para obtener los resultados; La opción --diff se ejecuta mucho más lentamente que un recuento de código absoluto.

Para ver cómo CLOC alinea los archivos entre los dos archivos, use la opción --diff-alignment

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

Para producir el archivo align.txt que muestra los pares de archivos, así como los archivos agregados y eliminados. Los símbolos == y != Antes de cada par de archivos indican si los archivos son idénticos ( == ) o si tienen contenido diferente ( != ).

Aquí hay una salida de muestra que muestra la diferencia entre las versiones de Python 2.6.6 y 2.7:

 Aviso> Cloc--Diff Python-2.7.9.Tgz Python-2.7.10.tar.xz
    4315 archivos de texto.
    4313 archivos de texto.s
    2173 archivos ignorados.

4 errores:
Error de diff, excedido del tiempo de espera: /tmp/8toganb9y1/python-2.7.9/mac/modules/qt/_qtmodule.c
Error de diff, excedido del tiempo de espera: /tmp/m6ldvsgaoq/python-2.7.10/mac/modules/qt/_qtmodule.c
Error de diferencia (¿comentarios citados?): /Tmp/8toganb9y1/python-2.7.9/mac/modules/qd/qdsupport.py
Error de diferencia (¿comentarios citados?): /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 archivos/s, 0.0 líneas/s)
-------------------------------------------------- ---------------------
Archivos de idioma Código de comentarios en blanco
-------------------------------------------------- ---------------------
visualbásico
 Igual 2 0 1 12
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
hacer
 Igual 11 0 340 2952
 modificado 1 0 0 1
 agregado 0 0 0 0
 eliminado 0 0 0 0
diferencia
 Igual 1 0 87 105
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
CSS
 Igual 0 0 19 327
 modificado 1 0 0 1
 agregado 0 0 0 0
 eliminado 0 0 0 0
Objetivo-C
 Igual 7 0 61 635
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
Guión nant
 Igual 2 0 0 30
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
XML
 Igual 3 0 2 72
 modificado 1 0 0 1
 agregado 0 0 0 1
 eliminado 0 1 0 0
Archivo de recursos de Windows
 Igual 3 0 56 206
 modificado 1 0 0 1
 agregado 0 0 0 0
 eliminado 0 0 0 0
Esperar
 Igual 6 0 161 565
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
HTML
 Igual 14 0 11 2344
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
guión vim
 Igual 1 0 7 106
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
C++
 Igual 2 0 18 128
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
Definición del módulo de Windows
 Igual 7 0 187 2080
 modificado 2 0 0 0 0
 agregado 0 0 0 1
 eliminado 0 1 0 2
Prólogo
 Igual 1 0 0 24
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
JavaScript
 Igual 3 0 49 229
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
Asamblea
 Igual 51 0 6794 12298
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
Bourne Shell
 Igual 41 0 7698 45024
 modificado 1 0 0 3
 agregado 0 13 2 64
 eliminado 0 0 0 0
Lote de DOS
 Igual 29 0 107 494
 modificado 1 0 0 9
 agregado 0 1 0 3
 eliminado 0 0 0 0
MSBuild Script
 Igual 77 0 3 38910
 modificado 0 0 0 0
 agregado 0 0 0 0
 eliminado 0 0 0 0
Pitón
 Igual de 1947 0 109012 430335
 modificado 192 0 94 950
 Se agregó 2 323 283 2532
 eliminado 2 55 58 646
m4
 Igual 18 0 191 15352
 modificado 1 0 0 2
 agregado 1 31 0 205
 eliminado 0 0 0 0
do
 Igual 505 0 37439 347837
 modificado 45 0 13 218
 Se agregó 0 90 33 795
 eliminado 0 9 2 148
Encabezado C/C ++
 Igual 255 0 10361 66635
 modificado 5 0 5 7
 agregado 0 1 3 300
 eliminado 0 0 0 0
-------------------------------------------------- -------------------
SUMA:
 Igual 2986 0 172604 966700
 modificado 251 0 112 1193
 Se agregó 3 459 321 3901
 eliminado 2 66 60 796
-------------------------------------------------- -------------------

Se produjeron un par de errores. El primer par fue causado por el tiempo fuera al calcular las diferencias del archivo Python-X/Mac/Modules/qt/_Qtmodule.c en cada versión de Python. Este archivo tiene> 26,000 líneas de código C y toma más de 10 segundos, la duración máxima predeterminada para difundir un solo archivo, en mi computadora lenta. (Nota: Esto se refiere a realizar diferencias con la función sdiff() en el Algorithm::Diff , no la utilidad diff la línea de comando.) Este error puede superarse al aumentar el tiempo para, por ejemplo, 20 segundos con --diff-timeout 20 .

El segundo error es más problemático. Los archivos Python-X/Mac/Modules/qd/qdsupport.py incluyen Python Docstring (texto entre pares de citas triples) que contienen comentarios C. CLOC trata las documentos como comentarios y los maneja primero convirtiéndolos en comentarios C, luego usando el comentario C eliminando la expresión regular. Sin embargo, los comentarios de C anidados producen resultados erróneos.

Crear definiciones de idioma personalizadas ▲

CLOC puede escribir sus definiciones de comentarios de idioma en un archivo o puede leer las definiciones de comentarios de un archivo, anulando las definiciones incorporadas. Esto puede ser útil cuando desea usar CLOC para contar líneas de un idioma aún no incluido, para cambiar la asociación de extensiones de archivos a los idiomas o para modificar la forma en que se cuentan los idiomas existentes.

La forma más fácil de crear un archivo de definición de idioma personalizado es hacer que CLOC escriba sus definiciones en un archivo, luego modifique ese archivo:

 Unix> CLOC--WRITE-LANG-DEF = my_definitions.txt

Crea el archivo my_definitions.txt que se puede modificar y luego lee nuevamente con la opción --read-lang-def o --force-lang-def . La diferencia entre las opciones es fusionar las definiciones de lenguaje de fusiones anteriores del archivo dado con las definiciones internas de CLOC con la precedencia de CLOC si hay superposiciones. La opción --force-lang-def , por otro lado, reemplaza las definiciones de CLOC por completo. Esta opción tiene una desventaja al evitar que los CLOC conten los idiomas cuyas extensiones se mapeen a varios idiomas, ya que estos idiomas requieren lógica adicional que no se exprese fácilmente en un archivo de definiciones.

 Unix> CLOC --Read-Lang-Def = my_definitions.txt file1 file2 dir1 ...

Cada entrada del idioma tiene cuatro partes:

• El nombre del idioma que comienza en la columna 1.
• Uno o más filtros de comentarios que comienzan en la columna 5.
• Una o más extensiones de nombre de archivo que comienzan en la columna 5.
• Un factor de escala de tercera generación que comienza en la columna 5. Esta entrada debe proporcionarse, pero su valor no es importante a menos que desee comparar su lenguaje con un lenguaje de programación hipotético de tercera generación.

Un filtro define un método para eliminar el texto de comentarios del archivo de origen. Por ejemplo, la entrada para C ++ se ve así

 C++
    Filtro Call_regexp_common C ++
    Filtro remove_inline //.*$
    Extensión C
    extensión C ++
    Extensión CC
    CPP de extensión
    extensión CXX
    extensión PCC
    3rd_gen_scale 1.51
    end_of_line_continuation \ $

C ++ tiene dos filtros: primero, elimine las líneas que coinciden con REGEXP :: COMENTOS C ++ COMENT REGEX. El segundo filtro que usa eliminar_inline no se usa actualmente. Su intención es identificar líneas con código y comentarios y puede implementarse en el futuro.

Una discusión más completa de las diferentes opciones de filtro puede aparecer aquí en el futuro. La salida de la opción --write-lang-def debe proporcionar suficientes ejemplos para que las personas motivadas modifiquen o extiendan las definiciones de lenguaje de CLOC.

Combinar informes ▲

Si administra múltiples proyectos de software, podría estar interesado en ver los recuentos de líneas por proyecto, no solo por lenguaje. Digamos que administra tres proyectos de software llamados MariadB, PostgreSQL y SQLite. Los equipos responsables de cada uno de estos proyectos ejecutan CLOC en su código fuente y le proporcionan la salida. Por ejemplo, el equipo de Mariadb lo hace

 cloc --out mariadb-10.1.txt mariadb-server-10.1.zip

y le proporciona el archivo mariadb-10.1.txt . El contenido de los tres archivos que obtiene son

 Unix> Cat Mariadb-10.1.txt
https://github.com/aldanial/CLOC V 1.65 T = 45.36 S (110.5 archivos/s, 66411.4 líneas/s)
-------------------------------------------------- ---------------------------------
Archivos de idioma Código de comentarios en blanco
-------------------------------------------------- ---------------------------------
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 :

Campo	Tipo
identificación	integer primary key
marca de tiempo	texto
proyecto	texto
elapsed_s	texto

Table t :

Campo	Tipo
proyecto	texto
idioma	texto
archivo	texto
nBlank	entero
nComment	entero
nCode	entero
nScaled	real
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 ; entonces
    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)."
    salida
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

Otros ejemplos:

• 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:

1. --list-file
2. --exclude-list-file
3. --read-lang-def
4. --force-lang-def
5. --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:

1. Lines containing both source code and comments are counted as lines of code.
2. 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 .

3. Embedded languages are not recognized. For example, an HTML file containing JavaScript will be counted entirely as HTML.
4. 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.
5. Language definition files read with --read-lang-def or --force-lang-def must be plain ASCII text files.
6. 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.
7. 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).
8. cloc's comment match code uses regular expressions which cannot properly account for nested comments using the same comment markers (such as /* /* */ */ ).
9. 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:

1. 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.
2. A description of how comments are defined.
3. 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

1. the operating system you're running on
2. the cloc command with all options
3. 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