cloc
v2.02
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.
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 ..
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.
docker run --rm -v $PWD :/tmp aldanial/clocdocker run --rm -v " / $( pwd -W ) " :/tmp aldanial/clocDependendo 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.
https://github.com/AlDanial/cloc/releases/latest
https://github.com/AlDanial/cloc/raw/master/cloc
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.
cloc possui muitos recursos que o tornam fácil de usar, completo, extensível e portátil:
Se cloc não atender às suas necessidades, aqui estão outros contadores disponíveis gratuitamente a serem considerados:
Outras referências:
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.
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 executável do Windows.
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 .
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/
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.
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.
prompt> cloc --help
Uso: cloc [opções] <arquivo(s)/dir(s)/git hash(es)> | <conjunto 1> <conjunto 2> | <arquivos de relatório>
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=<cmd> 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 <cmd> 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=<file> Leva a lista de nomes de arquivos e/ou diretórios para
processo de <arquivo>, 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 <arquivo>
to - para ler nomes de arquivos de um canal STDIN.
Veja também --exclude-list-file.
--diff-list-file=<arquivo> Pegue os pares de nomes de arquivos a serem comparados
<arquivo>, 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=<VCS> Invoque uma chamada de sistema para <VCS> para obter uma lista de
arquivos para trabalhar. Se <VCS> 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 <VCS> 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, <VCS> 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 <VCS>. 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 <VCS> 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 <arquivo> Lê as opções de linha de comando de <arquivo> 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 <conjunto1> <conjunto2>
Primeiro, execute contagens diretas de código do(s) arquivo(s) de origem
de <set1> e <set2> 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 <set1> <set2> Calcula diferenças no código e comentários entre
arquivo(s) de origem de <set1> e <set2>. 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 <N> Ignora arquivos que demoram mais de <N> segundos
para processar. O padrão é 10 segundos. Configuração <N>
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=<lang>[,<ext>]
Processe todos os arquivos que possuem uma extensão <ext>
com o contador do idioma <lang>. 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 <ext> for omitido, todos os arquivos serão contados
com o contador <lang>. Esta opção pode ser
especificado várias vezes (mas isso é apenas
útil quando <ext> é fornecido todas as vezes).
Veja também --script-lang, --lang-no-ext.
--force-lang-def=<arquivo> Carrega filtros de processamento de linguagem de <arquivo>,
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=<lang> Contar arquivos sem extensões usando o <lang>
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=<MB> Ignora arquivos maiores que <MB> megabytes quando
percorrendo diretórios. Por padrão, <MB>=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=<arquivo> Carregar novos filtros de processamento de linguagem de <arquivo>
e mesclá-los com aqueles já conhecidos por cloc.
Se <file> 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=<lang>,<s> Processa todos os arquivos que invocam <s> como #!
linguagem de script com o contador de idioma
<lang>. 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, <s>,
deve ter o caso certo. Esta opção pode ser
especificado várias vezes. Veja também --force-lang,
--lang-no-ext.
--sdir=<dir> Use <dir> 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=<file> 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=<ext> 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 .<ext> 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 <N> Ignora arquivos que demoram mais de <N> 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 <N> 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=<regex> Conta apenas arquivos contendo texto que corresponda ao
dada expressão regular.
--exclude-content=<regex> Exclui arquivos contendo texto que corresponda ao determinado
expressão regular.
--exclude-dir=<D1>[,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=<regex>
para fornecer um regex correspondente a vários subdiretórios.
--exclude-ext=<ext1>[,<ext2>[...]]
Não conte os arquivos com o nome de arquivo fornecido
extensões.
--exclude-lang=<L1>[,L2[...]]
Exclua os idiomas separados por vírgula fornecidos
L1, L2, L3, etc., sejam contados.
--exclude-list-file=<arquivo> Ignora arquivos e/ou diretórios cujos nomes
aparecem em <arquivo>. <arquivo> 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=<ext1>[,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=<L1>[,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=<regex> 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=<regex> 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=<regex> 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=<regex> 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=<regex> 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
-Categorizado = <File> Salvar tamanhos de arquivo em bytes, idiomas identificados
e nomes de arquivos categorizados para <File>.
--CONTED = <File> Salve nomes de arquivos de origem processados para <File>.
--DIFF-ALINGMENT = <File> Escreva para <File> 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 = <lang> Imprima os filtros usados para remover comentários para
idioma <lang> 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 = <File> Salve os nomes de cada arquivo encontrado em <File>.
--ignado = <File> Salvar nomes de arquivos ignorados e o motivo pelo qual eles
foram ignorados para <File>.
-Os palestrantes de filtro imprimem o código-fonte processado antes e depois
Cada filtro é aplicado.
--Show-ext [= <Ext>] Imprima informações sobre todos conhecidos (ou apenas o
dado) Extensões de arquivo e saída.
--Show-lang [= <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 [= <n>] Switch detalhado (valor numérico opcional).
-verbose [= <n>] forma longa de -v.
-Imprima a versão deste programa e saia.
--write-lang-DEF = <File> grava para <File> 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 = <File>
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 = <C> Use o caractere <C> como o delimitador para vírgula
arquivos separados em vez de ,. Este interruptor forças - -CSV a serem ativadas.
--File-coding = <e> gravar arquivos de saída usando a codificação <e> em vez de
o ASCII padrão (<E> = '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 = <File> Sinônimo para --Report-File = <File>.
--Progress-rate = <n> Mostrar atualização de progresso após os arquivos <n>
processado (padrão <n> = 100). Definir <n> 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 = <File> Escreva os resultados para <File> em vez de stdout.
--SQL = <File> Escreva resultados como SQL Criar e inserir instruções
que pode ser lido por um programa de banco de dados, como
Sqlite. Se <File> 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 = <name> use <name> como o identificador do projeto para o
execução atual. Somente válido com a opção - -SQL.
--SQL-STYLE = <Toy> 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 = <File> Referência <File> como uma folha de estilo XSL dentro
a saída XML. Se <File> é 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.
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
