시계
v2.02
코드 줄 수 세기
cloc는 많은 프로그래밍 언어에서 빈 줄, 주석 줄, 소스 코드의 물리적 줄을 계산합니다.
최신 릴리스: v2.02(2024년 8월 2일)
cloc은 2006년 8월부터 http://cloc.sourceforge.net/에서 호스팅되다가 2015년 9월 GitHub로 이전되었습니다.
1단계: cloc를 다운로드하거나(여러 가지 방법, 아래 참조) cloc의 docker 이미지를 실행합니다. Windows 실행 파일에는 요구 사항이 없습니다. cloc의 소스 버전에는 Perl 인터프리터가 필요하고, cloc의 Docker 버전에는 Docker 설치가 필요합니다.
2단계: 터미널(Windows의 경우 cmd.exe )을 엽니다.
3단계: cloc를 호출하여 소스 파일, 디렉터리, 아카이브 또는 git 커밋 수를 계산합니다. 실행 파일 이름은 개발 소스 버전( cloc ), 릴리스 버전 소스( cloc-2.02.pl ) 또는 Windows 실행 파일( cloc-2.02.exe )을 사용하는지 여부에 따라 다릅니다.
이 페이지에서 cloc 이들 중 하나를 지칭하는 데 사용되는 일반적인 용어입니다.
보안 포함에는 실제 단계를 보여주는 YouTube 비디오가 있습니다.
파일
프롬프트> cloc hello.c
텍스트 파일 1개.
고유한 파일 1개.
0개의 파일이 무시되었습니다.
https://github.com/AlDanial/cloc v 1.65 T=0.04 s (28.3 파일/초, 340.0 라인/초)
------------------------------------- ----------------
언어 파일의 빈 주석 코드
------------------------------------- ----------------
C 1 0 7 5
------------------------------------- ----------------
디렉토리
프롬프트> cloc gcc-5.2.0/gcc/c
16개의 텍스트 파일.
15개의 고유한 파일.
3개의 파일이 무시되었습니다.
https://github.com/AlDanial/cloc v 1.65 T=0.23 s (57.1 파일/초, 188914.0 라인/초)
------------------------------------- ----------------
언어 파일의 빈 주석 코드
------------------------------------- ----------------
C 10 4680 6621 30812
C/C++ 헤더 3 99 286 496
------------------------------------- ----------------
합계: 13 4779 6907 31308
------------------------------------- ----------------
기록 보관소
GitHub에서 cloc의 소스 zip 파일을 가져온 다음 내용을 계산합니다.
프롬프트> wget https://github.com/AlDanial/cloc/archive/master.zip 프롬프트> cloc master.zip https://github.com/AlDanial/cloc v 1.65 T=0.07 s (26.8 파일/초, 141370.3 라인/초) ------------------------------------- ---------------- 언어 파일의 빈 주석 코드 ------------------------------------- ---------------- 펄 2 725 1103 8713 ------------------------------------- ---------------- 합계: 2 725 1103 8713 ------------------------------------- ----------------
특정 커밋을 사용하는 git 저장소
이 예제에서는 환상적인 Python 디버거인 PuDB의 코드를 사용합니다.
프롬프트> git clone https://github.com/inducer/pudb.git
프롬프트> CD pudb
프롬프트> cloc 6be804e07a5db
48개의 텍스트 파일.
41개의 고유한 파일.
8개 파일이 무시되었습니다.
github.com/AlDanial/cloc v 1.99 T=0.04 s (1054.9 파일/초, 189646.8 라인/초)
------------------------------------- ----------------
언어 파일의 빈 주석 코드
------------------------------------- ----------------
파이썬 28 1519 728 4659
reStructuredText 6 102 20 203
YAML 2 9 2 75
본 쉘 3 6 0 17
텍스트 1 0 0 11
1 4 6 10을 만들다
------------------------------------- ----------------
합계: 41 1640 756 4975
------------------------------------- ----------------
특정 디렉토리의 각 하위 디렉토리
세 가지 다른 git 관리 프로젝트인 Project0, Project1 및 Project2가 있는 디렉터리가 있다고 가정해 보겠습니다. 쉘의 루핑 기능을 사용하여 각각의 코드 수를 계산할 수 있습니다. 이 예에서는 bash를 사용합니다(cmd.exe 예를 보려면 아래로 스크롤).
프롬프트> ./*/의 d에 대해; do (cd "$d" && echo "$d" && cloc --vcs git); 완료
./프로젝트0/
7개의 텍스트 파일.
7개의 고유한 파일.
파일 1개가 무시되었습니다.
github.com/AlDanial/cloc v 1.71 T=0.02 s (390.2 파일/초, 25687.6 라인/초)
------------------------------------- ----------------
언어 파일의 빈 주석 코드
------------------------------------- ----------------
디 4 61 32 251
마크다운 1 9 0 38
1 0 0 4를 만들다
------------------------------------- ----------------
합계: 6 70 32 293
------------------------------------- ----------------
./프로젝트1/
7개의 텍스트 파일.
7개의 고유한 파일.
0개의 파일이 무시되었습니다.
github.com/AlDanial/cloc v 1.71 T=0.02 s (293.0 파일/초, 52107.1 라인/초)
------------------------------------- ----------------
언어 파일의 빈 주석 코드
------------------------------------- ----------------
가다 7 165 282 798
------------------------------------- ----------------
합계: 7 165 282 798
------------------------------------- ----------------
./프로젝트2/
49개의 텍스트 파일.
47개의 고유한 파일.
13개의 파일이 무시되었습니다.
github.com/AlDanial/cloc v 1.71 T=0.10 s (399.5 파일/초, 70409.4 라인/초)
------------------------------------- ----------------
언어 파일의 빈 주석 코드
------------------------------------- ----------------
파이썬 33 1226 1026 3017
C 4 327 337 888
마크다운 1 11 0 28
YAML 1 0 2 12
------------------------------------- ----------------
합계: 39 1564 1365 3945
------------------------------------- ----------------
특정 디렉터리의 각 하위 디렉터리(Windows/cmd.exe)
for /D %I in (.*) do cd %I && cloc --vcs git && cd ..
cloc는 많은 프로그래밍 언어에서 빈 줄, 주석 줄, 소스 코드의 물리적 줄을 계산합니다. 두 가지 버전의 코드 베이스가 주어지면 cloc은 공백, 주석 및 소스 행의 차이를 계산할 수 있습니다. 이는 Perl v5.6 이상의 표준 배포판(일부 외부 모듈의 코드는 cloc에 내장되어 있음) 외부에 종속되지 않고 완전히 Perl로 작성되었으므로 이식성이 뛰어납니다. cloc는 Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX, z/OS 및 Windows의 다양한 버전에서 실행되는 것으로 알려져 있습니다. (Windows에서 cloc의 Perl 소스 버전을 실행하려면 ActiveState Perl 5.6.1 이상, Strawberry Perl, Linux용 Windows 하위 시스템, Cygwin, Perl 플러그인이 설치된 MobaXTerm 또는 다음에서 제공하는 mingw 환경 및 터미널이 필요합니다. Windows용 Git 또는 PAR::Packer로 생성된 cloc의 Windows 바이너리를 사용하여 Perl이나 Cygwin이 없는 Windows 컴퓨터에서 실행할 수 있습니다.
개별 텍스트 파일, 디렉터리 및 git 리포지토리의 코드를 계산하는 것 외에도 cloc는 .tar (압축 버전 포함), .zip , Python 휠 .whl , Jupyter 노트북 .ipynb , 소스 RPM과 같은 아카이브 파일의 코드도 계산할 수 있습니다 .rpm 또는 .src ( rpm2cpio 필요) 및 Debian .deb 파일( dpkg-deb 필요).
cloc에는 David Wheeler의 SLOCCount, Damian Conway 및 Abigail의 Perl 모듈 Regexp::Common, Sean M. Burke의 Perl 모듈 Win32::Autoglob 및 Tye McQueen의 Perl 모듈 Algorithm::Diff의 코드가 포함되어 있습니다. 언어 척도 인자는 Mayes Consulting, LLC 웹사이트 http://softwareestimator.com/IndustryData2.htm에서 파생되었습니다.
새 릴리스는 명목상 6개월마다 나타납니다.
docker run --rm -v $PWD :/tmp aldanial/clocdocker run --rm -v " / $( pwd -W ) " :/tmp aldanial/cloc운영 체제에 따라 다음 설치 방법 중 하나가 적합할 수 있습니다(Windows의 마지막 두 항목을 제외한 모든 항목에는 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
참고 : 저는 이러한 패키지를 제어하지 않습니다. 위 패키지 중 하나를 사용하여 cloc에서 버그가 발생하면 문제 보고서를 제출하기 전에 여기 GitHub(아래 링크 참조)의 최신 안정 릴리스에서 가져온 cloc를 사용해 보세요.
https://github.com/AlDanial/cloc/releases/latest
https://github.com/AlDanial/cloc/raw/master/cloc
cloc는 다른 소스에서 복사된 부분을 제외하고 GNU General Public License v 2에 따라 라이센스가 부여됩니다. Regexp::Common, Win32::Autoglob 및 Algorithm::Diff Perl 모듈에서 복사된 코드에는 예술 라이센스가 적용됩니다.
cloc에는 사용하기 쉽고, 철저하며, 확장 가능하고 이식 가능한 많은 기능이 있습니다.
cloc이 귀하의 요구 사항에 적합하지 않은 경우 고려해야 할 다른 무료 카운터가 있습니다.
기타 참고자료:
cloc에는 표준 배포판에 있는 것 이외의 Perl 모듈이 필요하지 않지만 cloc는 몇 가지 외부 모듈에 의존합니다. 세 가지 외부 모듈(Regexp::Common, Win32::Autoglob 및 Algorithm::Diff)의 코드가 cloc에 포함되어 있습니다. 네 번째 모듈인 Digest::MD5는 사용 가능한 경우에만 사용됩니다. cloc이 로컬에 설치된 Regexp::Common 또는 Algorithm::Diff를 발견하면 해당 설치를 사용합니다. 그렇지 않은 경우 cloc는 Regexp::Common 및/또는 Algorithm:Diff의 일부를 설치합니다. cloc 실행 시작 시 생성된 다음 실행이 완료되면 제거되는 임시 디렉터리에 필요합니다. Regexp::Common v2.120 및 Algorithm::Diff v1.1902의 필수 코드는 cloc 소스 코드 내에 포함되어 있습니다(서브루틴 Install_Regexp_Common() 및 Install_Algorithm_Diff() 참조). Win32::Autoglob에서는 세 줄만 필요하며 이는 cloc에 직접 포함됩니다.
또한, cloc는 Digest::MD5가 로컬에 설치된 경우 Digest::MD5를 사용하여 동일한 크기의 입력 파일 간의 고유성을 검증합니다.
병렬 처리 옵션 --processes= N 은 멀티 코어 시스템에서 더 빠른 실행을 가능하게 하기 위해 cloc 버전 1.76에 도입되었습니다. 그러나 이를 사용하려면 Parallel::ForkManager 모듈이 설치되어 있어야 합니다. 이 모듈은 Windows에서는 안정적으로 작동하지 않으므로 병렬 처리는 Unix 계열 운영 체제에서만 작동합니다.
Windows 바이너리는 Regexp::Common과 Digest::MD5가 모두 로컬로 설치된 컴퓨터에 구축되었습니다.
cloc의 Windows 실행 파일을 생성하는 가장 강력한 옵션은 ActiveState의 Perl Development Kit를 사용하는 것입니다. 여기에는 Perl 소스 코드의 독립 실행형 Windows, Mac 및 Linux 바이너리를 구축할 수 있는 유틸리티 perlapp 포함되어 있습니다.
perl2exe도 트릭을 수행합니다. perl2exe 있는 경우 cloc Windows를 실행 가능하게 만드는 데 필요한 사소한 코드 수정을 위해 cloc 소스 코드의 84-87행을 수정하십시오.
그렇지 않은 경우 PAR::Packer 에서 pp 사용하여 Windows 실행 파일을 빌드하려면 먼저 해당 지침에 따라 Windows 기반 Perl 배포판(예: Strawberry Perl 또는 ActivePerl)을 설치하세요. 다음으로, DOS 창이라고도 불리는 명령 프롬프트를 열고 PAR::Packer 모듈을 설치하세요. 마지막으로 cloc 소스 코드와 함께 새로 설치된 pp 명령을 호출하여 .exe 파일을 만듭니다.
C:> cpan -i 다이제스트::MD5 C:> cpan -i Regexp::공통 C:> cpan -i 알고리즘::Diff C:> cpan -i PAR::패커 C:> cpan -i Win32::LongPath C:> pp -M Win32::LongPath -M 인코딩::유니코드 -M 다이제스트::MD5 -c -x -o cloc-2.02.exe cloc-2.02.pl
위 지침의 변형은 Strawberry Perl의 휴대용 버전을 설치한 경우 먼저 portableshell.bat 실행하여 환경을 올바르게 설정해야 한다는 것입니다.
릴리스 섹션의 Windows 실행 파일 cloc-2.02.exe 는 Strawberry Perl 5.30.2 및 PAR::Packer를 사용하여 .exe 를 빌드하는 64비트 Windows 10 컴퓨터에서 빌드되었습니다.
이상적으로는 컴퓨터에 Perl 인터프리터가 설치되어 있고 cloc 소스 파일을 실행할 수 있기 때문에 Windows 실행 파일이 필요한 사람은 없습니다. 그러나 중앙에서 관리되는 기업 Windows 시스템에서는 이것이 어렵거나 불가능할 수 있습니다.
cloc과 함께 배포되는 Windows 실행 파일은 바이러스 및 악성 코드가 없는 .exe 대한 최선의 노력으로 제공됩니다. 실행 파일에 대해 자체 바이러스 스캐너를 실행하고 https://www.virustotal.com/과 같은 사이트도 확인하는 것이 좋습니다. 최신 버전의 항목은 다음과 같습니다.
cloc-2.02-winget.exe: (Windows의 심볼릭 링크에서 실행할 수 있도록 PR 850 포함) https://www.virustotal.com/gui/file/be033061e091fea48a5bc9e8964cee0416ddd5b34bd5226a1c9aa4b30bdba66a?nocache=1
cloc-2.02.exe: https://www.virustotal.com/gui/file/369ed76125f7399cd582d169adf39a2e08ae5066031fea0cc8b2836ea50e7ce2?nocache=1
cloc-2.00.exe: https://www.virustotal.com/gui/file/7a234ef0cb495de1b5776acf88c5554e2bab1fb02725a5fb85756a6db3121c1f
cloc-1.98.exe: https://www.virustotal.com/gui/file/88615d193ec8c06f7ceec3cc1d661088af997798d87ddff331d9e9f9128a6782?nocache=1
cloc-1.96.1.exe: https://www.virustotal.com/gui/file/00b1c9dbbfb920dabd374418e1b86d2c24b8cd2b8705aeb956dee910d0d75d45?nocache=1
cloc-1.96.exe: https://www.virustotal.com/gui/file/54bf5f46fbaba7949c4eb2d4837b03c774c0ba587448a5bad9b8efc0222b1583?nocache=1
cloc-1.94.exe: https://www.virustotal.com/gui/file/b48a6002fb75fa66ec5d0c05a5c4d51f2ad22b5b025b7eb4e3945d18419c0952?nocache=1
cloc-1.92.exe: https://www.virustotal.com/gui/file/2668fcf8609c431e8934fe9e1866bc620c58d198c4eb262f1d3ef31ef4a690f7
cloc-1.90.exe: https://www.virustotal.com/gui/file/d655caae55486f9bac39f7e3c7b7553bcfcfe2b88914c79bfc328055f22b8a37/Detection
cloc-1.88.exe: https://www.virustotal.com/gui/file/97d5d2631d1cccdbfd99267ab8a4cf5968816bbe52c0f9324e72e768857f642d/Detection
cloc-1.86.exe: https://www.virustotal.com/gui/file/1b2e189df1834411b34534db446330d1c379b4bc008af3042ee9ade818c6a1c8/Detection
cloc-1.84.exe: https://www.virustotal.com/gui/file/e73d490c1e4ae2f50ee174005614029b4fa2610dcb76988714839d7be68479af/Detection
cloc-1.82.exe: https://www.virustotal.com/#/file/2e5fb443fdefd776d7b6b136a25e5ee2048991e735042897dbd0bf92efb16563/Detection
cloc-1.80.exe: https://www.virustotal.com/#/file/9e547b01c946aa818ffad43b9ebaf05d3da08ed6ca876ef2b6847be3bf1cf8be/Detection
cloc-1.78.exe: https://www.virustotal.com/#/file/256ade3df82fa92febf2553853ed1106d96c604794606e86efd00d55664dd44f/Detection
cloc-1.76.exe: https://www.virustotal.com/#/url/c1b9b9fe909f91429f95d41e9a9928ab7c58b21351b3acd4249def2a61acd39d/Detection
cloc-1.74_x86.exe: https://www.virustotal.com/#/file/b73dece71f6d3199d90d55db53a588e1393c8dbf84231a7e1be2ce3c5a0ec75b/Detection
cloc 1.72 exe: https://www.virustotal.com/en/url/8fd2af5cd972f648d7a2d7917bc202492012484c3a6f0b48c8fd60a8d395c98c/analytic/
cloc 1.70 exe: https://www.virustotal.com/en/url/63edef209099a93aa0be1a220dc7c4c7ed045064d801e6d5daa84ee624fc0b4a/analytic/
cloc 1.68 exe: https://www.virustotal.com/en/file/c484fc58615fc3b0d5569b9063ec1532980281c3155e4a19099b11ef1c24443b/analytic/
cloc 1.66 exe: https://www.virustotal.com/en/file/54d6662e59b04be793dd10fa5e5edf7747cf0c0cc32f71eb67a3cf8e7a171d81/analytic/1453601367/
위에서 언급한 대로 perl2exe로 생성된 cloc 버전 1.60 이하의 Windows 실행 파일은 약 1.6MB인 반면, PAR::Packer 로 생성된 버전 1.62 및 1.54는 11MB입니다. 최신 버전의 PAR::Packer 로 구축된 버전 1.66은 약 5.5MB입니다. PAR::Packer 실행 파일이 perl2exe로 빌드된 실행 파일보다 훨씬 큰 이유는 무엇입니까? 내 이론은 perl2exe가 PAR::Packer 보다 더 똑똑한 트리 가지치기 논리를 사용한다는 것입니다. 그러나 이는 순수한 추측입니다.
cloc는 파일, 디렉터리 및/또는 아카이브 이름을 입력으로 사용하는 명령줄 프로그램입니다. 다음은 Perl v5.22.0 소스 배포판에 대해 cloc를 실행하는 예입니다.
프롬프트> cloc perl-5.22.0.tar.gz
5605 텍스트 파일.
5386개의 고유 파일.
2176개의 파일이 무시되었습니다.
https://github.com/AlDanial/cloc v 1.65 T=25.49 s (134.7 파일/초, 51980.3 라인/초)
------------------------------------- ---------------------------------
언어 파일의 빈 주석 코드
------------------------------------- ---------------------------------
펄 2892 136396 184362 536445
씨 130 24676 33684 155648
C/C++ 헤더 148 9766 16569 147858
본 쉘 112 4044 6796 42668
파스칼 8458 1603 8592
XML 33 142 0 2410
YAML 49 20 15 2078
C++ 10313 277 2033
4 426 488 1986을 만드세요
프롤로그 12 438 2 1146
JSON 14 1 0 1037
야cc 1 85 76 998
Windows 메시지 파일 1 102 11 489
DOS 배치 14 92 41 389
Windows 리소스 파일 3 10 0 85
디 1 5 7 8
리스프 2 0 3 4
------------------------------------- ---------------------------------
합계: 3434 176974 243934 903874
------------------------------------- ---------------------------------
Windows 컴퓨터에서 cloc를 실행하려면 명령(DOS라고도 함) 창을 열고 명령줄에서 cloc.exe를 호출하십시오. 또는 https://github.com/Roemer/ClocViewer에서 찾을 수 있는 cloc 주변의 GUI 래퍼인 ClocViewer를 사용해 보세요.
cloc 결과의 그래픽 렌더링은 https://github.com/jmensch1/codeflower를 참조하세요.
프롬프트> cloc --help 사용법: cloc [옵션] <파일/디렉터리/git 해시(들)> | <세트 1> <세트 2> | <보고서 파일> 소스 코드의 물리적 라인 수를 계산하거나 차이를 계산합니다. 주어진 파일(압축된 tarball 또는 zip 파일과 같은 아카이브일 수 있음, 또는 git commit 해시 또는 분기 이름) 및/또는 재귀적으로 주어진 디렉토리. 입력 옵션 --extract-with=이 옵션은 cloc을 사용할 수 없는 경우에만 필요합니다. 내용을 추출하는 방법을 알아 내기 위해 입력 파일 자체. 를 사용하여 바이너리 아카이브 파일을 추출합니다(예: .tar.gz, .zip, .Z). 리터럴 '>FILE<'을 다음과 같이 사용하십시오. 실제 파일을 대신하는 역할 추출되었습니다. 예를 들어, 코드 줄 수를 계산하려면 입력 파일에서 gcc-4.2.tar.gz perl-5.8.8.tar.gz 유닉스 사용시 --extract-with='gzip -dc >파일< | 타르 xf -' 또는 GNU tar가 있는 경우 --extract-with='tar zxf >파일<' Windows에서는 다음과 같이 사용합니다. --extract-with=""c:Program FilesWinZipWinZip32.exe" -e -o >파일< ." (WinZip이 설치된 경우) --list-file= 파일 및/또는 디렉터리 이름 목록을 가져옵니다. 하나의 파일/디렉토리가 있는 에서 프로세스 한 줄에 이름. 정확히 일치하는 항목만 계산됩니다. 상대 경로 이름은 다음에서 시작하여 확인됩니다. cloc이 호출되는 디렉토리입니다. <파일> 설정 to - STDIN 파이프에서 파일 이름을 읽습니다. --exclude-list-file도 참조하세요. --diff-list-file= 차이점을 확인할 파일 이름 쌍을 가져옵니다. 형식이 다음의 출력과 일치하는 --차이 정렬. (해당 옵션을 사용하여 실행하면 샘플을 참조하세요.) 각 줄의 끝은 무시됩니다. 이렇게 하면 --diff가 활성화됩니다. 모드이며 파일 쌍 정렬 논리를 우회합니다. --vcs= 에 대한 시스템 호출을 호출하여 목록을 얻습니다. 작업할 파일. 가 'git'이면 파일 목록을 얻으려면 'git ls-files'를 호출하고 하위 모듈 목록을 가져오는 'git submodule status' 그 내용은 무시됩니다. --git도 참조하세요. git commit 해시와 브랜치 이름을 허용합니다. 가 'svn'이면 'svn list -R'을 호출합니다. 주요 이점은 cloc이 건너뛴다는 것입니다. 버전 관리 도구에서 명시적으로 제외된 파일 문제가 있는 경우, 즉 .gitignore에 있거나 svn:속성을 무시합니다. 또는 는 임의의 시스템 명령일 수 있습니다. 파일 목록을 생성합니다. 참고: cloc는 읽을 수 있는 디렉토리에 있어야 합니다. 에서 반환된 파일입니다. 시계는 그럴 것이다 원격 저장소에서 파일을 다운로드하지 마십시오. 'svn list -R'은 원격 저장소를 나타낼 수 있습니다. 파일 이름을 얻으려면 (따라서 필요할 수 있습니다. 원격 저장소에 대한 인증), 그러나 파일 자체는 로컬이어야 합니다. 를 'auto'로 설정하면 'git' 중에서 선택됩니다. 존재 여부에 따라 'svn'(또는 둘 다) 디렉토리 아래의 .git 또는 .svn 하위 디렉토리 cloc이 호출되는 곳. --unicode 바이너리 파일에 유니코드가 포함되어 있는지 확인하세요. 확장된 ASCII 텍스트. 이로 인해 성능이 눈에 띄게 떨어집니다. 처리 옵션 --autoconf .in 파일 수(GNU autoconf에 의해 처리됨) 인식된 언어. --no-autogen도 참조하세요. --by-file 발견된 모든 소스 파일에 대한 결과를 보고합니다. --by-file-by-lang 발견된 모든 소스 파일에 대한 결과 보고 언어별 보고 외에 --config <파일> 대신 <파일>에서 명령줄 스위치를 읽습니다. 기본 위치는 /home/al/.config/cloc/options.txt입니다. 파일에는 다음과 같은 하나의 스위치가 포함되어야 합니다. 인수(있는 경우)(한 줄당). 빈 줄과 줄 '#'으로 시작하는 부분은 건너뜁니다. 에 주어진 옵션 명령줄은 읽은 항목보다 우선순위를 갖습니다. 파일. --개수 및 차이 먼저 소스 파일의 직접 코드 계산을 수행합니다. 과 를 별도로 분리한 다음 diff를 수행합니다. 이들 중. 입력은 파일, 디렉토리, 또는 아카이브. --out 또는 --report-file이 제공되면, 세 개의 출력 파일이 각각 하나씩 생성됩니다. 두 카운트 중 하나와 차이점에 대한 것입니다. 또한보십시오 --diff, --diff-alignment, --diff-timeout, --대소문자 무시, --공백 무시. --diff 코드와 주석의 차이를 계산합니다. 및 의 소스 파일입니다. 입력 파일, 디렉토리, 아카이브 등이 혼합되어 있을 수 있습니다. 또는 git commit 해시를 사용하세요. --diff-alignment를 사용하여 어떤 파일 쌍이 어디에 있는지 보여주는 목록을 생성합니다. 비교. git 브랜치를 비교할 때 파일만 두 커밋에서 변경된 사항이 비교됩니다. --git, --count-and-diff, --diff-alignment도 참조하세요. --diff-목록-파일, --diff-timeout, --ignore-case, --공백 무시. --diff-timeout 초 이상 걸리는 파일을 무시합니다. 처리합니다. 기본값은 10초입니다. 설정 0으로 설정하면 시간이 무제한으로 허용됩니다. (많은 파일이 포함된 대용량 파일 반복되는 줄은 Algorithm::Diff::sdiff()를 유발할 수 있습니다. 몇 시간이 걸릴 수 있습니다.) --timeout도 참조하세요. --docstring-as-code cloc는 독스트링을 주석으로 간주하지만 이는 독스트링은 정규를 나타내기 때문에 항상 정확하지는 않습니다. 문자열이 오른쪽에 나타날 때 할당 또는 함수 인수로. 이 스위치 독스트링을 코드로 간주하도록 강제합니다. --follow-links [Unix에만 해당] 디렉토리에 대한 기호 링크를 따릅니다. (파일에 대한 기호 링크는 항상 따라갑니다). --stat도 참조하세요. --force-lang=<언어>[, ] 확장자를 가진 모든 파일 처리 언어 에 대한 카운터를 사용합니다. 을 위한 예를 들어 모든 .f 파일 수를 계산하려면 Fortran 90 카운터(파일이 기본 Fortran 77 대신 .f90으로 끝남 카운터, 사용 --force-lang="포트란 90,f" 를 생략하면 모든 파일이 계산됩니다. 카운터를 사용합니다. 이 옵션은 다음과 같습니다. 여러 번 지정했습니다(그러나 이는 가 매번 제공될 때 유용합니다). --script-lang, --lang-no-ext도 참조하세요. --force-lang-def=<파일> <파일>에서 언어 처리 필터를 로드합니다. 내장된 필터 대신 이 필터를 사용하세요. 필터. 참고: 동일하게 매핑되는 언어 파일 확장자(예: MATLAB/Mathematica/Objective-C/MUMPS/머큐리; 파스칼/PHP; 리스프/오픈CL; 리스프/줄리아; 펄/프롤로그) 추가가 필요하므로 무시됩니다. 언어로 표현되지 않는 처리 정의 파일. --read-lang-def를 사용하여 정의 기본 제공을 교체하지 않고 새로운 언어 필터 필터(--write-lang-def 참조, --write-lang-def-incl-dup). --git 입력이 강제로 git 대상으로 해석되도록 합니다. (해시, 분기 이름 등을 커밋) 먼저 파일이나 디렉터리로 식별되지 않습니다. 이름. 이 옵션은 --vcs=git 논리를 재정의합니다. 이것이 주어지면; 즉, --git은 다음을 사용하여 git에서 직접 작업할 파일 목록 from이 아닌 해시 또는 지점 이름 'git ls-파일'. 이 옵션은 다음과 함께 사용할 수 있습니다. --diff git 사이의 라인 수 비교를 수행합니다. 커밋 또는 git 커밋과 파일 사이, 디렉토리 또는 아카이브. -v/--verbose를 사용하여 확인하세요. git 시스템 명령은 cloc 문제를 발생시킵니다. --git-diff-rel --git --diff와 동일하거나 입력이 있는 경우 --diff만 사용 git 대상으로 인식됩니다. 다음 파일만 두 커밋 중 변경된 사항이 비교됩니다. --git-diff-all Git diff 전략 #2: 다음의 모든 파일을 비교합니다. 두 커밋 사이의 저장소. --ignore-whitespace 파일을 비교할 때 가로 공백을 무시합니다. --diff를 사용합니다. --대소문자 무시도 참조하세요. --ignore-case 파일 내용 내 Case의 변경 사항을 무시합니다. 대문자와 소문자를 동일하게 고려하십시오. --diff로 파일을 비교할 때. 또한보십시오 --공백 무시. --ignore-case-ext 파일 이름 확장자의 대소문자를 무시합니다. 이것은 일부 언어를 계산하는 데 문제가 발생함 (구체적으로 .c 및 .C는 C와 연관되어 있으며 C++; 이 스위치는 .C 파일을 C로 계산합니다. *nix 운영 체제의 C++보다). 파일 이름 Windows에서는 대소문자를 구분하지 않습니다. --lang-no-ext= 을 사용하여 확장자가 없는 파일 수 계산 계수기. 이 옵션은 내부 논리를 재정의합니다. 확장자가 없는 파일의 경우(그러한 파일이 알려진 스크립팅 언어와 비교하여 확인됩니다. #!의 첫 번째 줄을 검사하여). 또한보십시오 --force-lang, --script-lang. --max-file-size= 다음과 같은 경우 MB보다 큰 파일을 건너뜁니다. 디렉토리 순회. 기본적으로 =100입니다. cloc의 메모리 요구 사항은 대략 20배입니다. 가장 큰 파일보다 크기 때문에 다음과 같이 실행됩니다. 용량이 적은 컴퓨터에서 100MB보다 큰 파일 2GB 이상의 메모리는 문제를 일으킬 수 있습니다. 참고: 이 검사는 파일에는 적용되지 않습니다. 명시적으로 명령줄 인수로 전달됩니다. --no-autogen[=list] 코드 생성 시스템에서 생성된 파일을 무시합니다. GNU autoconf와 같은 것입니다. 이 파일 목록을 보려면 (그런 다음 종료) --no-autogen list로 실행 --autoconf도 참조하세요. --original-dir [다음과 조합해서만 효과적입니다. --strip-comments] 제거된 파일 쓰기 원본 파일과 동일한 디렉토리에. --read-binary-files 텍스트 파일 외에 바이너리 파일도 처리합니다. 이는 일반적으로 나쁜 생각이므로 포함된 텍스트 파일로 시도했습니다. 바이너리 데이터. --read-lang-def= 에서 새 언어 처리 필터 로드 이미 cloc로 알려진 것과 병합합니다. 이 cloc이 이미 알고 있는 언어를 정의하는 경우 대략 cloc의 정의가 우선합니다. cloc을 재정의하려면 --force-lang-def를 사용하세요. 정의(--write-lang-def 참조, --write-lang-def-incl-dup). --script-lang= , 를 #!으로 호출하는 모든 파일을 처리합니다. 언어 카운터가 있는 스크립팅 언어 <언어>. 예를 들어 다음으로 시작하는 파일은 #!/usr/local/bin/perl5.8.8 다음을 사용하여 Perl 카운터로 계산됩니다. --script-lang=펄,펄5.8.8 언어 이름은 대소문자를 구분하지 않지만 스크립트 언어 실행 파일의 이름, 맞는 케이스가 있어야 합니다. 이 옵션은 다음과 같습니다. 여러 번 지정했습니다. --force-lang도 참조하세요. --lang-no-ext. --sdir=대신 을 스크래치 디렉터리로 사용합니다. File::Temp가 위치를 선택하도록 합니다. 파일 이 위치에 기록된 내용은 다음에서 제거되지 않습니다. 실행의 끝(File::Temp와 마찬가지로). --skip-uniqueness 파일 고유성 검사를 건너뜁니다. 이것은 줄 것이다 계산을 희생하여 성능 향상 동일한 내용이 여러 번 포함된 파일 (그러한 중복이 존재하는 경우). --stat 일부 파일 시스템(AFS, CD-ROM, FAT, HPFS, SMB) 일치하는 디렉터리 'nlink' 개수가 없습니다. 하위 디렉토리의 수. 따라서 cloc은 과소 계산되거나 완전히 건너뛸 수 있습니다. 그러한 파일 시스템의 내용. 이 스위치는 힘 파일::stat 디렉토리를 찾아 정확한 수. 파일 검색 속도가 감소합니다. --follow-links도 참조하세요. --stdin-name= 언어를 결정하는 데 사용할 파일 이름을 지정합니다. 표준 입력용. (-를 입력 이름으로 사용합니다. STDIN을 통해 소스 코드를 받습니다.) --strip-comments= 처리된 각 파일에 대해 현재 디렉토리 공백이 있는 파일 버전 주석 처리된 줄이 제거되었습니다(인라인 주석 지속). 제거된 각 파일의 이름은 원본 파일 이름에 . 가 추가됩니다. 그렇지 않은 경우에는 현재 디렉토리에 기록됩니다. --original-dir이 켜져 있습니다. --strip-str-comments 문자열에 포함된 주석 표시를 다음으로 교체합니다. '더블 엑스'. 이는 제한 사항을 해결하려고 시도합니다. Regexp::Common::Comment에서 주석 마커 문자열에 포함된 내용은 실제 주석으로 간주됩니다. 문자열이 아닌 마커로 인해 종종 '복잡한 정규 하위 표현식 재귀 제한' 경고 및 잘못된 계산. 두 가지가 있습니다 이 스위치 사용의 단점: 1/코드 수 성능 저하 및 2/코드 생성 --strip-comments에는 다른 문자열이 포함됩니다. 삽입된 댓글이 발견된 곳. --sum-reports 입력 인수는 이전에는 보고서 파일이었습니다. 일반에서 --report-file 옵션을 사용하여 생성됨 형식(예: JSON, YAML, XML 또는 SQL이 아님). 다음을 포함하는 누적 결과 집합을 만듭니다. 개별 보고서 파일의 데이터 합계입니다. --timeout 초 이상 걸리는 파일을 무시합니다. 언어의 필터 단계에서 처리합니다. 기본 최대 시간(초) 필터 단계는 파일의 줄 수입니다. 1천으로 나눕니다. 을 0으로 설정하면 시간 무제한. --diff-timeout도 참조하세요. --processes=NUM [최신 버전이 설치된 시스템에서만 사용 가능 Parallel::ForkManager 모듈의 아니다 Windows에서 사용 가능합니다.] 최대 개수를 설정합니다. cloc이 사용하는 코어. 기본값은 0입니다. 다중 처리를 비활성화합니다. --unix 운영 체제 자동 감지 무시 로직을 실행하고 UNIX 모드에서 실행합니다. 또한보십시오 --windows, --show-os. --use-sloccount SLOCCount가 설치된 경우 컴파일된 항목을 사용합니다. 실행 파일 c_count, java_count, pascal_count, cloc 대신 php_count 및 xml_count 카운터. SLOCCount의 컴파일된 카운터는 다음과 같습니다. cloc보다 상당히 빠르며 다음을 제공할 수 있습니다. 프로젝트 계산 시 성능 개선 큰 파일로. 그러나 이러한 시계 특정 기능을 사용할 수 없습니다: --diff, --count-and-diff, --strip-comments, --unicode. --windows 운영 체제 자동 감지를 재정의합니다. Microsoft Windows 모드에서 논리를 실행하고 실행합니다. --unix, --show-os도 참조하세요. 필터 옵션 --include-content= 일치하는 텍스트가 포함된 파일만 계산합니다. 정규 표현식이 주어졌습니다. --exclude-content= 주어진 내용과 일치하는 텍스트가 포함된 파일을 제외합니다. 정규식. --exclude-dir= [,D2,] 쉼표로 구분된 특정 디렉터리를 제외합니다. D1, D2, D3 등은 스캔되지 않습니다. 을 위한 예 --exclude-dir=.cache, 테스트는 건너뜁니다. /.cache/가 있는 모든 파일 및 하위 디렉터리 또는 /test/를 상위 디렉터리로 사용합니다. .bzr, .cvs, .hg, .git, .svn이라는 디렉터리 및 .snapshot은 항상 제외됩니다. 이 옵션은 개별 디렉터리에서만 작동합니다. 이름이므로 파일 경로 구분 기호를 포함하는 것은 아닙니다. 허용된. --fullpath 및 --not-match-d= 사용 여러 하위 디렉터리와 일치하는 정규식을 제공합니다. --exclude-ext= [, [...]] 주어진 파일 이름을 가진 파일을 계산하지 않음 확장. --exclude-lang= [,L2[...]] 지정된 쉼표로 구분된 언어 제외 L1, L2, L3 등은 계산되지 않습니다. --exclude-list-file= 이름이 다음과 같은 파일 및/또는 디렉터리를 무시합니다. <파일>에 나타납니다. 에는 하나의 파일이 있어야 합니다. 한 줄에 이름. 정확히 일치하는 항목만 무시됩니다. 상대 경로 이름은 다음에서 시작하여 확인됩니다. cloc이 호출되는 디렉토리입니다. --list-file도 참조하세요. --fullpath --match-f, --not-match-f의 동작을 수정합니다. 파일 경로를 포함하려면 --not-match-d 파일의 기본 이름뿐만 아니라 정규식에서. (이렇게 하면 각 파일이 해당 파일을 포함하도록 확장되지 않습니다. 절대 경로 대신에 cloc에 전달되는 경로입니다.) 참고: --match-d는 항상 전체를 확인합니다. path이므로 --fullpath의 영향을 받지 않습니다. --include-ext= [,ext2[...]] 주어진 쉼표가 있는 언어만 계산합니다. 분리된 파일 확장자. --show-ext를 사용하여 인식된 확장자를 확인하세요. --include-lang= [,L2[...]] 주어진 쉼표로 구분된 언어만 계산합니다. L1, L2, L3 등. --show-lang을 사용하여 확인하세요. 인식되는 언어 목록. --match-d= Perl과 일치하는 디렉토리의 파일만 계산합니다. 정규식. 예를 들어 --match-d='/(src|포함)/' 다음을 포함하는 디렉터리의 파일만 계산합니다. /src/ 또는 /include/. --not-match-d와 달리, --match-f, --not-match-f, --match-d 항상 정규화된 경로를 정규식. --not-match-d= 디렉토리에 있는 파일을 제외한 모든 파일 수 계산 Perl 정규식과 일치합니다. 후행만 예를 들어 다음과 같은 경우 디렉터리 이름이 비교됩니다. /usr/local/lib에서 계산하면 'lib'만 정규식과 비교. 상위 디렉토리를 비교하려면 --fullpath를 추가하세요. 정규식. 파일 경로 분리기를 포함하지 마십시오 Regex의 시작 또는 끝. --match-f = 베이스 이름이 Perl과 일치하는 파일 만 계산합니다 리그 즈. 예를 들어 --match-f = '^[ww] idget' 위젯 또는 위젯으로 시작하는 파일 만 계산합니다. 추가 -부모 디렉토리를 포함시키기 위해 add 베이스 이름 대신 regex에서. -매치 -F = 베이스 이름을 제외한 모든 파일을 계산하십시오 Perl Regex와 일치하십시오. add-fullpath를 포함하십시오 정당한 대신 동정형의 학부모 디렉토리 베이스 이름. ---skip-archive = 주어진 perl 일반으로 끝나는 파일을 무시합니다. 표현. 예를 들어, 주어진 경우 ---skip-archive = '(zip | tar (. (gz | z | bz2 | xz | 7z))' ' 코드는 .zip으로 끝나는 파일을 건너 뜁니다. .tar, .tar.gz, .tar.z, .tar.bz2, .tar.xz 및 .TAR.7Z. -Skip-Win-Hidden Windows에서 숨겨진 파일을 무시하십시오. 디버그 옵션 -Categorized = 파일 크기를 바이트, 식별 된 언어로 저장합니다 분류 된 파일의 이름 . -카운트 = 처리 된 소스 파일의 이름을 로 저장합니다. --diff-alignment = 파일 및 파일 쌍 목록에 쓰기 어떤 파일이 추가, 제거되었는지 및/또는 -diff와 달리기 중 비교. 이 스위치 -diff 모드를 켜십시오. --explain = 주석을 제거하는 데 사용되는 필터를 인쇄하십시오 언어 및 출구. 어떤 경우에는 필터는 Perl Subroutines가 아닌 Perl Subroutine을 나타냅니다 정규 표현. 검사 추가 설명을 위해서는 소스 코드가 필요할 수 있습니다. -헬프이 사용 정보를 인쇄하고 종료하십시오. -found = 발견 된 모든 파일의 이름을 에 저장합니다. -ignored = 무시 된 파일의 이름을 저장하고 그 이유 로 무시되었습니다. -프린트 필터-스테이지 전후에 처리 된 소스 코드를 인쇄합니다 각 필터가 적용됩니다. -show-ext [= ] 모든 알려진 (또는 그냥 주어진) 파일 확장 및 종료. -쇼-랭 [= ] 모든 알려진 (또는 그냥 주어진) 언어 및 종료. -쇼 -OS 운영 체제 모드의 값을 인쇄합니다 그리고 종료. -Unix, -windows도 참조하십시오. -v [= ] Verbose Switch (선택적 숫자 값). -verbose [= ] 긴 형태의 -v. -Version이 프로그램의 버전을 인쇄하고 종료하십시오. -write-lang-def = 은 언어 처리 필터 에 씁니다 그런 다음 종료합니다. 창조의 첫 단계로 유용합니다 맞춤 언어 정의. 참고 : 언어 동일한 파일 확장자에 대한지도는 제외됩니다. (또한 -force-lang-def, -read-lang-def 참조). -write-lang-def-incl-dup = -write-lang-def와 동일하지만 복제 된 포함 확장. 이것은 문제가있는 언어를 생성합니다 CLOC가 사용을 거부하기 때문에 정의 파일 복제가 제거 될 때까지. 출력 옵션 -3 인쇄 3 세대 언어 출력. (이 옵션으로 인해 보고서 요약이 실패 할 수 있습니다 이 옵션으로 일부 보고서가 작성된 경우 다른 사람들은 그것 없이는 생산되었습니다.) -댓글과 빈 줄 카운트 대신 x를 보여주십시오. 이 값은 값을 기준으로 백분율입니다 분모의 X : x = 'c' -> # 코드 줄 x = 'cm' -> # 코드 줄 + 댓글 x = 'CB' -> # 코드 + 블랭크 라인 x = 'cmb' -> # 코드 줄 + 댓글 + blanks 예를 들어, 메소드 'C'와 코드를 사용하는 경우 라인보다 두 배나 많은 주석이 있습니다 코드의, 주석 열의 값은 200%입니다. 코드 열은 줄 수 있습니다. -CSV 결과를 쉼표로 분리 된 값으로 작성합니다. --csv-delimiter = 문자 를 쉼표의 구분 기자로 사용하십시오. 대신 분리 된 파일. 이 스위치는 -CSV가 켜져 있습니다. -file-encoding = 인코딩을 사용하여 출력 파일 쓰기 기본 ASCII ( = 'UTF-7'). 예 : 'UTF-16', 'euc-kr', 'ISO-8859-16'. 알려진 인코딩이 될 수 있습니다 인쇄 perl -mencode -e 'print join ( " n", encode-> encodings ( ": all")), " n"' -헤드 비율은 라인과 파일 처리 속도를 표시하지 않습니다. 출력 헤더. 이것은 출력 결정 론적입니다. -json은 결과를 javaScript 객체 표기법으로 작성합니다 (JSON) 서식 출력. -md 결과를 Markdown 형식 텍스트로 씁니다. -out = -report-file = 의 동의어. --progress-rate = 모든 파일이 끝난 후 진행 업데이트를 표시합니다 처리 된 (기본 = 100). 을 0으로 설정하십시오 진행 출력을 억제합니다 (리디렉션 할 때 유용합니다 stdout에 출력). -Quiet은 제외한 모든 정보 메시지를 억제합니다 최종 보고서. -report-file = stdout 대신 결과를 에 씁니다. -sql = sql을 작성하고 삽입하여 결과를 쓰십시오 다음과 같은 데이터베이스 프로그램에서 읽을 수 있습니다. sqlite. 이면 -출력이 stdout으로 전송됩니다. -SQL-Append Append SQL 삽입 문을 지정된 파일에 삽입하십시오 -sql로 테이블 생성을 생성하지 마십시오 진술. -sql 옵션으로 만 유효합니다. ---sql-project = 을 프로젝트 식별자로 사용하십시오 현재 실행. -sql 옵션으로 만 유효합니다. -sql-style = 주어진 스타일로 SQL 문을 작성하십시오 기본 sqlite 형식의 스타일은 포함됩니다 'Oracle'및 'named_columns'. -일반 텍스트 보고서의 경우 SUM-ONE, SOM : Output Line 표시 하나의 입력 파일 만 처리 되더라도. -XML 결과를 XML로 작성합니다. -xsl = 참조 내면의 XSL 스타일 시트로 XML 출력. 이 1 (숫자)이면 기본 스타일 시트, cloc.xsl (또는 cloc-diff.xsl-diff가 제공되면). 이 스위치는 -xml을 켜야합니다. --yaml yaml에 결과를 쓰십시오.
프롬프트> Cloc-쇼어 랭 ABAP (ABAP) ActionScript (AS) ADA (ADA, ADB, 광고, PAD) ADSO/IDSM (ADSO) Agda (Agda, Lagda) 충분한 (충분한, 도피, 스타트 업) Ansprolog (LP) Ant (build.xml, build.xml) Antlr 문법 (G, G4) 에이펙스 클래스 (CLS) 에이펙스 트리거 (트리거) APL (APL, APLA, APLC, APLF, APLI, APLN, APLO, DYALOG, DYAPP, MIPAGE) 사과 스크립트 (사과) Arduino 스케치 (INO) 방주 (ETS) 아르투로 (Art) Asciidoc (Adoc, Asciidoc) ASP (ASA, ASHX, ASP, AXD) ASP.NET (ASAX, ASCX, ASMX, ASPX, MASTER, SITEEMAP, WEBINFO) SAGON (AJ) 어셈블리 (A51, ASM, NASM, S, S) Astro (Astro) ASYPTOTE (ASY) Autohotkey (AHK, AHKL) awk (auk, awk, gawk, mawk, nawk) 바젤 (빌드) 비즈 토크 오케스트레이션 (ODX) Biztalk 파이프 라인 (BTP) 블레이드 (블레이드, 블레이드) Bourne Again Shell (Bash) Bourne Shell (SH) 브라이트 스크립트 (BRS) 빌더 (xml.builder) C (C, Cats, EC, IDC, PGC) C 쉘 (CSH, TCSH) C# (CS) C# 디자이너 (Designer.cs) C ++ (C, C ++, C ++ M, CC, CCM, CPP, CPP, CPPM, CXX, CXXM, H ++, INL, IPP, IXX, PCC, TCC, TPP) C/C ++ 헤더 (H, H, HH, HPP, HXX) 카이로 (카이로) 케이크 빌드 스크립트 (케이크) 탄소 (탄소) CCS (CCS) 예배당 (chpl) Circom (Circom) 청소 (DCL, ICL) Clojure (Boot, Cl2, Clj, Cljs.hl, Cljscm, Cljx, HIC, Riemann.config) Clojurec (CLJC) clojurescript (cljs) cmake (cmake, cmake.in, cmakelists.txt) COBOL (CBL, CBL, CCP, COB, COB, COBOL, CPY) 코코아 5 (C5, Cocoa5, Cocoa5server, CPKG5) 커피 스크립트 (_coffee, CakeFile, CJSX, 커피, 아이스) 콜드 퓨전 (CFM, CFML) Coldfusion CFScript (CFC) 제약 문법 (CG3, RLX) 컨테이너 파일 (컨테이너 파일) COQ (V) 크리스탈 (CR) CSON (CSON) CSS (CSS) CSV (CSV) 오이 (기능) CUDA (CU, CUH) Cython (PXD, PXI, PYX) d (d) dafny (dfy) 달 (DA) 다트 (다트) 델파이 양식 (DFM) DENIZENSCRIPT (DSC) derw (derw) Dhall (Dhall) 다이어트 (DT) diff (diff, patch) 디타 (디타) dockerfile (dockerfile, dockerfile) 문 확장 언어 (DXL) DOS 배치 (Bat, Bat, BTM, BTM, CMD, CMD) 침포 (DRL) DTD (DTD) dtrace (d) ECPP (ECPP) EEX (EEX) EJS (EJS) elixir (ex, ex) Elm (Elm) 임베디드 크리스탈 (ECR) ERB (ERB, ERB) Erlang (App.Src, Emakefile, Erl, Hrl, Rebar.config, Rebar.config.lock, Rebar.lock, XRL, YRL) 기대 (exp) F# (FSI, FS, FS) F# 스크립트 (FSX) 회향 (FNL) 유한 주 언어 (FSL, JSSM) 물고기 껍질 (물고기) 플랫 버퍼 (FBS) 포커스 (focexec) Forth (4th, e4, f83, fb, forth, fpm, fr, frt, ft, fth, rx, fs, f, f, for) FORTRAN 77 (F, F77, F77, for, ftn, ftn, pfo, f, for) Fortran 90 (F90, F90) Fortran 95 (F95, F95) 프리 마커 템플릿 (FTL) Futhark (FUT) FXML (FXML) gdscript (GD) Gencat NLS (MSG) Glade (Glade, UI) 빛나는 (빛나는) Glimmer JavaScript (GJS) Glimmer Typescript (GTS) glsl (comp, fp, frag, frg, fsh, fshader, geo, geom, glsl, glslv, gshader, tesc, tese, vert, vrx, vsh, vshader) 가서 (go, ʕ◔ϖ◔ʔ) Godot Resource (TRES) Godot 장면 (TSCN) Godot Shaders (gdshader) Gradle (Gradle, gradle.kts) 성배 (GSP) GraphQL (GQL, GraphQL, GraphQL) Groovy (Gant, Groovy, Grt, Gtpl, Gvy, Jenkinsfile) Haml (Haml, Haml.deface) 핸들 바 (핸들 바, HBS) 항구 (HB) 헤어 (ha) Haskell (HS, HSC, LHS) Haxe (HX, HXSL) HCL (HCL, 유목민, TF, TFVARS) HLSL (CG, CGINC, FXH, HLSL, HLSLI, SHADER) 홀리 (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) 설치실 (ISM) ipl (ipl) Jai (Jai) Janet (Janet) 자바 (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 템플릿 (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.BECL, TONCOJSON, WATCHONFIG, WebApp, WebManifest, yyp) JSON5 (JSON5) JSP (JSP, JSPF) JSX (JSX) 줄리아 (JL) 주니퍼 주노스 (Junos) Jupyter Notebook (Ipynb) 커미트 (KSC) Korn Shell (KSH) Kotlin (KT, KTM, KTS) Kvlang (KV) 린 (hlean, 린) LEM (LEM) 덜 (적음) 렉스 (L, Lex) lfe (lfe) 링커 스크립트 (LD) 액체 (액체) LISP (ASD, EL, LISP, LSP, CL, JL) 문맹 IDRIS (LIDR) livelink oscript (oscript) LLVM IR (LL) 로고 (X, XM) Logtalk (LGT, Logtalk) LUA (Lua, NSE, P8, PD_LUA, RBXS, WLUA) 루우 (루아) M4 (AC, M4) Make (Am, Gnumakefile, Gnumakefile, Makefile, Makefile, MK) 마코 (마코, 마오) Markdown (Contents.lr, Markdown, MD, Mdown, MDWN, MDX, MKD, MKDN, MKDOWN, RONN, WORKBOOK) Mathematica (CDF, MA, Mathematica, MT, NBP, WL, WLT, M) MATLAB (M) Maven (pom, pom.xml) Meson (Meson.build) 금속 (금속) Modelica (MO) modula3 (i3, Ig, M3, Mg) 모조 (모조,?) Mojom (Mojom) MSBuild 스크립트 (Btproj, CSProj, MSBuild, VCProj, WDPROJ, WIXPROJ) 유행성 이증 (MPS, M) 콧수염 (콧수염) MXML (MXML) Nant 스크립트 (빌드) Nastran DMAP (DMAP) 네머 (N) Netlogo (Nlogo, NLS) 니켈 (NCL) NIM (NIM, NIM.CFG, NIMBLE, NIMROD, NIMS) 닉스 (닉스) Nunjucks (NJK) 대상 C (M) 목표 C ++ (MM) OCAML (Eliom, Eliomi, ML, ML4, MLI, MLL, MLY) 오딘 (오딘) Opencl (CL) OpenSCAD (SCAD) 오라클 형태 (FMT) Oracle PL/SQL (BOD, FNC, PRC, SPC, TRG) Oracle Reports (Rex) P4 (P4) Pascal (DPR, LPR, PAS, PASCAL) 파스칼/폰 (P) 파스칼/꼭두각시 (pp) Patran Command Language (PCL, SES) 전당포 (Pawn, Pwn) 페그 (페그) PEG.JS (PEGJS) 페기 (페기) Perl (ACK, AL, CPANFILE, MAKEFILE.PL, PERL, PH, PLH, PLX, PM, PSGI, Rexfile, PL, P6) 해충 (해충) PHP (AW, CTP, PHAKEFILE, PHP, PHP3, PHP4, PHP5, PHP_CS, PHP_CS.DIST, PHPS, PHPT, PHTML) PHP/PASCAL/FORTRAN/PAWN (INC) 돼지 라틴어 (돼지) PL/I (PL1) PL/M (Lit, PLM) plantuml (iuml, plantuml, pu, puml, wsd) PO 파일 (PO) 조랑말 (조랑말) PowerBuilder (PBT, SRA, SRF, SRM, SRS, SRU, SRW) PowerShell (PS1, PSD1, PSM1) 프리즘 스키마 (Prisma) 처리 (PDE) Proguard (Pro) 프롤로그 (P, Prolog, Yap, PL, P6, Pro) 속성 (속성) 프로토콜 버퍼 (프로토) PRQL (PRQL) 퍼그 (Jade, Pug) Purescript (Purs) Python (Buck, build.bazel, gclient, gyp, gypi, lmi, py, py3, pyde, pyi, pyp, pyt, pyw, sconscript, snakefile, tac, wscript, wscript, wsgi, xpy) QML (QBS, QML) QT (UI) QT 언어 학자 (TS) QT 프로젝트 (Pro) R (Expr-Dist, R, R, Rd, Rprofile, RSX) 라켓 (RKT, RKTD, RKTL, SCRBL) Raku (PM6, Raku, Rakumod) Raku/Prolog (P6, P6) RAML (RAML) rapydscript (pyj) 면도기 (CSHTML, Razor) rasyml (re, rei) Rescript (res, resi) 구조 조정 텍스트 (REST, REST.TXT, RST, RST.TXT) Rexx (PPRX, Rexx) 링 (Rform, RH, 링) RMD (RMD) 로봇 프레임 워크 (로봇) Ruby (평가, Berksfile, Brewfile, Builder, Buildfile, Capfile, Dangerfile, Deliverfile, Eye, Fastfile, gemfile, gemfile.lock, gemspec, god, guardfile, jarfile, jbuilder, mavenfile, mspec, podfile, podspec, pryspec, pryspec, pryspec, podfile. Puppetfile, Rabl, Rake, RB, Rbuild, RBW, RBX, RU, Snapfile, Thor, Thorfile, Vagrantfile, WatchR) 루비 HTML (RHTML) 녹 (Rs, Rs.in) 솔트 스택 (SLS) SAS (SAS) Sass (Sass) Scala (Kojo, SBT, Scala) 체계 (SC, SCH, SCM, SLD, SPS, SS, SLS) SCSS (SCSS) sed (sed) 기술 (IL) 스킬 ++ (ILS) 슬라이스 (얼음) 슬림 (슬림) 슬린트 (슬린트) SmallTalk (ST, CS) Smarty (Smarty, TPL) Snakemake (규칙, SMK) Softbridge Basic (SBL, SBL) 견고성 (SOL) Sparforte (SP) 사양 E (E) SQL (CQL, MySQL, PSQL, SQL, SQL, Tab, UDF, VIW) SQL 데이터 (data.sql) SQL 저장 프로 시저 (spc.sql, spoc.sql, sproc.sql, udf.sql) 다람쥐 (너트) 표준 ML (재미, SIG, SML) Starlark (Bazel, BZL) stata (ado, do, do, doh, ihlp, mata, matah, sthlp) 스타일러스 (스타일) 설탕 (SSS) svelte (svelte) SVG (SVG, SVG) 스위프트 (스위프트) Swig (I) 테이블 겐 (TD) TCL/TK (ITK, TCL, TK) 청록색 (청록색) TeamCenter Met (Met) TeamCenter Mth (Mth) 템플 (템플) Tex (aux, bbx, bib, bst, cbx, dtx, ins, lbx, ltx, mkii, mkiv, mkvi, sty, tex, cls) 텍스트 (텍스트, txt) 중고품 (중고품) 타이탄 프로젝트 파일 정보 (TPD) 티타늄 스타일 시트 (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) 나뭇 가지 (나뭇 가지) TypeScript (MTS, TSX, TS) typst (typ) Umka (음) Unity-Prefab (Mat, Prefab) 발라 (발라) 발라 헤더 (VAPI) 응용 프로그램 용 VB (VBA, VBA) 속도 템플릿 언어 (VM) Verilog-Systemverilog (SV, SVH, V) VHDL (VHD, VHD, VHDL, VHDL, VHF, VHI, VHO, VHS, VHT, VHT, VHW) 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) 비주얼 스튜디오 솔루션 (SLN) Visualforce 구성 요소 (구성 요소) Visualforce 페이지 (페이지) vuejs 구성 요소 (vue) Vyper (VY) 웹 서비스 설명 (WSDL) WebAssembly (WAST, WAT) WGSL (WGSL) Windows 메시지 파일 (MC) Windows 모듈 정의 (DEF) Windows 리소스 파일 (RC, RC2) Wix 포함 (WXI) wix 소스 (WXS) WIX 현지화 (WXL) WXML (WXML) WXSS (WXSS) x ++ (XPO) XAML (XAML) Xbase (PRG, PRW) Xbase 헤더 (CH) XHTML (XHTML) XMI (XMI, XMI) XML (ADML, ADMX, Ant, App.Config, AXML, 빌드, CCPROJ, CCXML, ClassPath, Clixml, CPROJECT, CSCFG, CSDEF, CSL, CT, DEPPROJ, DITAMAP, DITAVAL, DLL.CONFIG, DOTSTINGS, FSPROJ, FSPROJ, FSPROJ. GMX, GRXML, IML, IVY, Jelly, JSProj, KML, LANCE, MDPOLICY, MJML, NATVIS, NDPROJ, NPROJ, NUGET.CONFIG, NUSPEC, OSM, PACKAGES.CONFIG, PKGPROJ, PLIST, PROCJ, PROPS, PROP, Props, Props, Props. PS1XML, PSC1, PT, RDF, RESX, RSS, SCXML, SETTINGS.STYLECOP, SFPROJ, SHPROJ, SRDF, 스토리 보드, sttheme, Sublime-Snippet, Targets, TMCommand, TML, TMLANGURAGE, TMPREFERENCES, TMSNIPPET, TMTEME, URDFEME, URDFEN vcxproj, vsixmanifest, vssettings, vstemplate, vxml, web.config, web.debug.config, web.release.config, wsf, x3d, xacro, xib, xliff, xml, xml, xml.dist, xproj, xproj, Xul, ZCML) xquery (xq, xql, xqm, xquery, xqy) XSD (XSD, XSD) XSLT (XSL, XSL, XSLT, XSLT) XTEND (XTEND) YACC (Y, YACC) Yaml (Clang-format, Clang-tidy, gemrc, glide.lock, mir, reek, rviz, sublime-syntax, syntax, yaml, yaml-tmlanguage, yml, yml.mysql) 양 (양) 지그 (zig) ZSH (ZSH)
위 목록은 --read-lang-def 또는 --force-lang-def 옵션이있는 파일에서 언어 정의를 읽음으로써 사용자 정의 할 수 있습니다.
이 파일 확장자는 여러 언어에 매핑됩니다.
cl 파일은 LISP 또는 OpenCL 일 수 있습니다cls 파일은 Visual Basic, Tex 또는 Apex 클래스 일 수 있습니다.cs 파일은 C# 또는 SmallTalk 일 수 있습니다d 파일은 d 또는 dtrace 일 수 있습니다f 파일은 Fortran 77 또는 Forth 일 수 있습니다fnc 파일은 Oracle PL 또는 SQL 일 수 있습니다for Fortran 77 또는 Forth 일 수 있습니다fs 파일은 F# 또는 Forth 일 수 있습니다inc 파일은 PHP 또는 Pascal 일 수 있습니다itk 파일은 tcl 또는 tk 일 수 있습니다jl 파일은 LISP 또는 Julia 일 수 있습니다lit 파일은 pl 또는 m 일 수 있습니다m 파일은 Matlab, Mathematica, Objective-C, Mumps 또는 Mercury 일 수 있습니다.p6 파일은 Perl 또는 Prolog 일 수 있습니다pl 파일은 Perl 또는 Prolog 일 수 있습니다PL 파일은 Perl 또는 Prolog 일 수 있습니다pp 파일은 Pascal 또는 Puppet 일 수 있습니다pro 파일은 IDL, QT Project, Prolog 또는 Proguard 일 수 있습니다.ts 파일은 TypeScript 또는 QT 언어학 자일 수 있습니다ui 파일은 QT 또는 Glade 일 수 있습니다v 파일은 Verilog-Systemverilog 또는 COQ 일 수 있습니다CLOC에는이 특별한 경우에 대한 파일의 내용을 기반으로 올바른 언어를 식별하려는 서브 루틴이 있습니다. 언어 식별 정확도는 파일에 포함 된 코드의 양의 함수입니다. 예를 들어 .M 파일은 예를 들어, 한 줄만 한 두 줄만있는 파일에는 Matlab, Mercury, Mumps 또는 Objective-C를 올바르게 구별하기에 충분한 정보가 거의 없습니다.
파일 확장 충돌이있는 언어는 공통 확장을 가진 언어를 식별 할 수있는 메커니즘이 없으므로 --read-lang-def 또는 --force-lang-def 로 사용자 정의하기가 어렵습니다. 이 상황에서는 CLOC 소스 코드를 수정해야합니다.
Cloc의 작동 방법은 Sloccount의 것과 유사합니다. 첫째, 고려할 파일 목록을 만듭니다. 다음으로 파일을 찾은 여부를 확인하려고 시도하십시오. 파일에 인식 된 컴퓨터 언어 소스 코드가 포함되어 있는지 확인하십시오. 마지막으로 소스 파일로 식별 된 파일의 경우 언어 별 루틴을 호출하여 소스 라인 수를 계산합니다.
더 자세한 설명 :
입력 파일이 아카이브 (예 : .tar.gz 또는 .zip 파일) 인 경우 임시 디렉토리를 작성하고 시스템 호출을 사용하여 적절한 기본 유틸리티 (TAR, BZIP2, UNZIP 등)를 사용하여 아카이브를 확장 한 다음 추가하십시오. 이 임시 디렉토리는 입력 중 하나입니다. (이것은 Windows보다 Unix에서 더 안정적으로 작동합니다.)
파일 사용 :: 입력 디렉토리를 재귀 적으로 내려와 후보 파일 이름 목록을 작성하십시오. 이진 및 제로 크기의 파일을 무시하십시오.
후보자 목록의 파일에 고유 한 내용이 있는지 확인하십시오 (먼저 파일 크기를 비교하여 유사하게 크기가 크기를 비교하여 파일 내용의 MD5 해시를 Digest :: MD5와 비교하십시오). 동일한 파일의 각 세트에 대해 어휘 정렬에 의해 결정된 첫 번째 사본을 제외한 모든 사본을 제거하여 세트의 동일한 파일을 제거하십시오. 제거 된 파일은 보고서에 포함되어 있지 않습니다. ( --skip-uniqueness 스위치는 독창성 테스트를 비활성화하고 보고서에 포함되도록 모든 파일의 모든 사본을 강제로 포함합니다.) --ignored= switch를 참조하여 어떤 파일이 무시되었고 그 이유를 확인하십시오.
CLOC가 프로그래밍 언어와 관련된 파일 확장자에 대한 후보 파일 목록을 스캔하십시오 ( --show-lang 및 --show-ext 옵션 참조). 일치하는 파일은 해당 언어의 소스 코드를 포함하는 것으로 분류됩니다. 확장이없는 각 파일이 열리고 첫 번째 줄은 UNIX 쉘 스크립트인지 확인하기 위해 읽습니다 ( #!로 시작하는 모든 것). 쉘 스크립트 인 경우 파일은 해당 스크립팅 언어로 분류됩니다 (언어가 인식되는 경우). 파일에 인식 된 확장자가 없거나 인식 된 스크립팅 언어가없는 경우 파일은 무시됩니다.
후보 목록의 나머지 파일은 이제 알려진 프로그래밍 언어의 소스 파일이어야합니다. 이 파일 각각에 대해 :
옵션은 알고리즘을 약간 수정합니다. 예를 들어 --read-lang-def 옵션을 사용하면 사용자가 주석 필터, 알려진 파일 확장자 및 파일에서 알려진 스크립팅 언어의 정의를 읽을 수 있습니다. 이 옵션의 코드는 2 단계와 3 단계 사이에서 처리됩니다.
CLOC가 의견을 올바르게 식별하는지 어떻게 알 수 있습니까? CLOC가 올바른 일을하는 것 중 하나는 --strip-comments 옵션을 사용하여 파일에서 주석과 빈 줄을 제거한 다음 박탈 파일을 원본과 비교하는 것입니다.
헤더 파일과 함께 SQLITE 라이브러리를 빌드하는 데 필요한 모든 코드가 포함 된 C 파일 인 SQLITE Amalgamation을 사용하여 시도해 봅시다.
프롬프트> 타르 ZXF SQLITE-AMALGAMATION-3.5.6.tar.gz
프롬프트> CD SQLITE-3.5.6/
프롬프트> cloc-strip-comments = nc sqlite.c
1 텍스트 파일.
1 고유 한 파일.
sqlite3.c.nc를 썼습니다
0 파일이 무시되었습니다.
http://cloc.sourceforge.net v 1.03 t = 1.0 s (1.0 파일/s, 82895.0 줄/s)
------------------------------------- ---------------------------------
언어 파일 빈 댓글 코드 규모 3 세대. equiv
------------------------------------- ---------------------------------
C 1 5167 26827 50901 x 0.77 = 39193.77
------------------------------------- ---------------------------------
-스트립 컴포먼트에 주어진 확장 인수는 임의적이다. 여기서 NC는 "주석 없음"에 대한 약어로 사용되었습니다.
Cloc은 파일에서 31,000 줄 이상을 제거했습니다.
프롬프트> wc -l sqlite3.c sqlite3.c.nc 82895 sqlite3.c 50901 SQLITE3.C.NC 총 133796 프롬프트> echo "82895-50901"| 기원전 31994
이제 원본 파일 인 sqlite3.c와 diff 또는 vimdiff와 같은 도구와 sqlite3.c.nc를 제거하고 댓글과 빈 줄을 정확히 고려한 것을 볼 수 있습니다. 제거 된 파일에 원본과 동일한 C 코드가 포함되어 있다는 엄격한 증거는 이러한 파일을 컴파일하고 결과 객체 파일의 체크섬을 비교하는 것입니다.
먼저 원본 소스 파일 :
프롬프트> gcc -c sqlite3.c 프롬프트> MD5SUM SQLITE3.O CCE5F1A27C7E44B2E1047E2588B49 SQLITE3.O
다음으로 댓글이없는 버전 :
프롬프트> MV SQLITE3.C.NC SQLITE3.C 프롬프트> gcc -c sqlite3.c 프롬프트> MD5SUM SQLITE3.O CCE5F1A27C7E44B2E1047E2588B49 SQLITE3.O
CLOC는 31,000 줄 이상의 주석과 공백을 제거했지만 결과 객체 파일이 원본과 일치하기 때문에 소스 코드를 중요한 방식으로 수정하지 않았습니다.
v1.07 이전의 CLOC 버전에는 CLOC에 아카이브 파일을 확장하는 방법을 알려주는 --extract-with=CMD 옵션이 필요했습니다. v1.07부터 시작하여 이것은 추출이 자동으로 시도됩니다. 현재 자동 추출 방법은 다음 파일 유형에 대해 Unix-Type OS에서 합리적으로 잘 작동합니다. .tar.gz , .tar.bz2 , .tar.xz , .tgz , .zip , .ear , .deb . 이러한 확장자 중 일부는 기본 위치에 WinZip이 설치된 경우 Windows에서 작동합니다 ( C:Program FilesWinZipWinZip32.exe ). 또한 최신 버전의 winzip을 사용하면 올바른 작업을 위해서는 [http://www.winzip.com/downcl.htm]이 필요합니다. 이 경우 하나는
--extract -with = ""c : program files winzip winzip "-e -o> file <."
참조. http://sourceforge.net/projects/cloc/forums/forum/600963/topic/4021070?message=8938196
자동 추출이 실패하는 상황에서는 TAR 파일, ZIP 파일 또는 추출 도구가있는 다른 압축 아카이브 내에서 코드 줄을 계산하기 위해 --extract-with=CMD 옵션을 시도해 볼 수 있습니다. CLOC는 사용자가 제공하는 추출 명령을 가져 와서 아카이브를 임시 디렉토리 (File :: Temp로 생성)로 확장하고 임시 디렉토리에 코드 줄을 계산 한 다음 해당 디렉토리를 제거합니다. 단일 압축 아카이브를 다룰 때 특히 도움이되지는 않지만 (결국, 추출 명령을 입력하려면 어쨌든 아카이브를 수동으로 확장하지 않는 이유는 무엇입니까?)이 옵션은 여러 아카이브를 한 번에 작업하는 데 편리합니다.
예를 들어, 유닉스 머신에 다음과 같은 소스 Tarballs가 있다고 가정 해보십시오.
perl-5.8.5.tar.gz
Python-2.4.2.tar.gz
그리고 당신은 그 안에있는 모든 코드를 계산하고 싶습니다. 명령은 될 것입니다
cloc -extract -with = 'gzip -dc> file <| 타르 XF- 'perl-5.8.5.tar.gz python-2.4.2.tar.gz
UNIX 기계에 GNU TAR (한 단계로 압축하고 추출 할 수 있음)이 있으면 명령을 단축 할 수 있습니다.
cloc -extract-with = 'tar zxf> 파일 <'perl-5.8.5.tar.gz python-2.4.2.tar.gz
c:Program FilesWinZip 에 winzip이 설치된 Windows 컴퓨터에서 명령은 다음과 같습니다.
cloc.exe -extract -with = ""c : program files winzip winzip32.exe "-e -o> file <." perl-5.8.5.tar.gz python-2.4.2.tar.gz
java .ear 파일은 추가 zip 파일이 포함 된 zip 파일입니다. CLOC는 어려움없이 중첩 압축 아카이브를 처리 할 수 있습니다. 이러한 모든 파일이 동일한 방식으로 압축 및 보관됩니다. Unix 및 Windows에서 Java .ear 파일 계산의 예 :
unix> cloc -extract -with = "unzip -d.> file <"project.ear dos> cloc.exe -extract -with = ""c : program files winzip winzip32.exe "-e -o> file <." project.ear
--diff 스위치를 사용하면 소스 코드의 상대적 변경 사항과 두 버전의 파일, 디렉토리 또는 아카이브 간의 주석을 측정 할 수 있습니다. 차이점은 두 파일 버전의 절대 코드 수보다 훨씬 더 많은 것을 보여줍니다. 예를 들어, 소스 파일에 100 줄이 있고 개발자는 102 줄의 최신 버전을 제공합니다. 개발자는 2 개의 댓글 줄을 추가하거나 17 개의 소스 라인을 삭제하고 14 개의 소스 라인과 5 개의 댓글 줄을 추가 했습니까? 아니면 개발자가 100 개의 원래 줄을 모두 버리고 모든 새로운 소스의 102 줄을 추가 했습니까? Diff 옵션은 몇 줄의 소스가 추가, 제거, 수정 또는 동일하게 유지되었는지, 그리고 몇 줄의 주석도가 추가, 제거, 수정 또는 동일하게 유지되었는지를 알 수 있습니다.
빈 선의 차이는 CLOC에 의해 조기에 제거되기 때문에 훨씬 더 거칠게 처리됩니다. 파일 쌍이 동일하지 않으면 CLOC는 빈 줄의 절대 수의 차이 만보고합니다. 다시 말해, 두 번째 파일에 첫 번째 파일이 더 많은 경우 '추가'에 대한 항목 만 볼 수 있고 상황이 반전되면 '제거'할 수 있습니다. '동일'의 항목은 두 파일이 동일 할 때만 0이 아닙니다.
파일 쌍 외에도 복수 쌍의 디렉토리 또는 파일 아카이브 쌍 또는 파일 아카이브 및 디렉토리를 제공 할 수 있습니다. CLOC는 디렉토리 또는 아카이브 내에서 파일 쌍을 정렬하고 각 쌍의 차이를 비교하려고합니다. 예를 들어, GCC 4.4.0과 4.5.0 사이의 변경 사항을 확인하려면
cloc-diff gcc-4.4.0.tar.bz2 gcc-4.5.0.tar.bz2
그래도 결과를 기다릴 준비를하십시오. --diff 옵션은 절대 코드 수보다 훨씬 느리게 실행됩니다.
Cloc이 두 아카이브간에 파일을 정렬하는 방법을 보려면 --diff-alignment 옵션을 사용하십시오.
cloc-diff-alignment = align.txt gcc-4.4.0.tar.bz2 gcc-4.5.0.tar.bz2
파일 쌍과 추가 및 삭제 된 파일을 표시하는 파일 align.txt 생성합니다. 기호 == 및 != 각 파일 쌍이 파일이 동일한지 ( == ) 또는 다른 내용 ( != )인지 나타냅니다.
파이썬 2.6.6과 2.7 릴리스의 차이를 보여주는 샘플 출력은 다음과 같습니다.
프롬프트> Cloc-Diff Python-2.7.9.9tgz Python-2.7.10.tar.xz
4315 텍스트 파일.
4313 텍스트 파일
2173 파일은 무시되었습니다.
4 오류 :
diff 오류, 시간 초과 : /tmp/8toganb9y1/python-2.7.9/mac/modules/qt/_qtmodule.c
diff 오류, 시간 초과를 초과했습니다 : /tmp/m6ldvsgaoq/python-2.7.10/mac/modules/qt/_qtmodule.c
diff 오류 (인용 주석?) : /tmp/8toganb9y1/python-2.7.9/mac/modules/qdsupport.py
diff 오류 (인용 주석?) : /tmp/m6ldvsgaoq/python-2.7.10/mac/modules/qdsupport.py
https://github.com/aldanial/cloc v 1.65 t = 298.59 s (0.0 파일/s, 0.0 줄/s)
------------------------------------- -------------------------------
언어 파일 빈 주석 코드
------------------------------------- -------------------------------
비주얼 기본
같은 2 0 1 12
수정 0 0 0
0 0 0 0
0 0 0 0 0
만들다
동일한 11 0 340 2952
수정 된 1 0 0 1
0 0 0 0
0 0 0 0 0
차이점
동일 1 0 87 105
수정 0 0 0
0 0 0 0
0 0 0 0 0
CSS
동일 0 0 19 327
수정 된 1 0 0 1
0 0 0 0
0 0 0 0 0
오브젝티브-C
동일한 7 0 61 635
수정 0 0 0
0 0 0 0
0 0 0 0 0
Nant 스크립트
동일한 2 0 0 30
수정 0 0 0
0 0 0 0
0 0 0 0 0
XML
같은 3 0 2 72
수정 된 1 0 0 1
0 0 0 1
0 1 0 0
Windows 리소스 파일
동일한 3 0 56 206
수정 된 1 0 0 1
0 0 0 0
0 0 0 0 0
예상하다
같은 6 0 161 565
수정 0 0 0
0 0 0 0
0 0 0 0 0
HTML
같은 14 0 11 2344
수정 0 0 0
0 0 0 0
0 0 0 0 0
VIM 스크립트
같은 1 0 7 106
수정 0 0 0
0 0 0 0
0 0 0 0 0
C++
같은 2 0 18 128
수정 0 0 0
0 0 0 0
0 0 0 0 0
Windows 모듈 정의
동일한 7 0 187 2080
수정 된 2 0 0
0 0 0 1
제거 0 1 0 2
프롤로그
같은 1 0 0 24
수정 0 0 0
0 0 0 0
0 0 0 0 0
자바스크립트
동일 3 0 49 229
수정 0 0 0
0 0 0 0
0 0 0 0 0
집회
동일 51 0 6794 12298
수정 0 0 0
0 0 0 0
0 0 0 0 0
Bourne Shell
동일한 41 0 7698 45024
수정 된 1 0 0 3
추가 0 13 2 64
0 0 0 0 0
DOS 배치
동일 29 0 107 494
수정 된 1 0 0 9
추가 0 1 0 3
0 0 0 0 0
MSBuild 스크립트
동일한 77 0 3 38910
수정 0 0 0
0 0 0 0
0 0 0 0 0
파이썬
동일한 1947 0 109012 430335
수정 된 192 0 94 950
2 323 283 2532 추가
2 55 58 646 제거
M4
동일한 18 0 191 15352
수정 된 1 0 0 2
추가 1 31 0 205
0 0 0 0 0
기음
동일한 505 0 37439 347837
수정 된 45 0 13 218
0 90 33 795 추가
제거 0 9 2 148
C/C ++ 헤더
동일한 255 0 10361 66635
수정 된 5 0 5 7
추가 0 1 3 300
0 0 0 0 0
------------------------------------- ------
합집합:
동일한 2986 0 172604 966700
수정 된 251 0 112 1193
3 459 321 3901 추가
제거 2 66 60 796
------------------------------------- ------
한 쌍의 오류가 발생했습니다. 첫 번째 쌍은 각 Python 버전에서 Python-X/Mac/Modules/qt/_Qtmodule.c 파일의 차이를 계산할 때 타이밍으로 인해 발생했습니다. 이 파일에는> 26,000 줄의 C 코드가 있으며 느린 컴퓨터에서 단일 파일의 기본 최대 기간 인 10 초 이상이 소요됩니다. (참고 : 이것은 명령 줄 diff 유틸리티가 아닌 Perl Algorithm::Diff 의 sdiff() 함수와 차이를 수행하는 것을 의미합니다. --diff-timeout 20 .
두 번째 오류가 더 문제가됩니다. Python-X/Mac/Modules/qd/qdsupport.py 파일에는 c 댓글을 포함하는 python docstring (트리플 따옴표 쌍 사이)이 포함됩니다. Cloc은 DocStrings를 주석으로 취급하고 먼저 C 주석으로 변환 한 다음 정규 표현식을 제거하는 C 주석을 사용하여 처리합니다. 그러나 중첩 된 C 주석은 잘못된 결과를 산출합니다.
CLOC는 언어 주석 정의를 파일에 쓸 수 있거나 내장 된 정의를 재정의하여 파일에서 주석 정의를 읽을 수 있습니다. 이는 CLOC를 사용하여 아직 포함되지 않은 언어 라인을 계산하거나 파일 확장을 언어와 연관 시키거나 기존 언어가 계산되는 방식을 수정하려는 경우 유용 할 수 있습니다.
사용자 정의 언어 정의 파일을 만드는 가장 쉬운 방법은 Cloc이 파일에 정의를 작성한 다음 해당 파일을 수정하는 것입니다.
Unix> cloc-write-lang-def = my_definitions.txt
수정할 수있는 my_definitions.txt 파일을 생성 한 다음 --read-lang-def 또는 --force-lang-def 옵션으로 다시 읽습니다. 옵션 간의 차이점은 주어진 파일의 이전 언어 정의를 CLOC의 내부 정의와 병합하여 CLOC가 겹치는 경우 우선 순위를 결합한 것입니다. 반면에 --force-lang-def 옵션은 Cloc의 정의를 완전히 대체합니다. 이 옵션은 CLOC가 확장자가 여러 언어에 맵핑되는 언어를 계산하는 것을 방지하는 데 단점이 있습니다.이 언어에는 정의 파일에서 쉽게 표현되지 않는 추가 논리가 필요합니다.
unix> cloc -Read-lang-def = my_definitions.txt file1 file2 dir1 ...
각 언어 입력에는 네 가지 부분이 있습니다.
필터는 소스 파일에서 주석 텍스트를 제거하는 메소드를 정의합니다. 예를 들어 C ++ 항목은 다음과 같습니다
C++
필터 call_regexp_common c ++
필터 remove_inline //.*$
확장 c
확장 C ++
확장 CC
확장 CPP
확장 CXX
확장 PCC
3RD_GEN_SCALE 1.51
end_of_line_continuation \ $
C ++에는 두 개의 필터가 있습니다. 첫째, regexp :: Common의 C ++ 주석 regex와 일치하는 라인을 제거하십시오. The second filter using remove_inline is currently unused. Its intent is to identify lines with both code and comments and it may be implemented in the future.
A more complete discussion of the different filter options may appear here in the future. The output of cloc's --write-lang-def option should provide enough examples for motivated individuals to modify or extend cloc's language definitions.
If you manage multiple software projects you might be interested in seeing line counts by project, not just by language. Say you manage three software projects called MariaDB, PostgreSQL, and SQLite. The teams responsible for each of these projects run cloc on their source code and provide you with the output. For example, the MariaDB team does
cloc --out mariadb-10.1.txt mariadb-server-10.1.zip
and provides you with the file mariadb-10.1.txt . The contents of the three files you get are
Unix> cat mariadb-10.1.txt https://github.com/AlDanial/cloc v 1.65 T=45.36 s (110.5 files/s, 66411.4 lines/s) ------------------------------------- --------------------------------- Language files blank comment code ------------------------------------- --------------------------------- C++ 1613 225338 290077 983026 C 853 62442 73017 715018 C/C++ Header 1327 48300 114577 209394 Bourne Shell 256 10224 10810 61943 Perl 147 10342 8305 35562 Pascal 107 4907 5237 32541 HTML 56 195 6 16489 Javascript 5 3309 3019 15540 m4 30 1599 359 14215 CMake 190 1919 4097 12206 XML 35 648 56 5210 Ruby 59 619 184 4998 Puppet 10 0 1 3848 make 134 724 360 3631 SQL 23 306 377 3405 Python 34 371 122 2545 Bourne Again Shell 27 299 380 1604 Windows Module Definition 37 27 13 1211 lex 4 394 166 991 yacc 2 152 64 810 DOS Batch 19 89 82 700 Prolog 1 9 40 448 RobotFramework 1 0 0 441 CSS 2 33 155 393 JSON 5 0 0 359 dtrace 9 59 179 306 Windows Resource File 10 61 89 250 Assembly 2 70 284 237 WiX source 1 18 10 155 Visual Basic 6 0 0 88 YAML 2 4 4 65 PHP 1 11 2 24 SKILL 1 8 15 16 sed 2 0 0 16 Windows Message File 1 2 8 6 diff 1 1 4 4 D 1 4 11 4 ------------------------------------- --------------------------------- SUM: 5014 372484 512110 2127699 ------------------------------------- --------------------------------- Unix> cat sqlite-3081101.txt https://github.com/AlDanial/cloc v 1.65 T=1.22 s (3.3 files/s, 143783.6 lines/s) ------------------------------------- ----------------------------- Language files blank comment code ------------------------------------- ----------------------------- C 2 11059 53924 101454 C/C++ Header 2 211 6630 1546 ------------------------------------- ----------------------------- SUM: 4 11270 60554 103000 ------------------------------------- ----------------------------- Unix> cat postgresql-9.4.4.txt https://github.com/AlDanial/cloc v 1.65 T=22.46 s (172.0 files/s, 96721.6 lines/s) ------------------------------------- --------------------------------- Language files blank comment code ------------------------------------- --------------------------------- HTML 1254 3725 0 785991 C 1139 139289 244045 736519 C/C++ Header 667 12277 32488 57014 SQL 410 13400 8745 51926 yacc 8 3163 2669 28491 Bourne Shell 41 2647 2440 17170 Perl 81 1702 1308 9456 lex 9 792 1631 4285 make 205 1525 1554 4114 m4 12 218 25 1642 Windows Module Definition 13 4 17 1152 XSLT 5 76 55 294 DOS Batch 7 29 30 92 CSS 1 20 7 69 Assembly 3 17 38 69 D 1 14 14 66 Windows Resource File 3 4 0 62 Lisp 1 1 1 16 sed 1 1 7 15 Python 1 5 0 13 Bourne Again Shell 1 8 6 10 Windows Message File 1 0 0 5 ------------------------------------- --------------------------------- SUM: 3864 178917 295080 1698471 ------------------------------------- ---------------------------------
While these three files are interesting, you also want to see the combined counts from all projects. That can be done with cloc's --sum_reports option:
Unix> cloc --sum-reports --out=databases mariadb-10.1.txt sqlite-3081101.txt postgresql-9.4.4.txt Wrote databases.lang Wrote databases.file
The report combination produces two output files, one for sums by programming language ( databases.lang ) and one by project ( databases.file ). Their contents are
Unix> cat databases.lang https://github.com/AlDanial/cloc v 1.65 ------------------------------------- ----------------- Language files blank comment code ------------------------------------- ----------------- C 1994 212790 370986 1552991 C++ 1613 225338 290077 983026 HTML 1310 3920 6 802480 C/C++ Header 1996 60788 153695 267954 Bourne Shell 297 12871 13250 79113 SQL 433 13706 9122 55331 Perl 228 12044 9613 45018 Pascal 107 4907 5237 32541 yacc 10 3315 2733 29301 m4 42 1817 384 15857 Javascript 5 3309 3019 15540 CMake 190 1919 4097 12206 make 339 2249 1914 7745 lex 13 1186 1797 5276 XML 35 648 56 5210 Ruby 59 619 184 4998 Puppet 10 0 1 3848 Python 35 376 122 2558 Windows Module Definition 50 31 30 2363 Bourne Again Shell 28 307 386 1614 DOS Batch 26 118 112 792 CSS 3 53 162 462 Prolog 1 9 40 448 RobotFramework 1 0 0 441 JSON 5 0 0 359 Windows Resource File 13 65 89 312 Assembly 5 87 322 306 dtrace 9 59 179 306 XSLT 5 76 55 294 WiX source 1 18 10 155 Visual Basic 6 0 0 88 D 2 18 25 70 YAML 2 4 4 65 sed 3 1 7 31 PHP 1 11 2 24 SKILL 1 8 15 16 Lisp 1 1 1 16 Windows Message File 2 2 8 11 diff 1 1 4 4 ------------------------------------- ----------------- SUM: 8882 562671 867744 3929170 ------------------------------------- ----------------- Unix> cat databases.file ------------------------------------- -------------------------------- File files blank comment code ------------------------------------- -------------------------------- mariadb-10.1.txt 5014 372484 512110 2127699 postgresql-9.4.4.txt 3864 178917 295080 1698471 sqlite-3081101.txt 4 11270 60554 103000 ------------------------------------- -------------------------------- SUM: 8882 562671 867744 3929170 ------------------------------------- --------------------------------
Report files themselves can be summed together. Say you also manage development of Perl and Python and you want to keep track of those line counts separately from your database projects. First create reports for Perl and Python separately:
cloc --out perl-5.22.0.txt perl-5.22.0.tar.gz cloc --out python-2.7.10.txt Python-2.7.10.tar.xz
then sum these together with
Unix> cloc --sum-reports --out script_lang perl-5.22.0.txt python-2.7.10.txt Wrote script_lang.lang Wrote script_lang.file Unix> cat script_lang.lang https://github.com/AlDanial/cloc v 1.65 ------------------------------------- ----------------------------- Language files blank comment code ------------------------------------- ----------------------------- Perl 2892 136396 184362 536445 C 680 75566 71211 531203 Python 2141 89642 109524 434015 C/C++ Header 408 16433 26938 214800 Bourne Shell 154 11088 14496 87759 MSBuild script 77 0 3 38910 m4 20 1604 191 15559 Assembly 51 3775 6794 12298 Pascal 8 458 1603 8592 make 16 897 828 4939 XML 37 198 2 2484 HTML 14 393 11 2344 C++ 12 338 295 2161 Windows Module Definition 9 171 187 2081 YAML 49 20 15 2078 Prolog 12 438 2 1146 JSON 14 1 0 1037 yacc 1 85 76 998 DOS Batch 44 199 148 895 Objective-C 7 98 61 635 Expect 6 104 161 565 Windows Message File 1 102 11 489 CSS 1 98 19 328 Windows Resource File 7 55 56 292 Javascript 3 31 49 229 vim script 1 36 7 106 diff 1 17 87 105 NAnt script 2 1 0 30 IDL 1 0 0 24 Visual Basic 2 1 1 12 D 1 5 7 8 Lisp 2 0 3 4 ------------------------------------- ----------------------------- SUM: 6674 338250 417148 1902571 ------------------------------------- ----------------------------- Unix> cat script_lang.file ------------------------------------- ----------------------------- File files blank comment code ------------------------------------- ----------------------------- python-2.7.10.txt 3240 161276 173214 998697 perl-5.22.0.txt 3434 176974 243934 903874 ------------------------------------- ----------------------------- SUM: 6674 338250 417148 1902571 ------------------------------------- -----------------------------
Finally, combine the combination files:
Unix> cloc --sum-reports --report_file=everything databases.lang script_lang.lang Wrote everything.lang Wrote everything.file Unix> cat everything.lang https://github.com/AlDanial/cloc v 1.65 ------------------------------------- ------------------ Language files blank comment code ------------------------------------- ------------------ C 2674 288356 442197 2084194 C++ 1625 225676 290372 985187 HTML 1324 4313 17 804824 Perl 3120 148440 193975 581463 C/C++ Header 2404 77221 180633 482754 Python 2176 90018 109646 436573 Bourne Shell 451 23959 27746 166872 SQL 433 13706 9122 55331 Pascal 115 5365 6840 41133 MSBuild script 77 0 3 38910 m4 62 3421 575 31416 yacc 11 3400 2809 30299 Javascript 8 3340 3068 15769 make 355 3146 2742 12684 Assembly 56 3862 7116 12604 CMake 190 1919 4097 12206 XML 72 846 58 7694 lex 13 1186 1797 5276 Ruby 59 619 184 4998 Windows Module Definition 59 202 217 4444 Puppet 10 0 1 3848 YAML 51 24 19 2143 DOS Batch 70 317 260 1687 Bourne Again Shell 28 307 386 1614 Prolog 13 447 42 1594 JSON 19 1 0 1396 CSS 4 151 181 790 Objective-C 7 98 61 635 Windows Resource File 20 120 145 604 Expect 6 104 161 565 Windows Message File 3 104 19 500 RobotFramework 1 0 0 441 dtrace 9 59 179 306 XSLT 5 76 55 294 WiX source 1 18 10 155 diff 2 18 91 109 vim script 1 36 7 106 Visual Basic 8 1 1 100 D 3 23 32 78 sed 3 1 7 31 NAnt script 2 1 0 30 IDL 1 0 0 24 PHP 1 11 2 24 Lisp 3 1 4 20 SKILL 1 8 15 16 ------------------------------------- ------------------ SUM: 15556 900921 1284892 5831741 ------------------------------------- ------------------ Unix> cat everything.file ------------------------------------- ----------------------------- File files blank comment code ------------------------------------- ----------------------------- databases.lang 8882 562671 867744 3929170 script_lang.lang 6674 338250 417148 1902571 ------------------------------------- ----------------------------- SUM: 15556 900921 1284892 5831741 ------------------------------------- -----------------------------
One limitation of the --sum-reports feature is that the individual counts must be saved in the plain text format. Counts saved as XML, JSON, YAML, or SQL will produce errors if used in a summation.
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 :
| 필드 | 유형 |
|---|---|
| ID | integer primary key |
| 타임스탬프 | 텍스트 |
| 프로젝트 | 텍스트 |
| elapsed_s | 텍스트 |
Table t :
| 필드 | 유형 |
|---|---|
| 프로젝트 | 텍스트 |
| 언어 | 텍스트 |
| 파일 | 텍스트 |
| nBlank | 정수 |
| nComment | 정수 |
| nCode | 정수 |
| nScaled | 진짜 |
| 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
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
*
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 ; 그 다음에
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)."
출구
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:
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.
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.
If you find yourself using the same command line switches every time you invoke cloc, you can save some typing by adding those switches to the options.txt runtime configuration file. cloc will look for this file in the following default locations:
# Linux, NetBSD, FreeBSD, macOS: /home/USERNAME/.config/cloc/options.txt # Windows C:UsersUSERNAMEAppDataRoamingcloc
If you run cloc with --help , cloc will tell you where it expects to find this config file file. The information appears by the explanation of the --config switch after the text the default location of . On Unix-like operating systems, this can be simplified to
> cloc --help | grep "default location"
the default location of /home/al/.config/cloc/options.txt.
and in a Windows cmd terminal with
> cloc --help | findstr default | findstr location
the default location of C:UsersalAppDataRoamingcloc
Place each switch and arguments, if any, on a line by itself. Lines prefixed with # symbol are ignored as comments and blank lines are skipped. Leading hyphens on the switches are optional. Here's a sample file:
# options.txt --vcs git v # verbose level 1 exclude-ext svg,html
The path to the options.txt file can also be specified with the --config FILE switch.
Finally, if cloc finds an options.txt file in the same directory as files given by any of these switches (in the listed priority), it will use that configuration file from that location:
--list-file--exclude-list-file--read-lang-def--force-lang-def--diff-list-file Run with --verbose to have cloc tell you which, if any, options.txt file it uses.
Ozren Dabić created a Java programmatic interface to cloc. It is available at https://github.com/seart-group/jcloc
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.
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:
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 .
If cloc does not recognize a language you are interested in counting, create a GitHub issue requesting support for your language. Include this information:
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
Problem reports that cannot be reproduced will be ignored and eventually closed.
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.)
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 (c) 2006-2024, Al Danial
