um relógio

relógio

Contar linhas de código

---

cloc conta linhas em branco, linhas de comentários e linhas físicas de código-fonte em muitas linguagens de programação.

Versão mais recente: v2.02 (2 de agosto de 2024)

cloc mudou para GitHub em setembro de 2015 depois de ser hospedado em http://cloc.sourceforge.net/ desde agosto de 2006.

• Início rápido
• Visão geral
• Download
  • Instalar via gerenciador de pacotes
  • Versão estável
  • Versão de desenvolvimento
• Licença
• Por que usar o cloc?
• Outros contadores
• Construindo um executável do Windows
• Uso Básico
• Opções
• Idiomas reconhecidos
• Como funciona
• Uso Avançado
  • Remover comentários do código-fonte
  • Trabalhar com arquivos compactados
  • Diferenças
  • Crie definições de linguagem personalizadas
  • Combinar relatórios
  • SQL
  • Saída de coluna personalizada
  • Envolvendo cloc em outros scripts
  • nomes de caminhos git e UTF8
  • Fatores de escala de linguagem de terceira geração
  • arquivo de configuração options.txt
  • Interface Programática Java
• Limite de recursão de subexpressão regular complexa
• Limitações
• Solicitando suporte para idiomas adicionais
• Relatando problemas
• Citação
• Agradecimentos
• Direitos autorais

Início rápido ▲

Passo 1: Baixe o cloc (vários métodos, veja abaixo) ou execute a imagem docker do cloc. O executável do Windows não possui requisitos. A versão fonte do cloc requer um interpretador Perl, e a versão Docker do cloc requer uma instalação do Docker.

Passo 2: Abra um terminal ( cmd.exe no Windows).

Etapa 3: invoque cloc para contar seus arquivos de origem, diretórios, arquivos ou commits git. O nome do executável difere dependendo se você usa a versão de origem de desenvolvimento ( cloc ), a fonte de uma versão lançada ( cloc-2.02.pl ) ou um executável do Windows ( cloc-2.02.exe ).

Nesta página, cloc é o termo genérico usado para se referir a qualquer um deles.

Incluir Segurança tem um vídeo no YouTube mostrando as etapas em ação.

um arquivo

 prompt> cloc olá.c
       1 arquivo de texto.
       1 arquivo único.
       0 arquivos ignorados.

https://github.com/AlDanial/cloc v 1,65 T=0,04 s (28,3 arquivos/s, 340,0 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
C 1 0 7 5
-------------------------------------------------- -----------------------------

um diretório

 prompt> cloc gcc-5.2.0/gcc/c
      16 arquivos de texto.
      15 arquivos exclusivos.
       3 arquivos ignorados.

https://github.com/AlDanial/cloc v 1,65 T = 0,23 s (57,1 arquivos/s, 188.914,0 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
C10 4680 6621 30812
Cabeçalho C/C++ 3 99 286 496
-------------------------------------------------- -----------------------------
SOMA: 13 4779 6907 31308
-------------------------------------------------- -----------------------------

um arquivo

Extrairemos o arquivo zip de origem do cloc do GitHub e contaremos o conteúdo:

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

prompt> cloc master.zip
https://github.com/AlDanial/cloc v 1,65 T=0,07 s (26,8 arquivos/s, 141370,3 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
Perl2 725 1103 8713
-------------------------------------------------- -----------------------------
SOMA: 2 725 1103 8713
-------------------------------------------------- -----------------------------

um repositório git, usando um commit específico

Este exemplo usa código do PuDB, um fantástico depurador Python.

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

prompt> cd pudb

prompt> cloc 6be804e07a5db
      48 arquivos de texto.
      41 arquivos exclusivos.                              
       8 arquivos ignorados.

github.com/AlDanial/cloc v 1,99 T = 0,04 s (1.054,9 arquivos/s, 189.646,8 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
Pitão 28 1519 728 4659
Texto reestruturado 6 102 20 203
YAML 2 9 2 75
Bourne Concha 3 6 0 17
Texto 1 0 0 11
faça 1 4 6 10
-------------------------------------------------- -----------------------------
SOMA: 41 1640 756 4975
-------------------------------------------------- -----------------------------

cada subdiretório de um diretório específico

Digamos que você tenha um diretório com três projetos diferentes gerenciados pelo git, Projeto0, Projeto1 e Projeto2. Você pode usar a capacidade de loop do seu shell para contar o código em cada um. Este exemplo usa bash (role para baixo para ver o exemplo cmd.exe):

 prompt> para d em ./*/ ; do (cd "$d" && echo "$d" && cloc --vcs git); feito
./Projeto0/
7 arquivos de texto.
       7 arquivos exclusivos.
       1 arquivo ignorado.

github.com/AlDanial/cloc v 1,71 T = 0,02 s (390,2 arquivos/s, 25.687,6 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
D 4 61 32 251
Remarcação 1 9 0 38
faça 1 0 0 4
-------------------------------------------------- -----------------------------
SOMA: 6 70 32 293
-------------------------------------------------- -----------------------------
./Projeto1/
       7 arquivos de texto.
       7 arquivos exclusivos.
       0 arquivos ignorados.

github.com/AlDanial/cloc v 1,71 T = 0,02 s (293,0 arquivos/s, 52107,1 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
Vá 7 165 282 798
-------------------------------------------------- -----------------------------
SOMA: 7 165 282 798
-------------------------------------------------- -----------------------------
./Projeto2/
      49 arquivos de texto.
      47 arquivos exclusivos.
      13 arquivos ignorados.

github.com/AlDanial/cloc v 1,71 T=0,10 s (399,5 arquivos/s, 70409,4 linhas/s)
-------------------------------------------------- -----------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- -----------------------------
Pitão 33 1226 1026 3017
C4 327 337 888
Remarcação 1 11 0 28
YAML 1 0 2 12
-------------------------------------------------- -----------------------------
SOMA: 39 1564 1365 3945
-------------------------------------------------- -----------------------------

cada subdiretório de um diretório específico (Windows/cmd.exe)

 para /D %I in (.*) faça cd %I && cloc --vcs git && cd ..

Visão geral ▲

cloc conta linhas em branco, linhas de comentários e linhas físicas de código-fonte em muitas linguagens de programação. Dadas duas versões de uma base de código, cloc pode calcular diferenças em linhas em branco, comentários e linhas de origem. Ele é escrito inteiramente em Perl, sem dependências fora da distribuição padrão do Perl v5.6 e superior (o código de alguns módulos externos é incorporado ao cloc) e, portanto, é bastante portátil. cloc é conhecido por rodar em muitas versões de Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX, z/OS e Windows. (Para executar a versão fonte Perl do cloc no Windows é necessário ActiveState Perl 5.6.1 ou superior, Strawberry Perl, Windows Subsystem for Linux, Cygwin, MobaXTerm com o plug-in Perl instalado ou um ambiente e terminal mingw, como fornecido por Git para Windows. Alternativamente, pode-se usar o binário Windows do cloc gerado com PAR::Packer para rodar em computadores Windows que não possuem Perl nem Cygwin.)

Além de contar código em arquivos de texto individuais, diretórios e repositórios git, cloc também pode contar código em arquivos compactados como .tar (incluindo versões compactadas), .zip , Python wheel .whl , Jupyter notebook .ipynb , RPMs de origem .rpm ou .src (requer rpm2cpio ) e arquivos Debian .deb (requer dpkg-deb ).

cloc contém código do SLOCCount de David Wheeler, do módulo Perl de Damian Conway e Abigail Regexp::Common, do módulo Perl de Sean M. Burke Win32::Autoglob e do módulo Perl de Tye McQueen Algorithm::Diff. Os fatores de escala de idioma foram derivados do site da Mayes Consulting, LLC http://softwareestimator.com/IndustryData2.htm.

Novos lançamentos aparecem nominalmente a cada seis meses.

Executar via janela de encaixe

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

Execute via docker no git-bash

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

Instalar via gerenciador de pacotes

Dependendo do seu sistema operacional, um destes métodos de instalação pode funcionar para você (todos, exceto as duas últimas entradas para Windows, requerem um interpretador 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 : eu não controlo nenhum desses pacotes. Se você encontrar um bug no cloc usando um dos pacotes acima, tente com o cloc extraído da versão estável mais recente aqui no GitHub (link abaixo) antes de enviar um relatório de problema.

Versão estável

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

Versão de desenvolvimento

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

Licença ▲

cloc é licenciado sob a Licença Pública Geral GNU, v 2, excluindo partes que são copiadas de outras fontes. O código copiado dos módulos Regexp::Common, Win32::Autoglob e Algorithm::Diff Perl está sujeito à Licença Artística.

Por que usar o cloc? ▲

cloc possui muitos recursos que o tornam fácil de usar, completo, extensível e portátil:

1. Existe como um arquivo único e independente que requer esforço mínimo de instalação – basta baixar o arquivo e executá-lo.
2. Pode ler definições de comentários de linguagem de um arquivo e, assim, trabalhar potencialmente com linguagens de computador que ainda não existem.
3. Permite que os resultados de múltiplas execuções sejam somados por idioma e por projeto.
4. Pode produzir resultados em vários formatos: texto simples, Markdown, SQL, JSON, XML, YAML, valores separados por vírgula.
5. Pode contar código em arquivos compactados (tar balls, arquivos Zip, arquivos Java .ear).
6. Possui inúmeras opções de solução de problemas.
7. Lida com nomes de arquivos e diretórios com espaços e outros caracteres incomuns.
8. Não possui dependências fora da distribuição Perl padrão.
9. É executado em sistemas Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX e z/OS que possuem Perl 5.6 ou superior. A versão fonte é executada no Windows com o plugin ActiveState Perl, Strawberry Perl, Cygwin ou MobaXTerm+Perl. Alternativamente, no Windows pode-se executar o binário do Windows que não possui dependências.

Outros contadores ▲

Se cloc não atender às suas necessidades, aqui estão outros contadores disponíveis gratuitamente a serem considerados:

• local
• gcloc
• gocloc
• Oh contagem
• scc
• sclc
• Contagem SLOC
• Sonar
• Tokei
• Contagem de código unificado

Outras referências:

• Diretório de ferramentas de contagem de código do QSM.
• A entrada da Wikipedia para contagens de linhas de código-fonte.

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

Embora cloc não precise de módulos Perl fora daqueles encontrados na distribuição padrão, cloc depende de alguns módulos externos. O código de três desses módulos externos - Regexp::Common, Win32::Autoglob e Algorithm::Diff - está incorporado no cloc. Um quarto módulo, Digest::MD5, é usado somente se estiver disponível. Se cloc encontrar Regexp::Common ou Algorithm::Diff instalados localmente, ele usará essas instalações. Caso contrário, cloc instalará as partes de Regexp::Common e/ou Algorithm:Diff necessárias nos diretórios temporários que são criados no início de uma execução de cloc e removidos quando a execução for concluída. O código necessário de Regexp::Common v2.120 e Algorithm::Diff v1.1902 estão incorporados no código-fonte cloc (consulte as sub-rotinas Install_Regexp_Common() e Install_Algorithm_Diff() ). Apenas três linhas são necessárias no Win32::Autoglob e estas são incluídas diretamente no cloc.

Além disso, cloc usará Digest::MD5 para validar a exclusividade entre arquivos de entrada de tamanhos iguais se Digest::MD5 estiver instalado localmente.

Uma opção de processamento paralelo, --processes= N , foi introduzida com o cloc versão 1.76 para permitir execuções mais rápidas em máquinas multi-core. Porém, para utilizá-lo é necessário ter o módulo Parallel::ForkManager instalado. Este módulo não funciona de forma confiável no Windows, portanto o processamento paralelo só funcionará em sistemas operacionais do tipo Unix.

O binário do Windows é criado em um computador que possui Regexp::Common e Digest::MD5 instalados localmente.

Construindo um executável do Windows ▲

Crie seu próprio executável

A opção mais robusta para criar um executável de cloc no Windows é usar o Perl Development Kit do ActiveState. Ele inclui um utilitário, perlapp , que pode construir binários independentes de código-fonte Perl para Windows, Mac e Linux.

perl2exe também resolverá o problema. Se você tiver perl2exe , modifique as linhas 84-87 no código-fonte cloc para uma pequena modificação de código necessária para tornar um cloc Windows executável.

Caso contrário, para construir um executável do Windows com pp de PAR::Packer , primeiro instale uma distribuição Perl baseada em Windows (por exemplo Strawberry Perl ou ActivePerl) seguindo suas instruções. Em seguida, abra um prompt de comando, também conhecido como janela DOS e instale o módulo PAR::Packer. Por fim, invoque o comando pp recém-instalado com o código-fonte cloc para criar um arquivo .exe :

 C:> cpan -i Digest::MD5
C:> cpan -i Regexp::Common
C:> cpan -i Algoritmo::Diff
C:> cpan -i PAR::Packer
C:> cpan -i Win32::LongPath
C:> pp -M Win32::LongPath -M Encode::Unicode -M Digest::MD5 -c -x -o cloc-2.02.exe cloc-2.02.pl

Uma variação das instruções acima é que se você instalou a versão portátil do Strawberry Perl, você precisará executar portableshell.bat primeiro para configurar seu ambiente corretamente.

O executável do Windows na seção Releases, cloc-2.02.exe , foi construído em um computador Windows 10 de 64 bits usando Strawberry Perl 5.30.2 e PAR::Packer para construir o .exe .

O executável do Windows é seguro para execução? Contém malware?

Idealmente, ninguém precisaria do executável do Windows porque eles têm um interpretador Perl instalado em suas máquinas e podem executar o arquivo fonte cloc. No entanto, em máquinas corporativas Windows gerenciadas centralmente, isso pode ser difícil ou impossível.

O executável do Windows distribuído com cloc é fornecido como o melhor esforço de um .exe livre de vírus e malware. Recomendamos que você execute seus próprios antivírus no executável e também verifique sites como https://www.virustotal.com/ . As entradas para versões recentes são:

cloc-2.02-winget.exe: (inclui PR 850 para permitir a execução a partir de um link simbólico no 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/detecção

cloc-1.74_x86.exe: https://www.virustotal.com/#/file/b73dece71f6d3199d90d55db53a588e1393c8dbf84231a7e1be2ce3c5a0ec75b/detection

cloc 1.72 exe: https://www.virustotal.com/en/url/8fd2af5cd972f648d7a2d7917bc202492012484c3a6f0b48c8fd60a8d395c98c/análise/

cloc 1.70 exe: https://www.virustotal.com/en/url/63edef209099a93aa0be1a220dc7c4c7ed045064d801e6d5daa84ee624fc0b4a/análise/

cloc 1.68 exe: https://www.virustotal.com/en/file/c484fc58615fc3b0d5569b9063ec1532980281c3155e4a19099b11ef1c24443b/análise/

cloc 1.66 exe: https://www.virustotal.com/en/file/54d6662e59b04be793dd10fa5e5edf7747cf0c0cc32f71eb67a3cf8e7a171d81/análise/1453601367/

Por que o executável do Windows é tão grande?

Os executáveis ​​do Windows das versões cloc 1.60 e anteriores, criados com perl2exe conforme mencionado acima, têm cerca de 1,6 MB, enquanto as versões 1.62 e 1.54, criadas com PAR::Packer , têm 11 MB. A versão 1.66, construída com uma versão mais recente do PAR::Packer , tem cerca de 5,5 MB. Por que os executáveis PAR::Packer são muito maiores do que aqueles criados com perl2exe? Minha teoria é que perl2exe usa uma lógica de poda de árvore mais inteligente que PAR::Packer , mas isso é pura especulação.

Uso Básico ▲

cloc é um programa de linha de comando que usa nomes de arquivos, diretórios e/ou arquivos como entradas. Aqui está um exemplo de execução de cloc na distribuição de origem Perl v5.22.0:

 prompt> cloc perl-5.22.0.tar.gz
    5605 arquivos de texto.
    5386 arquivos exclusivos.
    2.176 arquivos ignorados.

https://github.com/AlDanial/cloc v 1,65 T = 25,49 s (134,7 arquivos/s, 51.980,3 linhas/s)
-------------------------------------------------- ---------------------------------
Código de comentário em branco dos arquivos de idioma
-------------------------------------------------- ---------------------------------
Perl 2892 136396 184362 536445
C 130 24676 33684 155648
Cabeçalho C/C++ 148 9766 16569 147858
Concha Bourne 112 4044 6796 42668
Pascal 8 458 1603 8592
XML33 142 0 2410
YAML 49 20 15 2078
C++10 313 277 2033
fazer 4 426 488 1986
Prólogo 12 438 2 1146
JSON 14 1 0 1037
sim 1 85 76 998
Arquivo de mensagens do Windows 1 102 11 489
Lote DOS 14 92 41 389
Arquivo de recursos do Windows 3 10 0 85
D 1 5 7 8
Lisp 2 0 3 4
-------------------------------------------------- ---------------------------------
SOMA: 3434 176974 243934 903874
-------------------------------------------------- ---------------------------------

Para executar cloc em computadores Windows, abra uma janela de comando (também conhecida como DOS) e invoque cloc.exe a partir da linha de comando. Como alternativa, experimente ClocViewer, o wrapper GUI em torno do cloc encontrado em https://github.com/Roemer/ClocViewer.

Consulte também https://github.com/jmensch1/codeflower para uma representação gráfica dos resultados do cloc.

Opções ▲

 prompt> cloc --help

Uso: cloc [opções]  |   | 

 Contar ou calcular diferenças de linhas físicas de código-fonte no
 determinados arquivos (podem ser arquivos como tarballs compactados ou arquivos zip,
 ou git commit hashes ou nomes de ramificações) e/ou recursivamente abaixo do
 determinados diretórios.

 Opções de entrada
   --extract-with= Esta opção só é necessária se o cloc não for possível
                             para descobrir como extrair o conteúdo de
                             o(s) arquivo(s) de entrada por si só.
                             Use  para extrair arquivos binários (por exemplo:
                             .tar.gz, .zip, .Z). Use o literal '>FILE<' como
                             um substituto para o(s) arquivo(s) real(is) a ser(em)
                             extraído. Por exemplo, para contar linhas de código
                             nos arquivos de entrada
                                gcc-4.2.tar.gz perl-5.8.8.tar.gz
                             no uso do Unix
                               --extract-with='gzip -dc >ARQUIVO< | alcatrão xf -'
                             ou, se você tiver GNU tar,
                               --extract-with='tar zxf >ARQUIVO<'
                             e no uso do Windows, por exemplo:
                               --extract-with=""c:Arquivos de ProgramasWinZipWinZip32.exe" -e -o >ARQUIVO< ."
                             (se o WinZip estiver instalado lá).
   --list-file= Leva a lista de nomes de arquivos e/ou diretórios para
                             processo de , que possui um arquivo/diretório
                             nome por linha. Apenas as correspondências exatas são contadas;
                             nomes de caminhos relativos serão resolvidos a partir de
                             o diretório onde cloc é invocado. Definir 
                             to - para ler nomes de arquivos de um canal STDIN.
                             Veja também --exclude-list-file.
   --diff-list-file= Pegue os pares de nomes de arquivos a serem comparados
                             , cujo formato corresponde à saída de
                             --diff-alinhamento. (Execute com essa opção para
                             veja um exemplo.) O identificador de idioma no
                             o final de cada linha é ignorado. Isso permite --diff
                             modo e ignora a lógica de alinhamento de pares de arquivos.
   --vcs= Invoque uma chamada de sistema para  para obter uma lista de
                             arquivos para trabalhar. Se  for 'git', então
                             invoque 'git ls-files' para obter uma lista de arquivos e
                             'git submodule status' para obter uma lista de submódulos
                             cujo conteúdo será ignorado. Veja também --git
                             que aceita hashes de commit do git e nomes de ramificações.
                             Se  for 'svn' então invocará 'svn list -R'.
                             O principal benefício é que o cloc irá pular
                             arquivos explicitamente excluídos pela ferramenta de controle de versão
                             em questão, ou seja, aqueles em .gitignore ou têm o
                             svn:ignorar propriedade.
                             Alternativamente,  pode ser qualquer comando do sistema
                             que gera uma lista de arquivos.
                             Nota: cloc deve estar em um diretório que possa ler
                             os arquivos conforme eles são retornados por . relógio vai
                             não baixe arquivos de repositórios remotos.
                             'svn list -R' pode se referir a um repositório remoto
                             para obter nomes de arquivos (e, portanto, pode exigir
                             autenticação para o repositório remoto), mas
                             os próprios arquivos devem ser locais.
                             Definir  como 'auto' seleciona entre 'git'
                             e 'svn' (ou nenhum) dependendo da presença
                             de um subdiretório .git ou .svn abaixo do diretório
                             onde cloc é invocado.
   --unicode Verifica os arquivos binários para ver se eles contêm Unicode
                             texto ASCII expandido. Isso faz com que o desempenho
                             cair visivelmente.

 Opções de processamento
   --autoconf Conta os arquivos .in (conforme processados ​​pelo GNU autoconf) de
                             línguas reconhecidas. Veja também --no-autogen.
   --by-file Relata os resultados para cada arquivo de origem encontrado.
   --by-file-by-lang Relata os resultados para cada arquivo de origem encontrado
                             além de reportar por idioma.
   --config  Lê as opções de linha de comando de  em vez de
                             o local padrão de /home/al/.config/cloc/options.txt.
                             O arquivo deve conter uma opção, junto com
                             argumentos (se houver), por linha. Linhas e linhas em branco
                             começando com '#' são ignorados. Opções dadas em
                             a linha de comando tem prioridade sobre as entradas lidas
                             o arquivo.
   --count-and-diff  
                             Primeiro, execute contagens diretas de código do(s) arquivo(s) de origem
                             de  e  separadamente e, em seguida, execute uma comparação
                             destes. As entradas podem ser pares de arquivos, diretórios,
                             ou arquivos. Se --out ou --report-file for fornecido,
                             três arquivos de saída serão criados, um para cada
                             das duas contagens e uma para a diferença. Veja também
                             --diff, --diff-alignment, --diff-timeout,
                             --ignore-case, --ignore-espaço em branco.
   --diff   Calcula diferenças no código e comentários entre
                             arquivo(s) de origem de  e . As entradas
                             pode ser qualquer combinação de arquivos, diretórios, arquivos,
                             ou git commit hashes. Use --diff-alignment para
                             gerar uma lista mostrando quais pares de arquivos onde
                             comparado. Ao comparar ramificações git, apenas arquivos
                             que foram alterados em qualquer commit são comparados.
                             Veja também --git, --count-and-diff, --diff-alignment,
                             --diff-list-file, --diff-timeout, --ignore-case,
                             --ignore-espaço em branco.
   --diff-timeout  Ignora arquivos que demoram mais de  segundos
                             para processar. O padrão é 10 segundos. Configuração 
                             para 0 permite tempo ilimitado. (Arquivos grandes com muitos
                             linhas repetidas podem causar Algorithm::Diff::sdiff()
                             pode levar horas.) Veja também --timeout.
   --docstring-as-code cloc considera docstrings como comentários, mas isso é
                             nem sempre correto, pois os docstrings representam regulares
                             strings quando elas aparecem no lado direito de uma
                             atribuição ou como argumentos de função. Esta opção
                             força docstrings a serem contados como código.
   --follow-links [somente Unix] Segue links simbólicos para diretórios
                             (links simbólicos para arquivos são sempre seguidos).
                             Veja também --stat.
   --force-lang=[,]
                             Processe todos os arquivos que possuem uma extensão 
                             com o contador do idioma . Para
                             por exemplo, para contar todos os arquivos .f com o
                             Contador Fortran 90 (que espera que os arquivos
                             termine com .f90) em vez do padrão Fortran 77
                             contador, usar
                               --force-lang="Fortran 90,f"
                             Se  for omitido, todos os arquivos serão contados
                             com o contador . Esta opção pode ser
                             especificado várias vezes (mas isso é apenas
                             útil quando  é fornecido todas as vezes).
                             Veja também --script-lang, --lang-no-ext.
   --force-lang-def= Carrega filtros de processamento de linguagem de ,
                             então use esses filtros em vez dos integrados
                             filtros. Nota: idiomas que mapeiam para o mesmo
                             extensão de arquivo (por exemplo:
                             MATLAB/Mathematica/Objective-C/MUMPS/Mercúrio;
                             Pascal/PHP; Lisp/OpenCL; Lisp/Júlia; Perl/Prólogo)
                             serão ignorados, pois exigem
                             processamento que não é expresso em linguagem
                             arquivos de definição. Use --read-lang-def para definir
                             novos filtros de idioma sem substituir os integrados
                             filtros (veja também --write-lang-def,
                             --write-lang-def-incl-dup).
   --git Força as entradas a serem interpretadas como alvos git
                             (confirmar hashes, nomes de ramificações, etc.) se estes
                             não são identificados primeiro como arquivo ou diretório
                             nomes. Esta opção substitui a lógica --vcs=git
                             se isso for dado; em outras palavras, --git obtém seu
                             lista de arquivos para trabalhar diretamente do git usando
                             o hash ou nome da ramificação em vez de from
                             'git ls-arquivos'. Esta opção pode ser usada com
                             --diff para realizar diferenças de contagem de linhas entre o git
                             commits, ou entre um commit git e um arquivo,
                             diretório ou arquivo. Use -v/--verbose para ver
                             o sistema git comanda problemas de cloc.
   --git-diff-rel O mesmo que --git --diff, ou apenas --diff se as entradas
                             são reconhecidos como alvos git. Somente arquivos que
                             que mudaram em qualquer commit são comparados.
   --git-diff-all Estratégia diff do Git nº 2: compare todos os arquivos no
                             repositório entre os dois commits.
   --ignore-whitespace Ignora o espaço em branco horizontal ao comparar arquivos
                             com --diff. Veja também --ignore-case.
   --ignore-case Ignora alterações de maiúsculas e minúsculas no conteúdo do arquivo;
                             considere letras maiúsculas e minúsculas equivalentes
                             ao comparar arquivos com --diff. Veja também
                             --ignore-espaço em branco.
   --ignore-case-ext Ignora maiúsculas e minúsculas das extensões de nome de arquivo. Isto irá
                             causar problemas ao contar alguns idiomas
                             (especificamente, .c e .C estão associados a C e
                             C++; essa opção contaria arquivos .C como C em vez
                             do que C++ em sistemas operacionais *nix). Nome do arquivo
                             a insensibilidade a maiúsculas e minúsculas é sempre verdadeira no Windows.
   --lang-no-ext= Contar arquivos sem extensões usando o 
                             contador. Esta opção substitui a lógica interna
                             para arquivos sem extensões (onde tais arquivos
                             são verificados em linguagens de script conhecidas
                             examinando a primeira linha para #!). Veja também
                             --force-lang, --script-lang.
   --max-file-size= Ignora arquivos maiores que  megabytes quando
                             percorrendo diretórios. Por padrão, =100.
                             o requisito de memória do cloc é cerca de vinte vezes
                             maior que o maior arquivo, então execute com
                             arquivos maiores que 100 MB em um computador com menos
                             mais de 2 GB de memória causará problemas.
                             Nota: esta verificação não se aplica a arquivos
                             passado explicitamente como argumentos de linha de comando.
   --no-autogen[=list] Ignora arquivos gerados por sistemas de produção de código
                             como o autoconf GNU. Para ver uma lista desses arquivos
                             (então saia), execute com --no-autogen list
                             Veja também --autoconf.
   --original-dir [Eficaz apenas em combinação com
                             --strip-comments] Escreva os arquivos removidos
                             para o mesmo diretório dos arquivos originais.
   --read-binary-files Processa arquivos binários além de arquivos de texto.
                             Isso geralmente é uma má ideia e só deve ser
                             tentada com arquivos de texto que incorporaram
                             dados binários.
   --read-lang-def= Carregar novos filtros de processamento de linguagem de 
                             e mesclá-los com aqueles já conhecidos por cloc.
                             Se  define um idioma que o cloc já conhece
                             sobre, a definição de cloc terá precedência.
                             Use --force-lang-def para substituir o cloc
                             definições (veja também --write-lang-def,
                             --write-lang-def-incl-dup).
   --script-lang=, Processa todos os arquivos que invocam  como um #!
                             linguagem de script com o contador de idioma
                             . Por exemplo, arquivos que começam com
                                #!/usr/local/bin/perl5.8.8
                             será contado com o contador Perl usando
                                --script-lang=Perl,perl5.8.8
                             O nome do idioma não diferencia maiúsculas de minúsculas, mas o
                             nome do executável da linguagem de script, ,
                             deve ter o caso certo. Esta opção pode ser
                             especificado várias vezes. Veja também --force-lang,
                             --lang-no-ext.
   --sdir= Use  como diretório temporário em vez de
                             deixando File::Temp escolher o local. Arquivos
                             gravados neste local não são removidos em
                             o final da execução (como acontece com File::Temp).
   --skip-uniqueness Ignora a verificação de exclusividade do arquivo. Isso vai dar
                             um aumento de desempenho às custas da contagem
                             arquivos com conteúdo idêntico várias vezes
                             (se tais duplicatas existirem).
   --stat Alguns sistemas de arquivos (AFS, CD-ROM, FAT, HPFS, SMB)
                             não tenho contagens de diretório 'nlink' que correspondam
                             o número de seus subdiretórios. Consequentemente
                             cloc pode subcontar ou pular completamente o
                             conteúdo de tais sistemas de arquivos. Esta mudança força
                             File::Find to stat diretórios para obter o
                             contagem correta. A velocidade de pesquisa de arquivos diminuirá.
                             Veja também --follow-links.
   --stdin-name= Dê um nome de arquivo para usar para determinar o idioma
                             para entrada padrão. (Use - como o nome de entrada para
                             receber código-fonte via STDIN.)
   --strip-comments= Para cada arquivo processado, grave no atual
                             diretório uma versão do arquivo que tem em branco
                             e linhas comentadas removidas (comentários in-line
                             persistir). O nome de cada arquivo removido é o
                             nome do arquivo original com . anexado a ele.
                             Ele é gravado no diretório atual, a menos que
                             --original-dir está ativado.
   --strip-str-comments Substitua marcadores de comentários incorporados em strings por
                             'xx'. Isso tenta contornar uma limitação
                             em Regexp::Common::Comment onde estão os marcadores de comentários
                             incorporados em strings são vistos como comentários reais
                             marcadores e não strings, muitas vezes resultando em um
                             'Limite de recursão de subexpressão regular complexa'
                             aviso e contagens incorretas. Existem dois
                             desvantagens de usar esta opção: 1/contagem de códigos
                             queda de desempenho e 2/código gerado com
                             --strip-comments conterá strings diferentes
                             onde comentários incorporados são encontrados.
   --sum-reports Argumentos de entrada são arquivos de relatório anteriores
                             criado com a opção --report-file em forma simples
                             formato (por exemplo, não JSON, YAML, XML ou SQL).
                             Faz um conjunto cumulativo de resultados contendo o
                             soma dos dados dos arquivos de relatório individuais.
   --timeout  Ignora arquivos que demoram mais de  segundos
                             para processar em qualquer um dos estágios de filtro da linguagem.
                             O número máximo padrão de segundos gastos em um
                             estágio de filtro é o número de linhas no arquivo
                             dividido por mil. Definir  como 0 permite
                             tempo ilimitado. Veja também --diff-timeout.
   --processes=NUM [Disponível apenas em sistemas com versão recente
                             do módulo Parallel::ForkManager. Não
                             disponível no Windows.] Define o número máximo de
                             núcleos que o cloc usa. O valor padrão de 0
                             desativa o multiprocessamento.
   --unix Substitui a detecção automática do sistema operacional
                             lógica e executado no modo UNIX. Veja também
                             --windows, --show-os.
   --use-sloccount Se SLOCCount estiver instalado, use seu compilado
                             executáveis ​​c_count, java_count, pascal_count,
                             php_count e xml_count em vez de cloc's
                             contadores. Os contadores compilados do SLOCCount são
                             substancialmente mais rápido que o do cloc e pode dar
                             uma melhoria de desempenho ao contar projetos
                             com arquivos grandes. No entanto, estes cloc-específicos
                             recursos não estarão disponíveis: --diff,
                             --count-and-diff, --strip-comments, --unicode.
   --windows Substitui a detecção automática do sistema operacional
                             lógica e executado no modo Microsoft Windows.
                             Veja também --unix, --show-os.

 Opções de filtro
   --include-content= Conta apenas arquivos contendo texto que corresponda ao
                             dada expressão regular.
   --exclude-content= Exclui arquivos contendo texto que corresponda ao determinado
                             expressão regular.
   --exclude-dir=[,D2,] Exclua os diretórios separados por vírgula fornecidos
                             D1, D2, D3, etc., sejam digitalizados. Para
                             exemplo --exclude-dir=.cache,test irá pular
                             todos os arquivos e subdiretórios que possuem /.cache/
                             ou /test/ como seu diretório pai.
                             Diretórios chamados .bzr, .cvs, .hg, .git, .svn,
                             e .snapshot são sempre excluídos.
                             Esta opção só funciona com diretório individual
                             nomes, portanto, incluir separadores de caminho de arquivo não é
                             permitido. Use --fullpath e --not-match-d=
                             para fornecer um regex correspondente a vários subdiretórios.
   --exclude-ext=[,[...]]
                             Não conte os arquivos com o nome de arquivo fornecido
                             extensões.
   --exclude-lang=[,L2[...]]
                             Exclua os idiomas separados por vírgula fornecidos
                             L1, L2, L3, etc., sejam contados.
   --exclude-list-file= Ignora arquivos e/ou diretórios cujos nomes
                             aparecem em .  deve ter um arquivo
                             nome por linha. Apenas as correspondências exatas são ignoradas;
                             nomes de caminhos relativos serão resolvidos a partir de
                             o diretório onde cloc é invocado.
                             Veja também --list-file.
   --fullpath Modifica o comportamento de --match-f, --not-match-f,
                             e --not-match-d para incluir o caminho do arquivo
                             no regex, não apenas no nome base do arquivo.
                             (Isso não expande cada arquivo para incluir seu
                             caminho absoluto, em vez disso ele usa tanto de
                             o caminho que é passado para cloc.)
                             Nota: --match-d sempre olha o completo
                             path e, portanto, não é afetado por --fullpath.
   --include-ext=[,ext2[...]]
                             Conte apenas os idiomas que possuem a vírgula fornecida
                             extensões de arquivo separadas. Use --show-ext para
                             veja as extensões reconhecidas.
   --include-lang=[,L2[...]]
                             Conte apenas os idiomas separados por vírgula
                             L1, L2, L3, etc. Use --show-lang para ver
                             a lista de idiomas reconhecidos.
   --match-d= Conta apenas arquivos em diretórios que correspondam ao Perl
                             expressão regular. Por exemplo
                               --match-d='/(src|incluir)/'
                             conta apenas arquivos em diretórios contendo
                             /src/ ou /include/. Ao contrário de --not-match-d,
                             --match-f e --not-match-f, --match-d sempre
                             compara o caminho totalmente qualificado com o
                             expressão regular.
   --not-match-d= Conta todos os arquivos, exceto aqueles nos diretórios
                             correspondendo ao regex Perl. Apenas o rastro
                             o nome do diretório é comparado, por exemplo, quando
                             contando em /usr/local/lib, apenas 'lib' é
                             em comparação com o regex.
                             Adicione --fullpath para comparar os diretórios pais com
                             a regex.
                             Não inclua separadores de caminho de arquivo no
                             início ou fim da regex.
   --match-f= Conta apenas arquivos cujos nomes de base correspondem ao Perl
                             expressão regular. Por exemplo
                               --match-f='^[Ww]idget'
                             conta apenas arquivos que começam com Widget ou widget.
                             Adicione --fullpath para incluir diretórios pais
                             no regex em vez de apenas no nome base.
   --not-match-f= Conta todos os arquivos, exceto aqueles cujos nomes de base
                             corresponda ao regex Perl. Adicione --fullpath para incluir
                             diretórios pais no regex em vez de apenas
                             o nome base.
   --skip-archive= Ignora arquivos que terminam com o Perl regular fornecido
                             expressão. Por exemplo, se for dado
                               --skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
                             o código irá pular os arquivos que terminam com .zip,
                             .tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz e
                             .tar.7z.
   --skip-win-hidden No Windows, ignore os arquivos ocultos.

 Opções de depuração
   --categorized= Salva tamanhos de arquivo em bytes, idiomas identificados
                             e nomes de arquivos categorizados para .
   --CONTED =  Salve nomes de arquivos de origem processados ​​para .
   --DIFF-ALINGMENT =  Escreva para  Uma lista de arquivos e pares de arquivos
                             mostrando quais arquivos foram adicionados, removidos e/ou
                             comparado durante uma corrida com - -dififf. Este interruptor
                             força o modo - -DIFF ligado.
   --explain =  Imprima os filtros usados ​​para remover comentários para
                             idioma  e saída. Em alguns casos, o
                             filtros se referem a sub -rotinas perl e não
                             expressões regulares. Um exame do
                             O código -fonte pode ser necessário para uma explicação adicional.
   -Help Imprima essas informações e saída de uso.
   --Found =  Salve os nomes de cada arquivo encontrado em .
   --ignado =  Salvar nomes de arquivos ignorados e o motivo pelo qual eles
                             foram ignorados para .
   -Os palestrantes de filtro imprimem o código-fonte processado antes e depois
                             Cada filtro é aplicado.
   --Show-ext [= ] Imprima informações sobre todos conhecidos (ou apenas o
                             dado) Extensões de arquivo e saída.
   --Show-lang [= ] Imprimir informações sobre todos conhecidos (ou apenas o
                             dado) idiomas e saída.
   -Show-OS Imprima o valor do modo de sistema operacional
                             e saída. Veja também --unix, - -Windows.
   -v [= ] Switch detalhado (valor numérico opcional).
   -verbose [= ] forma longa de -v.
   -Imprima a versão deste programa e saia.
   --write-lang-DEF =  grava para  Os filtros de processamento de idiomas
                             então sai. Útil como um primeiro passo para criar
                             Definições de linguagem personalizadas. Nota: idiomas que
                             mapear a mesma extensão de arquivo será excluída.
                             (Veja também-Force-lang-Def, --Read-Lang-Def).
   --write-lang-Def-Incl-DUP = 
                             O mesmo que--writ-lang-def, mas inclui duplicado
                             extensões. Isso gera uma linguagem problemática
                             arquivo de definição porque o cloc se recusará a usar
                             até que as duplicatas sejam removidas.

 Opções de saída
   --3 Imprima saída da linguagem de terceira geração.
                             (Esta opção pode fazer com que o soma do relatório falhe
                             Se alguns relatórios foram produzidos com esta opção
                             enquanto outros foram produzidos sem ele.)
   -por cento x em vez de comentário e contagem de linhas em branco, mostre
                             esses valores como porcentagens com base no valor
                             de x no denominador:
                                X = 'c' -> # linhas de código
                                X = 'cm' -> # linhas de código + comentários
                                X = 'cb' -> # linhas de código + em branco
                                X = 'cmb' -> # linhas de código + comentários + espaços em branco
                             Por exemplo, se estiver usando o método 'c' e seu código
                             tem duas vezes mais linhas de comentários que linhas
                             de código, o valor na coluna de comentários irá
                             ser 200%. A coluna de código continua sendo uma contagem de linhas.
   --CSV Escreva os resultados como valores separados por vírgula.
   --CSV-Delimiter =  Use o caractere  como o delimitador para vírgula
                             arquivos separados em vez de ,. Este interruptor forças - -CSV a serem ativadas.
   --File-coding =  gravar arquivos de saída usando a codificação  em vez de
                             o ASCII padrão ( = 'UTF-7'). Exemplos: 'UTF-16',
                             'Euc-kr', 'ISO-8859-16'. As codificações conhecidas podem ser
                             impresso com
                               Perl -Mencode -e 'Print Join (" n", Encodes-> Encodings (": All")), " n"' '
   -Hide-rate não mostra taxas de processamento de linha e arquivos no
                             Cabeçalho de saída. Isso torna a saída determinística.
   --json escreva os resultados como notação de objeto JavaScript
                             (JSON) Saída formatada.
   -MD Escreva os resultados como texto formatado em marcação.
   --out =  Sinônimo para --Report-File = .
   --Progress-rate =  Mostrar atualização de progresso após os arquivos 
                             processado (padrão  = 100). Definir  para 0 para
                             suprimir a saída de progresso (útil ao redirecionar
                             saída para stdout).
   --quiet suprime todas as mensagens de informação, exceto
                             o relatório final.
   --Report-File =  Escreva os resultados para  em vez de stdout.
   --SQL =  Escreva resultados como SQL Criar e inserir instruções
                             que pode ser lido por um programa de banco de dados, como
                             Sqlite. Se  for -, a saída será enviada para o stdout.
   --SQL-Appender Appender SQL Inserir declarações ao arquivo especificado
                             por - -sql e não gera criação de tabela
                             declarações. Somente válido com a opção - -SQL.
   --sql-project =  use  como o identificador do projeto para o
                             execução atual. Somente válido com a opção - -SQL.
   --SQL-STYLE =  Escreva declarações SQL no estilo dado em vez disso
                             do formato padrão SQLITE padrão. Os estilos incluem
                             'Oracle' e 'nomeado_columns'.
   -Soma-um para relatórios de texto sem formatação, mostre a soma: linha de saída
                             mesmo que apenas um arquivo de entrada seja processado.
   --xml Escreva os resultados em XML.
   --xsl =  Referência  como uma folha de estilo XSL dentro
                             a saída XML. Se  é 1 (numérico um),
                             escreve uma folha de estilo padrão, cloc.xsl (ou
                             cloc-diff.xsl se--diff também é fornecido).
                             Este interruptor força --xml ligado.
   -Yaml Escreva os resultados em YAML.

Idiomas reconhecidos ▲

 Prompt> Cloc-Show-Lang

ABAP (ABAP)
ActionScript (AS)
ADA (ADA, ADB, ADS, PAD)
Adso/idsm (adso)
AGDA (AGDA, LAGDA)
Amplo (amplo, dofile, startup)
Ansprolog (LP)
Ant (Build.xml, Built.xml)
Gramática Antlr (G, G4)
Classe de ápice (CLS)
Gatilho do ápice (gatilho)
APL (APL, APLA, APLC, APLF, APLI, APLN, APLO, DIALOG, DYAPP, MIPAGE)
AppleScript (AppleScript)
Esboço Arduino (Ino)
Arkts (ETs)
Arturo (arte)
ASCIIDOC (ADOC, ASCIIDOC)
ASP (ASA, ASHX, ASP, AXD)
ASP.NET (Asax, ASCX, ASMX, ASPX, Master, Sitemap, Webinfo)
Aspecto (AJ)
Assembléia (A51, ASM, Nasm, S, S)
Astro (Astro)
Assíntota (asy)
Autohotkey (ahk, ahkl)
Awk (Auk, Awk, Gawk, Mawk, Nawk)
Bazel (construção)
Orquestração BizTalk (ODX)
Oleoduto BizTalk (BTP)
Blade (Blade, Blade.php)
Bourne novamente Shell (Bash)
Bourne Shell (SH)
BrightScript (BRS)
construtor (xml.builder)
C (C, Cats, CE, 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)
Cabeçalho C/C ++ (H, H, HH, HPP, HXX)
Cairo (Cairo)
Script de construção de bolo (bolo)
Carbono (carbono)
CCS (CCS)
Capela (CHPL)
Circom (Circom)
Limpo (DCL, ICL)
Clojure (bota, 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)
Cacau 5 (C5, cocoa5, cocoa5server, cpkg5)
CoffeeScript (_coffee, bolofile, cjsx, café, gelado)
Coldfusion (CFM, CFML)
Coldfusion cfScript (CFC)
Gramática de restrição (CG3, RLX)
Containerfile (contêinerfile)
Coq (v)
Cristal (cr)
Cson (cson)
CSS (CSS)
CSV (CSV)
Pepino (recurso)
CUDA (CU, CUH)
Cython (PXD, PXI, Pyx)
D (D)
Dafny (DFY)
Dal (da)
Dardo (dardo)
Formulário Delphi (DFM)
Denizenscript (DSC)
Derw (Derw)
Dhall (Dhall)
Dieta (dt)
diff (diff, patch)
Dita (Dita)
Dockerfile (Dockerfile, Dockerfile)
Linguagem de extensão de portas (DXL)
Dos lote (morcego, morcego, btm, btm, cmd, cmd)
Babar (drl)
DTD (DTD)
DTRACE (D)
ECPP (ECPP)
EEX (EEX)
EJS (EJS)
Elixir (ex, exs)
Elm (Elm)
Cristal incorporado (ECR)
Erb (erb, erb)
Erlang (App.src, EmakeFile, Erl, HRL, Rebar.config, Rebar.config.lock, Rebar.lock, XRL, YRL)
Espere (exp)
F# (fsi, fs, fs)
Script f# (fsx)
Erva -doce (FNL)
Linguagem do Estado Finito (FSL, JSSM)
Casca de peixe (peixe)
Flatbuffers (FBS)
Foco (Focexec)
Adiante (4º, e4, f83, fb, adiante, fpm, fr, frt, ft, fth, rx, fs, f, para)
Fortran 77 (f, f77, f77, para, ftn, ftn, pfo, f, para)
Fortran 90 (F90, F90)
Fortran 95 (F95, F95)
Modelo Freemarker (FTL)
Futhark (FUT)
FXML (FXML)
GDScript (GD)
GENCAT NLS (MSG)
Glade (Glade, Ui)
Brilho (brilho)
Glimmer JavaScript (GJS)
GLIMERTSCRIPT (GTS)
GLSL (Comp, FP, Frag, FRG, FSH, FSHADER, GEO, GEOM, GLSL, GLSLV, GSHADER, TESC, TESE, VERT, VRX, VSH, VSHADER)
Vá (vá, ʕ◔ϖ◔ʔ)
Godot Resource (Tres)
Cena 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)
Guidão (guidão, HBS)
Porto (HB)
Hare (ha)
Haskell (HS, HSC, LHS)
Haxe (HX, HXSL)
HCL (HCl, Nomad, TF, TFVARS)
HLSL (CG, CGINC, FXH, HLSL, HLSLI, SHADER)
Holyc (HC)
Hoon (Hoon)
Html (htm, html, html.hl, xht)
HTML EEX (Heex)
IDL (DLM, IDL, Pro)
Idris (IDR)
Igor Pro (IPF)
IMBA (IMBA)
Ini (Buildozer.spec, EditorConfig, Ini, Lektorproject, 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)
Javaserver Faces (JSF)
JCL (JCL)
Jinja Modelo (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)
Magro (hlean, magro)
Lem (LEM)
Menos (menos)
Lex (L, Lex)
LFE (LFE)
Script de ligação (LD)
líquido (líquido)
Lisp (asd, el, lisp, lsp, cl, jl)
Idris alfabetizado (Lidr)
LiveLink OSCRCRCT (OSCRIPT)
LLVM IR (LL)
Logos (x, xm)
LogTalk (LGT, LogTalk)
Lua (lua, nse, p8, pd_lua, rbxs, wlua)
Luau (luau)
M4 (AC, M4)
Make (AM, GnumakeFile, GnumakeFile, Makefile, Makefile, Mk)
Mako (Mako, Mao)
Markdown (contents.lr, Markdown, MD, Mdown, MDWN, MDX, MKD, MKDN, MKDOWN, RONN, PODA DE TRABALHO)
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)
Script msbuild (btproj, csproj, msbuild, vcproj, wdproj, wixproj)
Caxumba (MPS, M)
Bigode (bigode)
Mxml (mxml)
Script Nant (construção)
NASTRAN DMAP (DMAP)
Nemerle (n)
NetLogo (NLOGO, NLS)
Níquel (NCL)
Nim (Nim, Nim.CFG, Nimble, Nimrod, Nims)
Nix (nix)
Nunjucks (NJK)
Objective-C (M)
Objective-C ++ (mm)
OCAML (Eliom, Eliomi, ML, ML4, MLI, MLL, MLY)
Odin (Odin)
OpenCl (CL)
OpenScad (SCAD)
Oracle Forms (FMT)
Oracle PL/SQL (BOD, FNC, PRC, SPC, TRG)
Oracle Reports (REX)
P4 (P4)
Pascal (DPR, LPR, PAS, Pascal)
Pascal/peão (P)
Pascal/Puppet (PP)
Patran Command Language (PCL, SES)
Peão (peão, PWN)
PEG (PEG)
PEG.JS (PEGJS)
Peggy (Peggy)
Perl (ACK, AL, CPANFILE, makefile.pl, perl, ph, PL, PLX, PM, PSGI, Rexfile, PL, P6)
PEST (PEST)
PHP (AW, CTP, PHAKEFILE, PHP, PHP3, PHP4, PHP5, PHP_CS, PHP_CS.DIST, PHPS, PHPT, PHTML)
PHP/Pascal/Fortran/Pawn (Inc)
Porco latino (porco)
Pl/i (pl1)
Pl/m (iluminado, plm)
Plantuml (IUML, Plantuml, Pu, Puml, WSD)
PO FILE (PO)
Pônei (pônei)
PowerBuilder (PBT, SRA, SRF, SRM, SRS, SRU, SRW)
PowerShell (PS1, PSD1, PSM1)
Esquema PRISMA (PRISMA)
Processamento (PDE)
ProGuard (Pro)
Prolog (P, Prolog, Yap, PL, P6, Pro)
Propriedades (propriedades)
Buffers de protocolo (proto)
PRQL (PRQL)
Pug (jade, pug)
PureScript (Pur Purch)
Python (buck, build.bazel, gclient, gyp, cigano, lmi, py, py3, pyde, pyi, pyp, pyt, pyw, sconscript, sconstruct, snakefile, tac, espaço de trabalho, wscript, wsgi, xpy)
QML (QBS, QML)
Qt (UI)
Linguista QT (TS)
Projeto 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)
RazãoMl (re, rei)
Rescript (res, resi)
reestruturadotext (descanso, descanso.txt, rst, rst.txt)
Rexx (pprx, rexx)
Anel (rform, rh, anel)
Rmd (rmd)
RobotFramework (robô)
Ruby (Avaliações, Berksfile, BrewFile, Builder, BuildFile, Capfile, Dangerfile, Delivery, Olhos, Fastfile, Gemfile, GemFile.lock, GemSpec, God, MoldFile, Irbrc, Jarfile, Jbuilder, Mavenfile, Mpec, Podfile, Podfile, PODFIL PuppetFile, Rabl, Rake, RB, Rbuild, RBW, RBX, RU, Snapfile, Thor, Thorfile, VagrantFile, Watchr)
Ruby html (rhtml)
Ferrugem (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)
Habilidade (IL)
Habilidade ++ (ILS)
Fatia (gelo)
Slim (Slim)
Slint (Slint)
Smalltalk (ST, CS)
Smarty (Smarty, TPL)
Snakemake (Regras, SMK)
Softbridge Basic (sbl, sbl)
Solidez (SOL)
Sparforte (SP)
Specman E (e)
SQL (CQL, MYSQL, PSQL, SQL, SQL, TAB, UDF, VIW)
Data SQL (data.sql)
Procedimento armazenado SQL (spc.sql, spoc.sql, sproc.sql, udf.sql)
Esquilo (porca)
ML padrão (Fun, Sig, SML)
Starlark (Bazel, BZL)
STATA (ADO, DO, DO, DOH, IHLP, MATA, MATAH, STHLP)
Stylus (Styl)
Sugarss (SSS)
Esbelto (esbelto)
SVG (SVG, SVG)
Swift (Swift)
Swig (i)
TableGen (TD)
Tcl/tk (itk, tcl, tk)
Teal (cerceta)
Teamcenter conheceu (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)
Brecha (economia)
Informações do Arquivo do Projeto Titan (TPD)
Folha de estilo de titânio (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)
Twig (Twig)
TypeScript (MTS, TSX, TS)
Typst (Typ)
Umka (um)
UNIDADE-PREFAB (MAT, Prefab)
Vala (Vala)
Cabeçalho de Vala (VAPI)
VB para aplicações (VBA, VBA)
Linguagem de modelo de velocidade (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)
Visual Basic Script (VBS, VBS)
Visual Fox Pro (SCA, SCA)
Solução do Visual Studio (SLN)
Componente visualforce (componente)
Página Visualforce (página)
Componente Vuejs (Vue)
Vyper (VY)
Descrição dos Serviços da Web (WSDL)
WebAssembly (Wast, Wat)
WGSL (WGSL)
Arquivo de mensagem do Windows (MC)
Definição do módulo Windows (def)
Arquivo de recursos do Windows (RC, RC2)
Wix inclui (wxi)
WIX Source (WXS)
Localização de String Wix (WXL)
WXML (WXML)
WXSS (WXSS)
X ++ (xpo)
Xaml (xaml)
Xbase (PRG, PRW)
Cabeçalho Xbase (CH)
Xhtml (xhtml)
Xmi (xmi, xmi)
XML (adml, admx, ant, app.config, axml, builds, ccproj, ccxml, classpath, clixml, cproject, cscfg, csdef, csl, ct, depproj, ditamap, ditaval, dll.config, dotsettings, filters, fsproj, gmx, grxml, iml, ivy, jelly, jsproj, kml, launch, mdpolicy, mjml, natvis, ndproj, nproj, nuget.config, nuspec, odd, osm, packages.config, pkgproj, plist, proj, project, props, PS1XML, PSC1, PT, RDF, RESX, RSS, SCXML, Settings.StyCOP, SFPROJ, SHPROJ, SRDF, Storyboard, STHEME, SUBLIME-SNIPET, TMSNIPT, TMCOMAND, TML, TMLANGEAGE, TMMPETETES, TMMET, TMNIPT, TMMIPT, TMMET, vcxproj, vsixmanifest, vssettings, vstemplate, vxml, web.config, web.debug.config, web.release.config, wsf, x3d, xacro, xib, xlf, xliff, XML, xml, xml.dist, xproj, xspec, xul, zcml)
XQuery (xq, xql, xqm, xquery, xqy)
XSD (XSD, XSD)
XSLT (XSL, XSL, XSLT, XSLT)
XTEND (XTEND)
yacc (y, yacc)
YAML (CLANG-FORMAT, CLANG-TIDY, GEMRC, GLIDE.LOCK, MIR, REEK, RVIZ, SUBLIME-SYNTAX, SINTAX, YAML, YAML-TMLANGUE, YML, YML.MYSQL)
Yang (Yang)
Zig (ZIG)
ZSH (ZSH)

A lista acima pode ser personalizada lendo as definições de idiomas de um arquivo com as opções --read-lang-def ou --force-lang-def .

Essas extensões de arquivo são mapeadas para vários idiomas:

• Os arquivos cl podem ser Lisp ou OpenCl
• Os arquivos cls podem ser a classe Visual Basic, Tex ou Apex
• Os arquivos cs podem ser C# ou SmallTalk
• Os arquivos d podem ser d ou dtrace
• Os arquivos f podem ser fortran 77 ou adiante
• Os arquivos fnc podem ser Oracle PL ou SQL
• for arquivos pode ser fortran 77 ou adiante
• Os arquivos fs podem ser f# ou adiante
• Arquivos inc podem ser PHP ou Pascal
• Os arquivos itk podem ser TCL ou TK
• Os arquivos jl podem ser Lisp ou Julia
• arquivos lit podem ser PL ou M
• Os arquivos m podem ser Matlab, Mathematica, Objective-C, Mumpps ou Mercury
• Os arquivos p6 podem ser Perl ou Prolog
• Os arquivos pl podem ser Perl ou Prolog
• Os arquivos PL podem ser Perl ou Prolog
• Os arquivos pp podem ser Pascal ou Puppet
• Os arquivos pro podem ser IDL, Projeto QT, Prolog ou ProGuard
• Os arquivos ts podem ser TypeScript ou QT Lingingist
• Os arquivos ui podem ser qt ou glade
• Os arquivos v podem ser verilog-systemVerilog ou coq

O CLOC possui sub -rotinas que tentam identificar a linguagem correta com base no conteúdo do arquivo para esses casos especiais. A precisão da identificação do idioma é uma função de quanto código o arquivo contém; Os arquivos .m com apenas uma ou duas linhas, por exemplo, raramente têm informações suficientes para distinguir corretamente entre Matlab, Mercury, caxumba ou Objective-C.

Os idiomas com colisões de extensão de arquivos são difíceis de personalizar com --read-lang-def ou --force-lang-def , pois não têm mecanismo para identificar linguagens com extensões comuns. Nesta situação, deve -se modificar o código -fonte CLOC.

Como funciona ▲

O método de operação da CLOC se assemelha ao Sloccount's: Primeiro, crie uma lista de arquivos a serem considerados. Em seguida, tente determinar se os arquivos encontrados contêm ou não o código -fonte da linguagem do computador reconhecida. Finalmente, para arquivos identificados como arquivos de origem, invoce rotinas específicas do idioma para contar o número de linhas de origem.

Uma descrição mais detalhada:

1. Se o arquivo de entrada for um arquivo (como um arquivo .tar.gz ou .zip), crie um diretório temporário e expanda o arquivo lá usando uma chamada de sistema para um utilitário subjacente apropriado (alcatrão, bzip2, descompactação etc.) Este diretório temporário como uma das entradas. (Isso funciona de maneira mais confiável no Unix do que no Windows.)

2. Use o arquivo :: Find para descer recursivamente os diretórios de entrada e fazer uma lista de nomes de arquivos candidatos. Ignore arquivos binários e zero.

3. Verifique se os arquivos na lista de candidatos têm conteúdo exclusivo (primeiro comparando os tamanhos dos arquivos e, em seguida, para arquivos de tamanho semelhante, compare o MD5 Hashes do conteúdo do arquivo com o Digest :: MD5). Para cada conjunto de arquivos idênticos, remova todos, exceto a primeira cópia, conforme determinado por um tipo lexical, de arquivos idênticos do conjunto. Os arquivos removidos não estão incluídos no relatório. (O switch --skip-uniqueness desativa os testes de singularidade e força todas as cópias dos arquivos a serem incluídas no relatório.) Consulte também o --ignored= Switch para ver quais arquivos foram ignorados e por quê.

4. Digitalize a lista de arquivos candidatos em busca de extensões de arquivo que o CLOC associa às linguagens de programação (consulte as opções --show-lang e --show-ext ). Os arquivos que correspondem são classificados como contendo código -fonte para esse idioma. Cada arquivo sem uma extensão é aberto e sua primeira linha leia para ver se é um script de shell do Unix (qualquer coisa que começa com #!). Se for script shell, o arquivo será classificado por esse idioma de script (se o idioma for reconhecido). Se o arquivo não tiver uma extensão reconhecida ou não for uma linguagem de script reconhecida, o arquivo será ignorado.

5. Todos os arquivos restantes na lista de candidatos agora devem ser arquivos de origem para linguagens de programação conhecidas. Para cada um desses arquivos:

   1. Leia o arquivo inteiro na memória.
   2. Conte o número de linhas (= l _original ).
   3. Remova as linhas em branco e conte novamente (= l _{non_blank} ).
   4. Loop sobre os filtros de comentários definidos para este idioma. (Por exemplo, C ++ possui dois filtros: (1) Remova as linhas que começam com o espaço de branco opcional seguido de // e (2) Remova o texto entre / * e * /) Aplique cada filtro ao código para remover comentários. Conte as linhas esquerdas (= L _Código ).
   5. Salve a contagem deste idioma:
      • linhas em branco = l _original - l _{non_blank}
      • linhas de comentário = l _{non_blank} - l _código
      • linhas de código = _código l

As opções modificam um pouco o algoritmo. A opção --read-lang-def , por exemplo, permite que o usuário leia definições de filtros de comentários, extensões de arquivo conhecidas e linguagens de script conhecidas de um arquivo. O código para esta opção é processado entre as etapas 2 e 3.

Uso avançado ▲

Remova os comentários do código -fonte ▲

Como você pode saber se o CLOC identifica corretamente os comentários? Uma maneira de se convencer do CLOC é fazer a coisa certa é usar sua opção --strip-comments para remover comentários e linhas em branco dos arquivos e comparar os arquivos despojados com os originais.

Vamos tentar isso com a amalgamação SQLITE, um arquivo C que contém todo o código necessário para construir a biblioteca SQLite junto com um arquivo de cabeçalho:

 Prompt> tar zxf sqlite-amalgamation-3.5.6.tar.gz
Prompt> CD SQLITE-3.5.6/
prompt> cloc-strip-com-comments = nc sqlite.c
       1 arquivo de texto.
       1 arquivo exclusivo.
Escreveu SQLITE3.C.NC
       0 arquivos ignorados.

http://cloc.sourceforge.net v 1.03 t = 1,0 s (1,0 arquivos/s, 82895.0 linhas/s)
-------------------------------------------------- -----------------------------
Arquivos de idioma em branco Código de comentários Escala de 3ª geração. equiv
-------------------------------------------------- -----------------------------
C 1 5167 26827 50901 x 0,77 = 39193.77
-------------------------------------------------- -----------------------------

O argumento de extensão dado a--STRIP-Compomments é arbitrário; Aqui a NC foi usada como abreviação de "sem comentários".

Cloc removeu mais de 31.000 linhas do arquivo:

 Prompt> wc -l sqlite3.c sqlite3.c.nc
  82895 SQLITE3.C
  50901 SQLITE3.C.NC
 133796 TOTAL
Prompt> Echo "82895 - 50901" | a.C.
31994

Agora podemos comparar o arquivo original, sqlite3.c e o despojado de comentários, sqlite3.c.nc com ferramentas como DIFF ou VIMDIFF e ver o que exatamente o CLOC considerou comentários e linhas em branco. Uma prova rigorosa de que o arquivo despojado contém o mesmo código C que o original é compilar esses arquivos e comparar as somas de verificação dos arquivos de objeto resultantes.

Primeiro, o arquivo de origem original:

 prompt> gcc -c sqlite3.c
Prompt> md5sum sqlite3.o
CCE5F1A2EA27C7E44B2E1047E2588B49 SQLITE3.O

Em seguida, a versão sem comentários:

 Prompt> mv sqlite3.c.nc sqlite3.c
prompt> gcc -c sqlite3.c
Prompt> md5sum sqlite3.o
CCE5F1A2EA27C7E44B2E1047E2588B49 SQLITE3.O

O CLOC removeu mais de 31.000 linhas de comentários e espaços em branco, mas não modificou o código -fonte de maneira significativa, pois o arquivo de objeto resultante corresponde ao original.

Trabalhe com arquivos compactados ▲

As versões do CLOC antes da v1.07 exigiam uma opção --extract-with=CMD para informar ao CLOC como expandir um arquivo de arquivo. Começando com v1.07, essa é a extração é tentada automaticamente. No momento, o método de extração automática funciona razoavelmente bem nos sistemas operacionais do tipo Unix para os seguintes tipos de arquivo: .tar.gz , .tar.bz2 , .tar.xz , .tgz , .zip , .ear , .deb . Algumas dessas extensões funcionam no Windows se tiver um Winzip instalado no local padrão ( C:Program FilesWinZipWinZip32.exe ). Além disso, com versões mais recentes do Winzip, é necessário [http://www.winzip.com/dowlc.htm]. Nesse caso, alguém seria invocar Cloc com algo como

 --extract -with = "" C:  Arquivos de programas  winzip  wzunzip  "-e -o> arquivo <."
 

Ref. http://sourceforge.net/projects/cloc/forums/forum/600963/topic/4021070?message=8938196

Em situações em que a extração automática falha, pode-se experimentar a opção --extract-with=CMD para contar linhas de código dentro de arquivos TAR, arquivos zip ou outros arquivos compactados para os quais se possui uma ferramenta de extração. O CLOC pega o comando de extração fornecido pelo usuário e expande o arquivo para um diretório temporário (criado com o arquivo :: temp), conta as linhas de código no diretório temporário e remove esse diretório. Embora não seja especialmente útil ao lidar com um único arquivo compactado (afinal, se você vai digitar o comando de extração de qualquer maneira, por que não apenas expandir manualmente o arquivo?) Essa opção é útil para trabalhar com vários arquivos de uma só vez.

Por exemplo, digamos que você tenha as seguintes tarballs de origem em uma máquina Unix

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

E você deseja contar todo o código dentro deles. O comando seria

 cloc --extract -with = 'gzip -dc> arquivo <| TAR XF-'Perl-5.8.5.tar.gz python-2.4.2.tar.gz

Se essa máquina Unix tiver GNU tar (que pode descompactar e extrair em uma etapa), o comando pode ser reduzido para

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

Em um computador Windows com Winzip instalado em c:Program FilesWinZip the Comando parece

 cloc.exe --xtract -with = "" C:  Arquivos de programas  winzip  winzip32.exe  "-e -o> arquivo <." perl-5.8.5.tar.gz python-2.4.2.tar.gz

Os arquivos java .ear são arquivos zip que contêm arquivos zip adicionais. O CLOC pode lidar com arquivos compactados aninhados sem dificuldade-todos esses arquivos são compactados e arquivados da mesma maneira. Exemplos de contagem de um arquivo java .ear no Unix e Windows:

 Unix> cloc --extract -with = "UNZIP -D.> Arquivo <" Project.ear
Dos> cloc.exe --extract -with = "" C:  Arquivos de programas  winzip  winzip32.exe  "-e -o> arquivo <." Project.ear

Diferenças ▲

O switch --diff permite medir a mudança relativa no código -fonte e os comentários entre duas versões de um arquivo, diretório ou arquivo. As diferenças revelam muito mais do que a contagem absoluta de código de duas versões de arquivo. Por exemplo, digamos um arquivo de origem tem 100 linhas e seu desenvolvedor entrega uma versão mais recente com 102 linhas. O desenvolvedor adicionou duas linhas de comentários, ou excluiu dezessete linhas de origem e adicionou quatorze linhas de origem e cinco linhas de comentários, ou o desenvolvedor fez uma reescrita completa, descartando todas as 100 linhas originais e adicionando 102 linhas de toda a nova fonte? A opção DIFF informa quantas linhas de origem foram adicionadas, removidas, modificadas ou permanecem as mesmas, e quantas linhas de comentários foram adicionadas, removidas, modificadas ou permanecem as mesmas.

As diferenças nas linhas em branco são tratadas muito mais grosseiramente porque são despojadas pelo Cloc desde o início. A menos que um par de arquivos seja idêntico, o CLOC relatará apenas diferenças nas contagens absolutas de linhas em branco. Em outras palavras, pode -se esperar ver apenas entradas para 'adicionadas' se o segundo arquivo tiver mais espaços em branco que o primeiro e 'removido' se a situação for revertida. A entrada para o 'mesmo' será diferente de zero quando os dois arquivos forem idênticos.

Além dos pares de arquivos, é possível fornecer aos pares de diretórios Cloc ou pares de arquivos de arquivos, ou um arquivo de arquivo e um diretório. O CLOC tentará alinhar pares de arquivos nos diretórios ou arquivos e comparar diferencios para cada par. Por exemplo, para ver o que mudou entre o GCC 4.4.0 e 4.5.0, um poderia fazer

 CLOC--DIFF GCC-4.4.0.tar.bz2 gcc-4.5.0.tar.bz2

Esteja preparado para esperar um pouco para os resultados; A opção --diff funciona muito mais lentamente do que uma contagem absoluta de código.

Para ver como o CLOC alinha os arquivos entre os dois arquivos, use a opção de --diff-alignment

 CLOC--DIFF-ALINGENT = ALIGN.TXT GCC-4.4.0.TAR.BZ2 GCC-4.5.0.TAR.BZ2

Para produzir o arquivo align.txt , que mostra os pares de arquivos e os arquivos adicionados e excluídos. Os símbolos == e != Antes de cada par de arquivos indicam se os arquivos são idênticos ( == ) ou se têm conteúdo diferente ( != ).

Aqui está a saída de amostra mostrando a diferença entre as liberações Python 2.6.6 e 2.7:

 Prompt> Cloc-Diff Python-2.7.9.tgz python-2.7.10.tar.xz
    4315 arquivos de texto.
    4313 Arquivos de texto
    2173 arquivos ignorados.

4 erros:
Erro de diff, excedido Timeout: /tmp/8toganb9y1/python-2.7.9/mac/modules/qt/_qtmodule.c
Erro de diff, excedido Timeout: /tmp/m6ldvsgaoq/python-2.7.10/mac/modules/qt/_qtmodule.c
Erro de diff (comentários citados?): /Tmp/8toganb9y1/python-2.7.9/mac/modules/qd/qdsupport.py
Erro de diff (comentários 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 arquivos/s, 0,0 linhas/s)
-------------------------------------------------- ---------------------------
Arquivos de idioma Código de comentário em branco
-------------------------------------------------- ---------------------------
Visual Básico
 Mesmo 2 0 1 12
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
fazer
 Mesmo 11 0 340 2952
 modificado 1 0 0 1
 Adicionado 0 0 0 0
 removido 0 0 0 0
diferença
 Mesmo 1 0 87 105
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
CSS
 mesmo 0 0 19 327
 modificado 1 0 0 1
 Adicionado 0 0 0 0
 removido 0 0 0 0
Objective-C
 mesmo 7 0 61 635
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
Script nant
 Mesmo 2 0 0 30
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
XML
 mesmo 3 0 2 72
 modificado 1 0 0 1
 Adicionado 0 0 0 1
 removido 0 1 0 0
Arquivo de recursos do Windows
 mesmo 3 0 56 206
 modificado 1 0 0 1
 Adicionado 0 0 0 0
 removido 0 0 0 0
Esperar
 Mesmo 6 0 161 565
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
HTML
 mesmo 14 0 11 2344
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
script vim
 Mesmo 1 0 7 106
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
C++
 Mesmo 2 0 18 128
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
Definição do módulo Windows
 mesmo 7 0 187 2080
 modificado 2 0 0 0
 Adicionado 0 0 0 1
 removido 0 1 0 2
Prolog
 Mesmo 1 0 0 24
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
JavaScript
 Mesmo 3 0 49 229
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
Conjunto
 Mesmo 51 0 6794 12298
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
Bourne Shell
 Mesmo 41 0 7698 45024
 modificado 1 0 0 3
 Adicionado 0 13 2 64
 removido 0 0 0 0
Dos lote
 Mesmo 29 0 107 494
 modificado 1 0 0 9
 Adicionado 0 1 0 3
 removido 0 0 0 0
Script msbuild
 mesmo 77 0 3 38910
 modificado 0 0 0 0
 Adicionado 0 0 0 0
 removido 0 0 0 0
Pitão
 Mesmo 1947 0 109012 430335
 modificado 192 0 94 950
 Adicionado 2 323 283 2532
 Removido 2 55 58 646
m4
 mesmo 18 0 191 15352
 modificado 1 0 0 2
 Adicionado 1 31 0 205
 removido 0 0 0 0
C
 Mesmo 505 0 37439 347837
 modificado 45 0 13 218
 Adicionado 0 90 33 795
 Removido 0 9 2 148
Cabeçalho C/C ++
 Mesmo 255 0 10361 66635
 modificado 5 0 5 7
 Adicionado 0 1 3 300
 removido 0 0 0 0
-------------------------------------------------- -------------------
SOMA:
 Mesmo 2986 0 172604 966700
 modificado 251 0 112 1193
 Adicionado 3 459 321 3901
 Removido 2 66 60 796
-------------------------------------------------- -------------------

Um par de erros ocorreu. O primeiro par foi causado pelo tempo de tempo quando a computação de diferenças do arquivo Python-X/Mac/Modules/qt/_Qtmodule.c em cada versão python. Este arquivo possui> 26.000 linhas de código C e leva mais de 10 segundos-a duração máxima padrão para diferenciar um único arquivo-no meu computador lento. (Nota: refere -se à execução de diferenças com a função sdiff() no Algorithm::Diff Módulo, não a linha de comando diff UTILIDADE.) Esse erro pode ser superado aumentando o tempo para, digamos, 20 segundos com --diff-timeout 20 .

O segundo erro é mais problemático. Os arquivos Python-X/Mac/Modules/qd/qdsupport.py incluem python docstring (texto entre pares de citações triplas) contendo comentários c. O CLOC trata os documentos como comentários e os lida primeiro convertendo -os em comentários C e depois usando o comentário C removendo a expressão regular. Os comentários aninhados C rendem resultados errôneos no entanto.

Crie definições de linguagem personalizadas ▲

O CLOC pode escrever suas definições de comentários de idiomas em um arquivo ou pode ler as definições de comentários de um arquivo, substituindo as definições internas. Isso pode ser útil quando você deseja usar o CLOC para contar as linhas de um idioma ainda não incluído, para alterar a associação de extensões de arquivo para idiomas ou modificar a maneira como os idiomas existentes são contados.

A maneira mais fácil de criar um arquivo de definição de idioma personalizado é fazer com que o CLOC escreva suas definições em um arquivo e modifique esse arquivo:

 Unix> cloc--write-lang-Def = my_definitions.txt

Cria o arquivo my_definitions.txt , que pode ser modificado e leia novamente com a opção --read-lang-def ou --force-lang-def . A diferença entre as opções é que as anteriores mesclaram definições de idiomas do arquivo fornecido com as definições internas da CLOC com a precedência de Cloc se houver sobreposições. A opção --force-lang-def , por outro lado, substitui completamente as definições de Cloc. Esta opção tem uma desvantagem em impedir que o CLOC contasse idiomas cujas extensões mapeiam para vários idiomas, pois esses idiomas requerem lógica adicional que não é facilmente expressa em um arquivo de definições.

 Unix> cloc --read-lang-Def = my_definitions.txt file1 file2 dir1 ...

Cada entrada de idioma tem quatro partes:

• O nome do idioma que começa na coluna 1.
• Um ou mais filtros de comentários começando na coluna 5.
• Uma ou mais extensões de nome de arquivo começando na coluna 5.
• Um fator de escala de 3ª geração que começa na coluna 5. Esta entrada deve ser fornecida, mas seu valor não é importante, a menos que você queira comparar seu idioma com uma linguagem de programação hipotética de terceira geração.

Um filtro define um método para remover o texto do comentário do arquivo de origem. Por exemplo, a entrada para C ++ se parece com isso

 C++
    FILTE CALL_REGEXP_COMMON C ++
    FILTE REMOVER_INLINE //.*$
    Extensão c
    Extensão C ++
    Extensão cc
    Extensão cpp
    Extensão CXX
    Extensão PCC
    3rd_gen_scale 1.51
    end_of_line_continuation \ $

O C ++ possui dois filtros: primeiro, remova as linhas correspondentes a Regexp :: Comment Regex do Common C ++. O segundo filtro usando Remone_inline não é utilizado. Sua intenção é identificar linhas com código e comentários e pode ser implementada no futuro.

Uma discussão mais completa das diferentes opções de filtro pode aparecer aqui no futuro. A saída da opção de CLOC --write-lang-def deve fornecer exemplos suficientes para indivíduos motivados para modificar ou estender as definições de linguagem do CLOC.

Combine relatórios ▲

Se você gerenciar vários projetos de software, poderá estar interessado em ver contagens de linha por projeto, não apenas por idioma. Digamos que você gerencie três projetos de software chamados Mariadb, PostgreSQL e SQLite. As equipes responsáveis ​​por cada um desses projetos executam o CLOC em seu código -fonte e fornecem a saída. Por exemplo, a equipe MariaDB faz

 Cloc-MARIADB-10.1.TXT MARIADB-SERVER-10.1.ZIP

e fornece o arquivo mariadb-10.1.txt . O conteúdo dos três arquivos que você recebe são

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

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

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

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

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

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

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

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

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

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

then sum these together with

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

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

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

Finally, combine the combination files:

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

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

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

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

SQL ▲

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

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

Table metadata :

Campo	Tipo
eu ia	integer primary key
carimbo de data/hora	texto
projeto	texto
elapsed_s	texto

Table t :

Campo	Tipo
projeto	texto
linguagem	texto
arquivo	texto
nBlank	integer
nComment	integer
nCode	integer
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 ; então
    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)."
    saída
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

Other examples:

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