CLOC - Счетчик Линий Кода

Обзор

Cloc считает пустые строки, строки комментариев и физические строки исходного кода во многих языках программирования. Учитывая две версии кодовой базы, cloc может вычислить разницу в пустой строке, комментарии и строке исходного кода. Он написан полностью на Perl без внешних зависимостей от стандартного дистрибутива Perl версии 5.6 и выше (код от некоторых внешних модулей встроен в cloc) и это довольно мобильно. Cloc может запускаться на многих версиях Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, z/OS и Windows. (Для запуска Perl версии cloc на Windows, необходим ActiveState Perl 5.6.1 или выше, Strawberry Perl, Cygwin или MobaXTerm с установленным Perl-плагином. В качестве альтернативы можно использовать Windows бинары из cloc cгенерированные PAR::Packer для запуска на компьютерах Windows, которые не имеют ни Perl, ни Cygwin.)

Cloc содержит код от SLOCCount Дэвида Уилера, Damian Conway и Perl модуль Абигейла Regexp::Common, Perl модуль Шона М. Берка Win32::Autoglob, и Perl модуль Тай Маккуина Algorithm::Diff. Масштабируемые коэффициенты языка были получены от Mayes Consulting, LLC, веб-сайт http://softwareestimator.com/IndustryData2.htm.


Установка с помощью менеджера пакетов

В зависимости от вашей операционной системы, для вас может работать один из этих способов установки:

  npm install -g cloc                    # https://www.npmjs.com/package/cloc
  sudo apt-get install cloc              # Debian, Ubuntu
  sudo yum install cloc                  # Fedora
  sudo pacman -S cloc                    # Arch
  

Скачать стабильный релиз

Исходный код, замечания по выпуску, Windows исполняемый файл, и Unix пакет для текущего стабильного релиза можно найти на http://sourceforge.net/projects/cloc/files/cloc/v1.64/.


Лицензия

Cloc находится под лицензией GNU General Public License v2, за исключением частей, которые были скопированы из других источников. Код скопированный из Perl модулей Regexp::Common, Win32::Autoglob, и Algorithm::Diff это предмет Artistic License.


Зачем использовать Cloc?

Cloc имеет много особенностей, которые делают его простым в использовании, законченным, расширяемым и переносимым:

1. Существует в виде единого автономного файла, который требует минимальных усилий для установки --- просто скачать файл и запустить его.

2. Можно читать языковые комментарий из файла и, таким образом, потенциально работать с компьютерными языками, которые еще не существуют.

3. Позволяет результатам нескольких запусков быть подсчитанными вместе языком и проектом.

4. Может производить результаты в различных форматах: текст, SQL, XML, YAML, с разделенными запятой значениями.

5. Может считать код в сжатых архивах (tar balls, Zip файлах, Java .ear файлах).

6. Имеет многочисленные варианты устранения неполадок.

7. Управляет именами файлов и каталогов с пробелами и другими необычными персонажами.

8. Не имеет зависимостей за пределами стандартного дистрибутива Perl.

9. Работает на Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, и системах z/ OS, которые имеют Perl 5.6 или выше. Исходная версия работает на Windows, либо с любым ActiveState Perl, Strawberry Perl, Cygwin или MobaXTerm + Perl плагин. Кроме Windows, может работать на Windows binary, который не имеет зависимостей.


Другие Счетчики

Если Cloc не удовлетворяет вашим потребностям, то здесь есть для рассмотрения и другие, свободно доступные счетчики:

Sonar

Ohcount

SLOCCount

sclc

• USC's CODECOUNT

loc

Другие ссылки:

• QSM каталог инструментов считающих код

Запись в Википедии для счетчиков линий кода


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

Хотя 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 локально. Если Digest::MD5 не найден проверка уникальности файл пропускается.

Двоичный Windows, построен на компьютере и регулярных Regexp::Common и Digest::MD5 установлены локально.


Построение Windows исполняемой версии

Скачать Windows по умолчанию, Cloc-1.64.exe, был построен с PAR::Packer на Windows 7 компьютере с Strawberry Perl. Windows исполняемые Cloc версии 1.60 и ранее были построены с perl2exe на 32-битной Windows XP компьютер. Небольшой модификации было сделано в исходном коде Cloc перед его передачей perl2exe; линии 87 и 88 были раскомментированы:

85  # Uncomment next two lines when building Windows executable with perl2exe
86  # or if running on a system that already has Regexp::Common. 
87  #use Regexp::Common;
88  #$HAVE_Rexexp_Common = 1;

Почему версия для Windows настолько большая?

Windows исполняемые Cloc версии 1.60 и выше, создан с perl2exe как отмечалось выше, около 1,6 Мб, в то время как более новые версии, созданные с PAR::Packer, 11 МБ. Почему новые исполняемые настолько больше? Моя теория состоит в том, что perl2exe использует умнее Обрезка деревьев логику, чем PAR::Packer, но это чистая спекуляция.


Создайте свою собственную исполняемую версию

Если у вас есть доступ к perl2exe, вы можете использовать его для создания жесткой исполняемый Windows. См линии 84-87 в исходном коде Cloc для незначительного изменения кода, что необходимо при использовании perl2exe.

В противном случае, чтобы построить исполняемый файл Windows, с pp от PAR::Packer сначала установить Windows, основанный распределение Perl (например Perl или Strawberry ActivePerl) после их поручению. Далее, откройте командную строку, иначе в окне DOS и установить модуль PAR::Packer. Наконец, вызовите команду вновь установленный pp с Cloc код соусе создать .exe -файл:

C:> perl -MCPAN -e shell
cpan> install PAR::Packer
cpan> exit
C:> pp cloc-1.64.pl

Вариация на выше, если вы установили портативную версию Strawberry Perl, вам нужно будет запустить portableshell.bat первым правильно настроить среду. Strawberry Perl получены исполняемый на SourceForge загрузить район был создан с переносной версии на компьютере Windows 7.


Основное применение

Cloc это программа командной строки, которая принимает файл, каталог и/или имена архивных как входы. Вот пример запуска Cloc против распространения Perl v5.10.0 источника:

  
prompt> cloc perl-5.10.0.tar.gz
    4076 text files.
    3883 unique files.                                          
    1521 files ignored.

http://cloc.sourceforge.net v 1.50  T=12.0 s (209.2 files/s, 70472.1 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Perl                          2052         110356         130018         292281
C                              135          18718          22862         140483
C/C++ Header                   147           7650          12093          44042
Bourne Shell                   116           3402           5789          36882
Lisp                             1            684           2242           7515
make                             7            498            473           2044
C++                             10            312            277           2000
XML                             26            231              0           1972
yacc                             2            128             97           1549
YAML                             2              2              0            489
DOS Batch                       11             85             50            322
HTML                             1             19              2             98
-------------------------------------------------------------------------------
SUM:                          2510         142085         173903         529677
-------------------------------------------------------------------------------

Чтобы запустить Cloc на компьютерах Windows, нужно сначала открыть команду (ака DOS) окно и вызвать cloc.exe из командной строки нет.


Опции

  
prompt> cloc

Usage: cloc [options] <file(s)/dir(s)> | <set 1> <set 2> | <report files>

 Count, or compute differences of, physical lines of source code in the
 given files (may be archives such as compressed tarballs or zip files)
 and/or recursively below the given directories.

 Input Options
   --extract-with=<cmd>      This option is only needed if cloc is unable
                             to figure out how to extract the contents of
                             the input file(s) by itself.
                             Use <cmd> to extract binary archive files (e.g.:
                             .tar.gz, .zip, .Z).  Use the literal '>FILE<' as
                             a stand-in for the actual file(s) to be
                             extracted.  For example, to count lines of code
                             in the input files
                                gcc-4.2.tar.gz  perl-5.8.8.tar.gz
                             on Unix use
                               --extract-with='gzip -dc >FILE< | tar xf -'
                             or, if you have GNU tar,
                               --extract-with='tar zxf >FILE<'
                             and on Windows use, for example:
                               --extract-with="\"c:\Program Files\WinZip\WinZip32.exe\" -e -o >FILE< ."
                             (if WinZip is installed there).
   --list-file=<file>        Take the list of file and/or directory names to
                             process from <file>, which has one file/directory
                             name per line.  Only exact matches are counted;
                             relative path names will be resolved starting from 
                             the directory where cloc is invoked.  
                             See also --exclude-list-file.
   --unicode                 Check binary files to see if they contain Unicode
                             expanded ASCII text.  This causes performance to
                             drop noticably.

 Processing Options
   --autoconf                Count .in files (as processed by GNU autoconf) of
                             recognized languages.
   --by-file                 Report results for every source file encountered.
   --by-file-by-lang         Report results for every source file encountered
                             in addition to reporting by language.
   --count-and-diff <set1> <set2>    
                             First perform direct code counts of source file(s)
                             of <set1> and <set2> separately, then perform a diff 
                             of these.  Inputs may be pairs of files, directories, 
                             or archives.  See also --diff, --diff-alignment,
                             --diff-timeout, --ignore-case, --ignore-whitespace.
   --diff <set1> <set2>      Compute differences in code and comments between
                             source file(s) of <set1> and <set2>.  The inputs
                             may be pairs of files, directories, or archives.
                             Use --diff-alignment to generate a list showing
                             which file pairs where compared.  See also
                             --count-and-diff, --diff-alignment, --diff-timeout, 
                             --ignore-case, --ignore-whitespace.
   --diff-timeout <N>        Ignore files which take more than <N> seconds
                             to process.  Default is 10 seconds.
                             (Large files with many repeated lines can cause 
                             Algorithm::Diff::sdiff() to take hours.)
   --follow-links            [Unix only] Follow symbolic links to directories
                             (sym links to files are always followed).
   --force-lang=<lang>[,<ext>]
                             Process all files that have a <ext> extension
                             with the counter for language <lang>.  For
                             example, to count all .f files with the
                             Fortran 90 counter (which expects files to
                             end with .f90) instead of the default Fortran 77
                             counter, use
                               --force-lang="Fortran 90",f
                             If <ext> is omitted, every file will be counted
                             with the <lang> counter.  This option can be
                             specified multiple times (but that is only
                             useful when <ext> is given each time).
                             See also --script-lang, --lang-no-ext.
   --force-lang-def=<file>   Load language processing filters from <file>,
                             then use these filters instead of the built-in
                             filters.  Note:  languages which map to the same 
                             file extension (for example:
                             MATLAB/Objective C/MUMPS/Mercury;  Pascal/PHP; 
                             Lisp/OpenCL; Lisp/Julia; Perl/Prolog) will be 
                             ignored as these require additional processing 
                             that is not expressed in language definition 
                             files.  Use --read-lang-def to define new 
                             language filters without replacing built-in 
                             filters (see also --write-lang-def).
   --ignore-whitespace       Ignore horizontal white space when comparing files
                             with --diff.  See also --ignore-case.
   --ignore-case             Ignore changes in case; consider upper- and lower-
                             case letters equivalent when comparing files with
                             --diff.  See also --ignore-whitespace.
   --lang-no-ext=<lang>      Count files without extensions using the <lang>
                             counter.  This option overrides internal logic
                             for files without extensions (where such files
                             are checked against known scripting languages
                             by examining the first line for #!).  See also
                             --force-lang, --script-lang.
   --max-file-size=<MB>      Skip files larger than <MB> megabytes when
                             traversing directories.  By default, <MB>=100.
                             cloc's memory requirement is roughly twenty times 
                             larger than the largest file so running with 
                             files larger than 100 MB on a computer with less 
                             than 2 GB of memory will cause problems.  
                             Note:  this check does not apply to files 
                             explicitly passed as command line arguments.
   --read-binary-files       Process binary files in addition to text files.
                             This is usually a bad idea and should only be
                             attempted with text files that have embedded
                             binary data.
   --read-lang-def=<file>    Load new language processing filters from <file>
                             and merge them with those already known to cloc.  
                             If <file> defines a language cloc already knows 
                             about, cloc's definition will take precedence.  
                             Use --force-lang-def to over-ride cloc's 
                             definitions (see also --write-lang-def ).
   --script-lang=<lang>,<s>  Process all files that invoke <s> as a #!
                             scripting language with the counter for language
                             <lang>.  For example, files that begin with
                                #!/usr/local/bin/perl5.8.8
                             will be counted with the Perl counter by using
                                --script-lang=Perl,perl5.8.8
                             The language name is case insensitive but the
                             name of the script language executable, <s>,
                             must have the right case.  This option can be
                             specified multiple times.  See also --force-lang,
                             --lang-no-ext.
   --sdir=<dir>              Use <dir> as the scratch directory instead of
                             letting File::Temp chose the location.  Files
                             written to this location are not removed at
                             the end of the run (as they are with File::Temp).
   --skip-uniqueness         Skip the file uniqueness check.  This will give
                             a performance boost at the expense of counting
                             files with identical contents multiple times
                             (if such duplicates exist).
   --stdin-name=<file>       Give a file name to use to determine the language
                             for standard input.
   --strip-comments=<ext>    For each file processed, write to the current
                             directory a version of the file which has blank
                             lines and comments removed.  The name of each
                             stripped file is the original file name with
                             .<ext> appended to it.  It is written to the
                             current directory unless --original-dir is on.
   --original-dir            [Only effective in combination with
                             --strip-comments]  Write the stripped files
                             to the same directory as the original files.
   --sum-reports             Input arguments are report files previously
                             created with the --report-file option.  Makes
                             a cumulative set of results containing the
                             sum of data from the individual report files.
   --unix                    Override the operating system autodetection
                             logic and run in UNIX mode.  See also
                             --windows, --show-os.
   --windows                 Override the operating system autodetection
                             logic and run in Microsoft Windows mode.
                             See also --unix, --show-os.

 Filter Options
   --exclude-dir=<D1>[,D2,]  Exclude the given comma separated directories
                             D1, D2, D3, et cetera, from being scanned.  For
                             example  --exclude-dir=.cache,test  will skip
                             all files that have /.cache/ or /test/ as part
                             of their path.
                             Directories named .bzr, .cvs, .hg, .git, and
                             .svn are always excluded.
   --exclude-ext=<ext1>[,<ext2>[...]]
                             Do not count files having the given file name
                             extensions.
   --exclude-lang=<L1>[,L2,] Exclude the given comma separated languages
                             L1, L2, L3, et cetera, from being counted.
   --exclude-list-file=<file>  Ignore files and/or directories whose names
                             appear in <file>.  <file> should have one file
                             name per line.  Only exact matches are ignored;
                             relative path names will be resolved starting from 
                             the directory where cloc is invoked.  
                             See also --list-file.
   --include-lang=<L1>[,L2,] Count only the given comma separated languages
                             L1, L2, L3, et cetera.
   --match-d=<regex>         Only count files in directories matching the Perl
                             regex.  For example
                               --match-d='/(src|include)/'
                             only counts files in directories containing
                             /src/ or /include/.
   --not-match-d=<regex>     Count all files except those in directories
                             matching the Perl regex.
   --match-f=<regex>         Only count files whose basenames match the Perl
                             regex.  For example
                               --match-f='^[Ww]idget'
                             only counts files that start with Widget or widget.
   --not-match-f=<regex>     Count all files except those whose basenames
                             match the Perl regex.
   --skip-archive=<regex>    Ignore files that end with the given Perl regular
                             expression.  For example, if given
                               --skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
                             the code will skip files that end with .zip,
                             .tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz, and
                             .tar.7z.
   --skip-win-hidden         On Windows, ignore hidden files.

 Debug Options
   --categorized=<file>      Save names of categorized files to <file>.
   --counted=<file>          Save names of processed source files to <file>.
   --explain=<lang>          Print the filters used to remove comments for
                             language <lang> and exit.  In some cases the 
                             filters refer to Perl subroutines rather than
                             regular expressions.  An examination of the
                             source code may be needed for further explanation.
   --diff-alignment=<file>   Write to <file> a list of files and file pairs
                             showing which files were added, removed, and/or
                             compared during a run with --diff.  This switch
                             forces the --diff mode on.
   --help                    Print this usage information and exit.
   --found=<file>            Save names of every file found to <file>.
   --ignored=<file>          Save names of ignored files and the reason they
                             were ignored to <file>.
   --print-filter-stages     Print processed source code before and after 
                             each filter is applied.
   --show-ext[=<ext>]        Print information about all known (or just the
                             given) file extensions and exit.
   --show-lang[=<lang>]      Print information about all known (or just the
                             given) languages and exit.
   --show-os                 Print the value of the operating system mode
                             and exit.  See also --unix, --windows.
   -v[=<n>]                  Verbose switch (optional numeric value).
   --version                 Print the version of this program and exit.
   --write-lang-def=<file>   Writes to <file> the language processing filters
                             then exits.  Useful as a first step to creating
                             custom language definitions (see also
                             --force-lang-def, --read-lang-def).

 Output Options
   --3                       Print third-generation language output.
                             (This option can cause report summation to fail
                             if some reports were produced with this option
                             while others were produced without it.)
   --by-percent  X           Instead of comment and blank line counts, show 
                             these values as percentages based on the value 
                             of X in the denominator:
                                X = 'c'   -> # lines of code
                                X = 'cm'  -> # lines of code + comments
                                X = 'cb'  -> # lines of code + blanks
                                X = 'cmb' -> # lines of code + comments + blanks
                             For example, if using method 'c' and your code
                             has twice as many lines of comments as lines 
                             of code, the value in the comment column will 
                             be 200%.  The code column remains a line count.
   --csv                     Write the results as comma separated values.
   --csv-delimiter=<C>       Use the character <C> as the delimiter for comma
                             separated files instead of ,.  This switch forces
   --out=<file>              Synonym for --report-file=<file>.
                             --csv to be on.
   --progress-rate=<n>       Show progress update after every <n> files are
                             processed (default <n>=100).  Set <n> to 0 to
                             suppress progress output (useful when redirecting
                             output to STDOUT).
   --quiet                   Suppress all information messages except for
                             the final report.
   --report-file=<file>      Write the results to <file> instead of STDOUT.
   --sql=<file>              Write results as SQL create and insert statements
                             which can be read by a database program such as
                             SQLite.  If <file> is -, output is sent to STDOUT.
   --sql-append              Append SQL insert statements to the file specified
                             by --sql and do not generate table creation
                             statements.  Only valid with the --sql option.
   --sql-project=<name>      Use <name> as the project identifier for the
                             current run.  Only valid with the --sql option.
   --sql-style=<style>       Write SQL statements in the given style instead
                             of the default SQLite format.  Currently, the 
                             only style option is Oracle.
   --sum-one                 For plain text reports, show the SUM: output line
                             even if only one input file is processed.
   --xml                     Write the results in XML.
   --xsl=<file>              Reference <file> as an XSL stylesheet within
                             the XML output.  If <file> is 1 (numeric one),
                             writes a default stylesheet, cloc.xsl (or
                             cloc-diff.xsl if --diff is also given).
                             This switch forces --xml on.
   --yaml                    Write the results in YAML.


Распознаваемые языки

prompt> cloc --show-lang

ABAP                       (abap)
ActionScript               (as)
Ada                        (ada, adb, ads, pad)
ADSO/IDSM                  (adso)
AMPLE                      (ample, dofile, startup)
Ant                        (build.xml)
Apex Trigger               (trigger)
Arduino Sketch             (ino, pde)
ASP                        (asa, asp)
ASP.Net                    (asax, ascx, asmx, aspx, config, master, sitemap, webinfo)
Assembly                   (asm, s, S)
AutoHotkey                 (ahk)
awk                        (awk)
Bourne Again Shell         (bash)
Bourne Shell               (sh)
C                          (c, ec, pgc)
C Shell                    (csh, tcsh)
C#                         (cs)
C++                        (C, c++, cc, cpp, cxx, pcc)
C/C++ Header               (h, H, hh, hpp)
CCS                        (ccs)
Clojure                    (clj)
ClojureScript              (cljs)
CMake                      (cmake, CMakeLists.txt)
COBOL                      (cbl, CBL, cob, COB)
CoffeeScript               (coffee)
ColdFusion                 (cfm)
ColdFusion CFScript        (cfc)
CSS                        (css)
CUDA                       (cu)
Cython                     (pyx)
D/dtrace                   (d)
DAL                        (da)
Dart                       (dart)
diff                       (diff)
DITA                       (dita)
DOS Batch                  (bat, BAT, btm, BTM, cmd, CMD)
DTD                        (dtd)
ECPP                       (ecpp)
Elixir                     (ex, exs)
ERB                        (ERB, erb)
Erlang                     (erl, hrl)
Expect                     (exp)
F#                         (fs, fsi)
Focus                      (focexec)
Fortran 77                 (f, F, f77, F77, for, FOR, FTN, ftn, pfo)
Fortran 90                 (f90, F90)
Fortran 95                 (f95, F95)
Go                         (go)
Grails                     (gsp)
Groovy                     (gant, gradle, groovy)
Haml                       (haml)
Handlebars                 (handlebars, hbs)
Harbour                    (hb)
Haskell                    (hs, lhs)
HLSL                       (cg, cginc, shader)
HTML                       (htm, html)
IDL                        (idl)
IDL/Qt Project/Prolog      (pro)
InstallShield              (ism)
Java                       (java)
Javascript                 (js)
JavaServer Faces           (jsf, xhtml)
JCL                        (jcl)
JSON                       (json)
JSP                        (jsp, jspf)
Kermit                     (ksc)
Korn Shell                 (ksh)
Kotlin                     (kt)
LESS                       (less)
lex                        (l)
Lisp                       (el, lisp, lsp, sc)
Lisp/Julia                 (jl)
Lisp/OpenCL                (cl)
LiveLink OScript           (oscript)
Lua                        (lua)
m4                         (ac, m4)
make                       (am, gnumakefile, Gnumakefile, makefile, Makefile)
MATLAB                     (m)
Maven                      (pom, pom.xml)
Modula3                    (i3, ig, m3, mg)
MSBuild script             (csproj, vbproj, vcproj, wdproj, wixproj)
MUMPS                      (mps, m)
Mustache                   (mustache)
MXML                       (mxml)
NAnt script                (build)
NASTRAN DMAP               (dmap)
Objective C                (m)
Objective C++              (mm)
OCaml                      (ml, mli, mll, mly)
Oracle Forms               (fmt)
Oracle Reports             (rex)
Pascal                     (dpr, p, pas)
Pascal/Puppet              (pp)
Patran Command Language    (pcl, ses)
Perl                       (perl, plh, plx, pm)
Perl/Prolog                (PL, pl)
PHP                        (php, php3, php4, php5)
PHP/Pascal                 (inc)
Pig Latin                  (pig)
PL/I                       (pl1)
PowerShell                 (ps1)
Prolog                     (P)
Protocol Buffers           (proto)
PureScript                 (purs)
Python                     (py)
QML                        (qml)
R                          (R)
Racket                     (rkt, rktl, sch, scm, scrbl, ss)
Razor                      (cshtml)
Rexx                       (rexx)
RobotFramework             (robot, tsv)
Ruby                       (rake, rb)
Ruby HTML                  (rhtml)
Rust                       (rs)
SAS                        (sas)
SASS                       (sass, scss)
Scala                      (scala)
sed                        (sed)
SKILL                      (il)
SKILL++                    (ils)
Smarty                     (smarty, tpl)
Softbridge Basic           (sbl, SBL)
SQL                        (psql, sql, SQL)
SQL Data                   (data.sql)
SQL Stored Procedure       (spc.sql, spoc.sql, sproc.sql, udf.sql)
Standard ML                (fun, sig, sml)
Swift                      (swift)
Tcl/Tk                     (itk, tcl, tk)
Teamcenter met             (met)
Teamcenter mth             (mth)
Titanium Style Sheet       (tss)
TypeScript                 (ts)
Unity-Prefab               (mat, prefab)
Vala                       (vala)
Vala Header                (vapi)
Velocity Template Language (vm)
Verilog-SystemVerilog      (sv, svh, v)
VHDL                       (VHD, vhd, vhdl, VHDL)
vim script                 (vim)
Visual Basic               (bas, cls, ctl, dsr, frm, VB, vb, VBA, vba, vbs, VBS)
Visual Fox Pro             (sca, SCA)
Visualforce Component      (component)
Visualforce Page           (page)
Windows Message File       (mc)
Windows Module Definition  (def)
Windows Resource File      (rc, rc2)
WiX include                (wxi)
WiX source                 (wxs)
WiX string localization    (wxl)
XAML                       (xaml)
xBase                      (prg)
xBase Header               (ch)
XML                        (XML, xml)
XQuery                     (xq, xquery)
XSD                        (xsd, XSD)
XSLT                       (xsl, XSL, xslt, XSLT)
yacc                       (y)
YAML                       (yaml, yml)

Выше список может быть изменен, читая определения языка из файла с --read-lang-def или --force-lang-def вариантов.

Восемь расширений файлов есть несколько сопоставлений языка:

• .cl файлы могут быть Lisp или OpenCL

• .INC файлы могут быть PHP или Pascal

• .jl файлы могут быть Lisp или Julia

• .m файлы могут быть MATLAB, Mercury, MUMPS, или Objective C

• .P файлы могут быть D или DTrace

• .pl файлы могут быть Perl или Prolog

• .PP файлы могут быть Pascal или Puppet

• .pro файлы могут быть IDL, Prolog, или Qt Project

Cloc имеет подпрограммы, которые пытаются определить правильный язык, основанный на содержимое файла для этих особых случаев. Точность идентификации Язык функция, как много кода файл содержит; .m файлы с помощью всего одного или двух линий, например, редко имеют достаточно информации, чтобы правильно различать MATLAB, Меркурий, эпидемического паротита, или Objective C.

Языки с расширением файла столкновений трудно настроить с --read-lang-def четкости или --force-lang-def четкости, поскольку они не имеют никакого механизма для выявления языки с общими расширений. В этой ситуации необходимо изменить исходный код Cloc.


Как это работает

Метод Cloc о работе напоминает SLOCCount: во-первых, создать список файлов, чтобы рассмотреть. Далее, попытка определить, является ли или не найден файлы содержат признанный источник компьютерный язык кода. Наконец, для файлов, определенных как исходных файлов, вызовите конкретного языка процедуры, чтобы подсчитать количество строк исходного кода.

Более подробное описание:

1. Если входной файл архива (например, .tar.gz или .zip), создать временный каталог и развернуть архив есть с помощью системного вызова к соответствующему основной утилиты (tar, bzip2, unzip, и т.д.), то добавить Этот временный каталог в качестве одного из входов. (Это работает более надежно на Unix, чем на Windows.)

2. Используйте File::Find рекурсивно спускаться входные каталоги и составьте список имен файлов кандидат. Игнорировать двойных и нулевого размера файлов.

3. Убедитесь, что файлы в списке кандидата есть уникальные содержание (первый, сравнивая размеры файлов, то для тех же размеров файлов, сравнить MD5 хэши содержимого файлов с Digest::MD5). Для каждого набора одинаковых файлов, удалить все, кроме первой копии, как определено в лексической рода, одинаковых файлов из набора. Снятые файлы не включены в отчет. (Переключатель --skip-uniqueness отключает тесты уникальность и заставляет все копии файлов, которые будут включены в отчет.) См также --ignored= переключатель, чтобы увидеть, какие файлы были проигнорированы, и почему.

4. Просмотрите список кандидатов файла расширений файлов, которые Cloc ассоциируется с языками программирования (см --show-lang и --show-ext варианты). Файлы, которые соответствуют классифицируются как содержащие исходный код для данного языка. Каждый файл без расширения открывается и его первая строка чтения, чтобы увидеть, если это сценарий оболочки Unix (все, что начинается с #!). Если это сценарий оболочки, файл классифицируется этой языком сценариев (если язык признан). Если файл не имеет признанного расширение или не recognzied скриптовый язык, файл игнорируется.

5. Теперь все остальные файлы в списке кандидата должны быть исходные файлы для известных языков программирования. Для каждого из этих файлов:

1. Читайте весь файл в память.

2. Подсчитайте количество строк (=Loriginal).

3. Удалить пустые строки, то рассчитывать снова (=Lnon_blank).

4. Петлю на комментарий фильтров, определенных для этого языка. (Например, в C ++ имеет два фильтра: (1) удалить строки, которые начинаются с дополнительным пробелом с последующей // и (2) удалить текст между /* и */) применить каждый фильтр к коду, чтобы удалить комментарии. Граф оставшиеся линии (=Lcode).

5. Сохранить расчеты для этого языка:

пустые строки = Loriginal - Lnon_blank

строки комментариев = Lnon_blank - Lcode

строки кода = Lcode

Варианты изменить алгоритм немного. Опция --read-lang-def, например, позволяет пользователю читать определения комментарий фильтров, известных расширений файлов и известных языков сценариев из файла. Код для этой опции обрабатывается между шагами 2 и 3.


Расширенное использование

Удаление комментариев из исходного кода

Как вы можете сказать, если Cloc правильно определяет комментарии? Один из способов, чтобы убедить себя Cloc делает правильную вещь, чтобы использовать его --strip-comments опцию чтобы удалить комментарии и пустые строки из файлов, а затем сравнить урезанная файлы оригиналов.

Давайте попробуем это с SQLite amalgamation, С файл, содержащий все код, необходимый для построения SQLite библиотеки вместе с файлом заголовка:

prompt> tar zxf sqlite-amalgamation-3.5.6.tar.gz 
prompt> cd sqlite-3.5.6/
prompt> cloc --strip-comments=nc sqlite.c
       1 text file.
       1 unique file.                              
Wrote sqlite3.c.nc
       0 files ignored.

http://cloc.sourceforge.net v 1.03  T=1.0 s (1.0 files/s, 82895.0 lines/s)
-------------------------------------------------------------------------------
Language          files     blank   comment      code    scale   3rd gen. equiv
-------------------------------------------------------------------------------
C                     1      5167     26827     50901 x   0.77 =       39193.77
-------------------------------------------------------------------------------

Аргумент продление дается --strip-comments произвольно; здесь nc был использован как сокращение для "без комментариев".

Cloc удалил более 31000 строк из файла:

prompt> wc -l sqlite3.c sqlite3.c.nc 
  82895 sqlite3.c
  50901 sqlite3.c.nc
 133796 total
prompt> echo "82895 - 50901" | bc
31994

Теперь мы можем сравнить orignial файл, sqlite3.c и один зачищенный комментариев, sqlite3.c.nc с инструментами, как дифф или vimdiff и посмотреть, что именно считается Cloc комментарии и пустые строки. Строгое доказательство, что урезанная файл содержит тот же код C как оригинал, чтобы обобщить эти файлы и сравнить контрольные суммы полученных объектных файлов.

Во-первых, оригинальный источник файла:

prompt> gcc -c sqlite3.c
prompt> md5sum sqlite3.o
cce5f1a2ea27c7e44b2e1047e2588b49  sqlite3.o

Далее, версия без комментариев:

prompt> mv sqlite3.c.nc sqlite3.c
prompt> gcc -c sqlite3.c
prompt> md5sum sqlite3.o
cce5f1a2ea27c7e44b2e1047e2588b49  sqlite3.o

Cloc удалил более 31000 строк комментариев и пробелов, но не изменять исходный код в любом существенным образом, поскольку в результате объектный файл соответствует оригиналу.


Работа с сжатыми архивами

Версии Cloc до v1.07 требовала --extract-with= опцию возможность рассказать Cloc как расширить архивный файл. Начиная с v1.07 это добыча попытка автоматически. В настоящее время способ автоматического извлечения работает достаточно хорошо на Unix-типа OS для следующих типов файлов: .tar.gz, .tar.bz2, .tgz, .zip, .ear. Некоторые из этих расширений работать на Windows, если один WinZip установлен в папку по умолчанию (C:\Program Files\WinZip\WinZip32.exe). Кроме того, с более новыми версиями WinZip, дополнения командной строки необходимы для правильной работы; в этом случае можно было бы ссылаться Cloc что-то вроде

--extract-with="\"c:\Program Files\WinZip\wzunzip\" -e -o >FILE< ." (см. сообщение в форуме).

В ситуациях, когда автоматическое извлечение не удается, можно попробовать вариант --extract-with= опцию для подсчета строк кода в битуминозных файлов, Zip файлов, или других сжатых архивов для которых имеет инструмент для извлечения. Cloc принимает команду извлечения пользователем при условии, и расширяет архив во временную директорию (созданной с File::Temp), подсчитывает строки кода во временном каталоге, а затем удаляет этот каталог. В то время как не особенно полезно при работе с одной сжатого архива (в конце концов, если вы собираетесь в любом случае введите команду извлечения, почему не просто вручную развернуть архив?) Эта опция удобна для работы с несколькими архивами одновременно.

Например, у вас есть следующие исходные архивы на машине Unix:

perl-5.8.5.tar.gz

Python-2.4.2.tar.gz

и вы хотите подсчитать весь код внутри них. Команда будет следующая:

cloc --extract-with='gzip -dc >FILE< | tar xf -' perl-5.8.5.tar.gz Python-2.4.2.tar.gz

Если Unix машина имеет GNU tar (который может распаковать и извлечь в один прием) команда может быть сокращен до

cloc --extract-with='tar zxf >FILE<' perl-5.8.5.tar.gz Python-2.4.2.tar.gz

На компьютере Windows, с помощью WinZip, установленной в c:\Program Files\WinZip команда будет выглядеть так:

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 может обрабатывать вложенные в сжатые архивы без труда - при условии, все такие файлы сжимаются и сохраняются в том же пути. Примеры подсчета .ear файл Java в Unix и Windows:

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 линий. Он добавьте две строки комментариев, или удалить семнадцать строк исходного и добавить четырнадцать исходные линии и пять строк комментариев, или он сделал полный рерайт, отбрасывая все 100 оригинальных линий и добавления линии 102 всех новых источников? Опция разн рассказывает, как были добавлены многие линии источника, удаляется, изменения или остались же, как и были добавлены многие линии комментариев, удалены, изменены или остались прежними.

В дополнение к пар файлов, можно дать Cloc пары каталогов или пары файловых архивов, или файловый архив и каталог. 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-aligment=align.txt gcc-4.4.0.tar.bz2  gcc-4.5.0.tar.bz2

для получения файла align.txt который показывает файл пары, а также файлы, добавленные и удаленные. Символы == и != перед каждым пары файлов указать, если файлы идентичны (==), или если они имеют различное содержание (!=).

Вот пример вывода, показывающий разницу между Python релизами 2.6.6 и 2.7:

prompt> cloc --diff  Python-2.6.6.tar.bz2 Python-2.7.tar.bz2
      3870 text files.
      4130 text files.s
      2177 files ignored.                                         
  
  2 errors:
  Diff error (quoted comments?):  /tmp/4QAqkrHN7Z/Python-2.6.6/Mac/Modules/qd/qdsupport.py
  Diff error (quoted comments?):  /tmp/LvStB1lQxd/Python-2.7/Mac/Modules/qd/qdsupport.py
  
  http://cloc.sourceforge.net v 1.52  T=422.0 s (0.0 files/s, 0.0 lines/s)
  -------------------------------------------------------------------------------
  Language                     files          blank        comment           code
  -------------------------------------------------------------------------------
  vim script
   same                            0              0              7             85
   modified                        1              0              0             20
   added                           0              0              0              1
   removed                         0              0              0              0
  Expect
   same                            1              0              0             60
   modified                        0              0              0              0
   added                           6              0              0              0
   removed                         0              0              0              0
  CSS
   same                            1              0             19            318
   modified                        0              0              0              0
   added                           0              0              0              0
   removed                         0              0              0              0
  XML
   same                            1              0              0              4
   modified                        0              0              0              0
   added                           3              0              0              0
   removed                         1              0              0              0
  m4
   same                            1              0             19           1089
   modified                        2              0              0            130
   added                           5              6              5            150
   removed                         0            660             15           5905
  Visual Basic
   same                            2              0              1             12
   modified                        0              0              0              0
   added                           0              0              0              0
   removed                         0              0              0              0
  Lisp
   same                            1              0            503           2933
   modified                        0              0              0              0
   added                           0              0              0              0
   removed                         0              0              0              0
  NAnt scripts
   same                            2              0              0             30
   modified                        0              0              0              0
   added                           0              0              0              0
   removed                         0              0              0              0
  HTML
   same                           12              0             11           2329
   modified                        2              0              0              2
   added                           0              0              0              0
   removed                         9              0              0              0
  make
   same                            3              0            353           2888
   modified                        7              0              3             11
   added                           2              1              0             14
   removed                         0              2              0              8
  Objective C
   same                            6              0             70            633
   modified                        1              0              0              2
   added                           0              0              0              0
   removed                         0              0              0              0
  Assembly
   same                           22              0           1575           9156
   modified                       14              0             78            174
   added                           3            171            111            998
   removed                         2              1              0            189
  Bourne Shell
   same                           26              0           2828          20114
   modified                        7              0            255           2179
   added                           5            163           1103           4770
   removed                         0            550           2444          11660
  (unknown)
   same                            0              0              0              0
   modified                        0              0              0              0
   added                          32              0              0              0
   removed                        26              0              0              0
  C++
   same                            0              0              0              0
   modified                        0              0              0              0
   added                           2              0              0              0
   removed                         0              0              0              0
  Teamcenter def
   same                            6              0            158            885
   modified                        2              0              0              0
   added                           1              2              4             17
   removed                         1              0              4              2
  DOS Batch
   same                           26              0            101            416
   modified                        5              0              1              8
   added                           1              0              0              0
   removed                         0              0              0              0
  C/C++ Header
   same                          143              0           9016          37452
   modified                       90              0            157          15564
   added                          12            181            341          10247
   removed                         1            101            129           5219
  C
   same                          222              0          28753         322642
   modified                      157              0            542           5023
   added                         141           1485           1730          12440
   removed                         4            223            619           4519
  Python
   same                         1211              0          92289         348923
   modified                      740              0           1238          11589
   added                         114           2845           4645          17251
   removed                        23           1409           2617           6385
  -------------------------------------------------------------------------------
  SUM:
   same                         1686              0         135703         749969
   modified                     1028              0           2274          34702
   added                         327           4854           7939          45888
   removed                        67           2946           5828          33887
  -------------------------------------------------------------------------------

Обратите внимание на две ошибки для файла Python-X/Mac/Modules/qd/qdsupport.py. Этот файл имеет Python строки документации (текст между парами тройных кавычек), которые содержат C комментарии. Cloc лечит строки документации как комментарии и обрабатывает их сначала преобразовать их в С комментариями, то с помощью C комментарий удаление регулярное выражение. Вложенные комментарии C провоцировать ошибочные результаты, однако.

Там также выход для языка "(неизвестного)". Файлы в этой категории не являются исходные файлы, и поэтому не учитываются; их присутствие лишь отметить, как будто они были удалены, добавлены или модифицированы.


Создание пользовательских определений языка

Cloc можете написать свои определения языка комментарий к файлу или можете прочитать определения комментарий из файла, перекрывая встроенные определения. Это может быть полезно, когда вы хотите использовать Cloc рассчитывать линии языке еще не включены, чтобы изменить ассоциации расширений файлов с языками, или изменить способ существующих языков подсчитываются.

Самый простой способ для создания пользовательского файла определения языка, чтобы сделать Cloc написать свои определения в файл, а затем изменить файл:

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

создает файл my_definitions.txt, которые могут быть изменены, то читать еще в ни --read-lang-def или --force-lang-def опцию. Разница между вариантами бывший определения слияния языка из данного файла с использованием внутренних определений Cloc с cloc'taking приоритет, если есть совпадения. Опция --force-lang-def, с другой стороны, заменяет определения Cloc совершенно. Эта опция имеет недостаток в предотвращении Cloc от подсчета языков чья расширенная карта имеет несколько языков, так как эти языки требуют дополнительной логики, которая не может быть выражена в файлах описаний.

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

Каждая запись в языке состоит из четырех частей:

1. Название языка, начиная с колонки 1.

2. Один или несколько фильтров комментариев, начиная в колонке 5.

3. Один или несколько расширений имен файлов, начинающиеся в колонке 5.

4. Коэффициент 3 шкала поколение, начиная с колонки 5. Эта запись должна быть предоставлена, но его значение не важно, если вы не хотите, чтобы сравнить язык в гипотетической языке программирования третьего поколения.

Фильтр определяет метод удаления текста комментария из исходного файла. Например вход для C ++ выглядит так:

C++
    filter remove_matches ^\s*//
    filter call_regexp_common C
    extension C
    extension cc
    extension cpp
    extension cxx
    extension pcc
    3rd_gen_scale 1.51

C++ имеет два фильтра: во-первых, удалить строки, которые начинаются с дополнительным пробелом и последующим //. Затем удалите все комментарии C. C комментарии трудно выразить, как регулярные выражения, чтобы вызов на Regexp::Common, чтобы получить соответствующую регулярное выражение, чтобы соответствовать C комментарии, которые затем удаляются.

Более полное обсуждение различных вариантов фильтров может появиться здесь в будущем. Выход опции --write-lang-def Cloc должны обеспечить достаточное количество примеров для мотивированных людей, чтобы изменить или расширить определения языка Cloc.


Объединенные отчеты

Если вы управляете несколькими проектами программного обеспечения вы можете быть заинтересованы в том, счетчики линии по проекту, а не только по языку. Скажем, вы управлять три программных проектов называемые MySQL, PostgreSQL, и SQLite. Команды, отвечающие за каждый из этих проектов запустить Cloc на их исходного кода и предоставить Вам с выходом. Например команда MySQL делает:

cloc --report-file=mysql-5.1.42.txt mysql-5.1.42.tar.gz

и снабжает вас файловом mysql-5.1.42.txt. Содержание из трех файлов вы получаете такое:

Unix> cat mysql-5.1.42.txt
http://cloc.sourceforge.net v 1.50  T=26.0 s (108.1 files/s, 65774.5 lines/s)
--------------------------------------------------------------------------------
Language                      files          blank        comment           code
--------------------------------------------------------------------------------
C++                             615          93609         110909         521041
C                               642          83179          82424         393602
C/C++ Header                   1065          33980          77633         142779
Bourne Shell                    178          14892          11437          74525
Perl                             60           7634           4667          22703
m4                               13           1220            394          10497
make                            119            914           1855           4447
XML                              27            564             23           4107
SQL                              18            517            209           3433
Assembly                         12            161              0           1304
yacc                              2            167             40           1048
lex                               2            332            113            879
Teamcenter def                   43             85            219            701
Javascript                        3             70            140            427
Pascal                            2              0            436            377
HTML                              1              7              0            250
Bourne Again Shell                1              6              1             48
DOS Batch                         8             23             73             36
--------------------------------------------------------------------------------
SUM:                           2811         237360         290573        1182204
--------------------------------------------------------------------------------
Unix> cat sqlite-3.6.22.txt
http://cloc.sourceforge.net v 1.50  T=3.0 s (4.7 files/s, 53833.7 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                                2           7459          37993          68944
Bourne Shell                     7           3344           4522          25849
m4                               2            754             20           6557
C/C++ Header                     2            155           4808           1077
make                             1              6              0             13
-------------------------------------------------------------------------------
SUM:                            14          11718          47343         102440
-------------------------------------------------------------------------------

Unix> cat postgresql-8.4.2.txt
http://cloc.sourceforge.net v 1.50  T=16.0 s (129.1 files/s, 64474.9 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                              923         102324         167390         563865
C/C++ Header                   556           9180          22723          40990
Bourne Shell                    51           3692           3245          28486
SQL                            260           8246           5645          25862
yacc                             6           2667           2126          22825
Perl                            36            782            696           4894
lex                              8            708           1525           3638
make                           180           1215           1385           3453
m4                              12            199             25           1431
Teamcenter def                  13              4              0           1104
HTML                             2             94              1            410
DOS Batch                        7             53             22            188
XSLT                             5             41             30            111
Assembly                         3             17              0            105
D                                1             14             14             65
CSS                              1             16              7             44
sed                              1              1              7             15
Python                           1              5              1             12
-------------------------------------------------------------------------------
SUM:                          2066         129258         204842         697498
-------------------------------------------------------------------------------

В то время как эти три файла интересно, вы также хотите, чтобы увидеть объединенные рассчитывает из всех проектов. Это может быть сделано с Cloc опцией --sum_reports:

Unix> cloc --sum-reports --report_file=databases mysql-5.1.42.txt  postgresql-8.4.2.txt  sqlite-3.6.22.txt
Wrote databases.lang
Wrote databases.file

Сочетание отчет производит два выходных файлов, один для сумм по языку программирования (databases.lang) и один проект (databases.file). Их содержание следующие:

Unix> cat databases.lang
http://cloc.sourceforge.net v 1.50
--------------------------------------------------------------------------------
Language                      files          blank        comment           code
--------------------------------------------------------------------------------
C                              1567         192962         287807        1026411
C++                             615          93609         110909         521041
C/C++ Header                   1623          43315         105164         184846
Bourne Shell                    236          21928          19204         128860
SQL                             278           8763           5854          29295
Perl                             96           8416           5363          27597
yacc                              8           2834           2166          23873
m4                               27           2173            439          18485
make                            300           2135           3240           7913
lex                              10           1040           1638           4517
XML                              27            564             23           4107
Teamcenter def                   56             89            219           1805
Assembly                         15            178              0           1409
HTML                              3            101              1            660
Javascript                        3             70            140            427
Pascal                            2              0            436            377
DOS Batch                        15             76             95            224
XSLT                              5             41             30            111
D                                 1             14             14             65
Bourne Again Shell                1              6              1             48
CSS                               1             16              7             44
sed                               1              1              7             15
Python                            1              5              1             12
--------------------------------------------------------------------------------
SUM:                           4891         378336         542758        1982142
--------------------------------------------------------------------------------

Unix> cat databases.file
----------------------------------------------------------------------------------
Report File                     files          blank        comment           code
----------------------------------------------------------------------------------
mysql-5.1.42.txt                 2811         237360         290573        1182204
postgresql-8.4.2.txt             2066         129258         204842         697498
sqlite-3.6.22.txt                  14          11718          47343         102440
----------------------------------------------------------------------------------
SUM:                             4891         378336         542758        1982142
----------------------------------------------------------------------------------

Сообщить файлы сами по себе могут быть суммируются. Скажем, вы также управлять развития Perl и Python, и вы хотите, чтобы отслеживать тех, линия насчитывает отдельно от проектов баз данных. Во-первых, создание отчетов за Perl и Python отдельно:

cloc --report-file=perl-5.10.0.txt perl-5.10.0.tar.gz
cloc --report-file=python-2.6.4.txt Python-2.6.4.tar.bz2

затем сложить их вместе

Unix> cloc --sum-reports --report_file=script_lang perl-5.10.0.txt python-2.6.4.txt
Wrote script_lang.lang
Wrote script_lang.file

Unix> cat script_lang.lang
http://cloc.sourceforge.net v 1.50
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                              518          61871          52705         473034
Python                        1965          76022          95289         365716
Perl                          2052         110356         130018         292281
C/C++ Header                   381          13762          21402         102276
Bourne Shell                   149           9376          11665          81508
Lisp                             2           1154           2745          10448
Assembly                        38           1616           1712           9755
m4                               3            825             34           7124
make                            16            954            804           4829
HTML                            25            516             13           3010
Teamcenter def                   9            170            162           2075
XML                             28            288              0           2034
C++                             10            312            277           2000
yacc                             2            128             97           1549
DOS Batch                       42            175            152            746
Objective C                      7            102             70            635
YAML                             2              2              0            489
CSS                              1             94             19            308
vim script                       1             36              7            105
Expect                           1              0              0             60
NAnt scripts                     2              1              0             30
Visual Basic                     2              1              1             12
-------------------------------------------------------------------------------
SUM:                          5256         277761         317172        1360024
-------------------------------------------------------------------------------

Unix> cat script_lang.file
-------------------------------------------------------------------------------
Report File                  files          blank        comment           code
-------------------------------------------------------------------------------
python-2.6.4.txt              2746         135676         143269         830347
perl-5.10.0.txt               2510         142085         173903         529677
-------------------------------------------------------------------------------
SUM:                          5256         277761         317172        1360024
-------------------------------------------------------------------------------

Наконец, объединить комбинации файлов:

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

Unix> cat everything.lang
http://cloc.sourceforge.net v 1.50
--------------------------------------------------------------------------------
Language                      files          blank        comment           code
--------------------------------------------------------------------------------
C                              2085         254833         340512        1499445
C++                             625          93921         111186         523041
Python                         1966          76027          95290         365728
Perl                           2148         118772         135381         319878
C/C++ Header                   2004          57077         126566         287122
Bourne Shell                    385          31304          30869         210368
SQL                             278           8763           5854          29295
m4                               30           2998            473          25609
yacc                             10           2962           2263          25422
make                            316           3089           4044          12742
Assembly                         53           1794           1712          11164
Lisp                              2           1154           2745          10448
XML                              55            852             23           6141
lex                              10           1040           1638           4517
Teamcenter def                   65            259            381           3880
HTML                             28            617             14           3670
DOS Batch                        57            251            247            970
Objective C                       7            102             70            635
YAML                              2              2              0            489
Javascript                        3             70            140            427
Pascal                            2              0            436            377
CSS                               2            110             26            352
XSLT                              5             41             30            111
vim script                        1             36              7            105
D                                 1             14             14             65
Expect                            1              0              0             60
Bourne Again Shell                1              6              1             48
NAnt scripts                      2              1              0             30
sed                               1              1              7             15
Visual Basic                      2              1              1             12
--------------------------------------------------------------------------------
SUM:                          10147         656097         859930        3342166
--------------------------------------------------------------------------------

Unix> cat everything.file
-------------------------------------------------------------------------------
Report File                  files          blank        comment           code
-------------------------------------------------------------------------------
databases.lang                4891         378336         542758        1982142
script_lang.lang              5256         277761         317172        1360024
-------------------------------------------------------------------------------
SUM:                         10147         656097         859930        3342166
-------------------------------------------------------------------------------


SQL

Cloc может записать результаты в виде таблицы SQL создать и вставить заявления для использования с реляционными базами данных программ, таких как SQLite, MySQL, PostgreSQL, Oracle, Microsoft SQL или. После того, как информация Количество код в базе данных, информация может быть допрошен и отображаются в интересных способов.

База данных, созданная Cloc и выведенная в SQL имеет две таблицы, metadata и t:

metadata

Field Type
  timestamp       text
  project   text
  elapsed_s   real
                       

t

Field Type
  project       text
  language   text
  file   text
  nBlank   integer
  nComment   integer
  nCode   integer
  nScaled   real

Таблица metadata содержит информацию о том, когда был сделан Cloc выполнения. Переключатель --sql-append позволяет объединить множество трасс в единой базе данных; при каждом запуске добавляет строку в таблицу метаданных. Информация подсчет код находится в таблице t.

Давайте повторим примеры подсчета кода Perl, Python, SQLite, MySQL и PostgreSQL архивы, показанные в примере объединенных отчетов выше, на этот раз с помощью опции вывода SQL и движок базы данных SQLite.

--sql переключатель указывает Cloc генерировать вывод в виде таблицы SQL create и insert команды. Переключатель принимает аргумент имени файла, чтобы написать эти SQL заявления в, или, если аргумент 1 (числовое один), ручьи вывод STDOUT. С SQLite программы командной строки, sqlite3, можете прочитать команды из стандартного ввода, мы можем обойтись без хранения SQL заявления в файл и использовать --sql 1 к данным труб непосредственно в исполняемый файл SQLite:

cloc --sql 1 --sql-project mysql mysql-5.1.42.tar.gz    | sqlite3 code.db

--sql-project mysql часть является необязательной; нет необходимости указывать название проекта, когда работать только с одной базой кода. Однако, поскольку мы будем добавлять счетчики кода из четырех других тарболов мы будем только в состоянии определить данные, источник входного сигнала, если мы поставляем имя проекта для каждого прогона.

Теперь у нас есть база данных нам нужно будет пройти в коммутаторе --sql-append дописывания сказать Cloc не уничтожить эту базу данных, но вместо того, чтобы добавить больше данных:

cloc --sql 1 --sql-project postgresql --sql-append postgresql-8.4.2.tar.bz2          | sqlite3 code.db
cloc --sql 1 --sql-project sqlite     --sql-append sqlite-amalgamation-3.6.22.tar.gz | sqlite3 code.db
cloc --sql 1 --sql-project python     --sql-append Python-2.6.4.tar.bz2              | sqlite3 code.db
cloc --sql 1 --sql-project perl       --sql-append perl-5.10.0.tar.gz                | sqlite3 code.db

Теперь начинается самое интересное - у нас есть базы данных, code.db, с большим количеством информации о пяти проектов и может начать его запросов для всяких интересных фактов.


Какой был самый длинный файл среди всех проектов?

>  sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t where nL = (select max(nBlank+nComment+nCode) from t)'

sqlite|sqlite-3.6.22/sqlite3.c|110860

Формат вывода по умолчанию sqlite3 оставляет желать лучшего. Мы можем добавить опцию в файл гс программы, ~/.sqliterc, чтобы показать заголовки столбцов:

.header on

Один может возникнуть соблазн также

.mode column

в ~/.sqliterc но это вызывает проблемы, когда выход имеет более чем одну строку, так как ширина записей в первой строке регулируют максимальную ширину для всех последующих рядов. Часто это приводит к усеченной выходе - совсем не желательны. Одним из вариантов является, чтобы написать выходной форматирования пользовательских данных SQLite, таких как sqlite_formatter. Он используется так:

>  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-3.6.22/sqlite3.c 110860

Отметим также, что sqlite3 имеет опцию вывода HTML, --html, что также может оказаться полезным.


Какой бывает самый длинный файл в каждом проекте?

> 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     
__________ _____________________________________________ ______ 
perl       perl-5.10.0/t/op/mkdir.t                       22658 
python     Python-2.6.4/Lib/email/quoprimime.py           28091 
postgresql postgresql-8.4.2/contrib/pgcrypto/pgp-pgsql.c  40041 
mysql      mysql-5.1.42/netware/mysqldump.def             51841 
sqlite     sqlite-3.6.22/config.sub                      110860 


Какие файлы в каждом проекте имеют больше всего строк кода?

> sqlite3 code.db 'select project,file,max(nCode) as nL from t group by project order by nL desc;' | sqlite_formatter

Project    File                                          nL    
__________ _____________________________________________ _____ 
sqlite     sqlite-3.6.22/config.sub                      66142 
mysql      mysql-5.1.42/netware/mysqldump.def            38555 
postgresql postgresql-8.4.2/contrib/pgcrypto/pgp-pgsql.c 36905 
python     Python-2.6.4/Lib/email/quoprimime.py          26705 
perl       perl-5.10.0/t/op/mkdir.t                      20079 


Какие исходные файлы С с количеством линий более 300 имеют соотношение комментариев ниже 1%?

> sqlite3 code.db 'select project, language, 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    Language File                                                                          nCode nComment comment_ratio      
__________ ________ _____________________________________________________________________________ _____ ________ __________________ 
mysql      C        mysql-5.1.42/scripts/mysql_fix_privilege_tables_sql.c                           658        0 0.0                
python     C        Python-2.6.4/Python/graminit.c                                                 2143        1 0.0466417910447761 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_turkish.c          2095        1 0.0477099236641221 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_french.c           1211        1 0.0825082508250825 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_french.c      1201        1 0.0831946755407654 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_hungarian.c        1182        1 0.084530853761623  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_hungarian.c   1178        1 0.0848176420695505 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_english.c          1072        1 0.0931966449207828 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_english.c     1064        1 0.0938967136150235 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_spanish.c          1053        1 0.094876660341556  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_spanish.c     1049        1 0.0952380952380952 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_italian.c          1031        1 0.0968992248062016 
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_italian.c     1023        1 0.09765625         
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_portuguese.c        981        1 0.10183299389002   
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_portuguese.c   975        1 0.102459016393443  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_romanian.c          967        1 0.103305785123967  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_2_romanian.c     961        1 0.103950103950104  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_finnish.c           720        1 0.13869625520111   
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_porter.c            717        1 0.139275766016713  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_finnish.c      714        1 0.13986013986014   
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_porter.c       711        1 0.140449438202247  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_KOI8_R_russian.c          660        1 0.151285930408472  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_russian.c           654        1 0.152671755725191  
python     C        Python-2.6.4/Mac/Modules/qt/_Qtmodule.c                                       26705       42 0.157026956294164  
python     C        Python-2.6.4/Mac/Modules/icn/_Icnmodule.c                                      1521        3 0.196850393700787  
mysql      C        mysql-5.1.42/strings/ctype-extra.c                                             8348       17 0.203227734608488  
python     C        Python-2.6.4/Python/Python-ast.c                                               5910       17 0.286823013328834  
python     C        Python-2.6.4/Mac/Modules/menu/_Menumodule.c                                    3263       10 0.305530094714329  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_dutch.c             596        2 0.334448160535117  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_dutch.c        586        2 0.340136054421769  
perl       C        perl-5.10.0/x2p/a2p.c                                                          2916       10 0.341763499658236  
python     C        Python-2.6.4/Mac/Modules/qd/_Qdmodule.c                                        6694       24 0.357249181303959  
python     C        Python-2.6.4/Mac/Modules/win/_Winmodule.c                                      3056       11 0.358656667753505  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_german.c            476        2 0.418410041841004  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_german.c       470        2 0.423728813559322  
perl       C        perl-5.10.0/x2p/walk.c                                                         2024       10 0.491642084562439  
python     C        Python-2.6.4/Mac/Modules/ctl/_Ctlmodule.c                                      5442       28 0.511882998171846  
python     C        Python-2.6.4/Mac/Modules/ae/_AEmodule.c                                        1347        7 0.51698670605613   
python     C        Python-2.6.4/Mac/Modules/app/_Appmodule.c                                      1712        9 0.52295177222545   
mysql      C        mysql-5.1.42/strings/ctype-euc_kr.c                                            8691       49 0.560640732265446  
mysql      C        mysql-5.1.42/storage/archive/archive_reader.c                                   348        2 0.571428571428571  
python     C        Python-2.6.4/Mac/Modules/evt/_Evtmodule.c                                       504        3 0.591715976331361  
python     C        Python-2.6.4/Modules/expat/xmlrole.c                                           1250        8 0.635930047694754  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_danish.c            312        2 0.636942675159236  
mysql      C        mysql-5.1.42/strings/ctype-gbk.c                                               9946       64 0.639360639360639  
postgresql C        postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_danish.c       310        2 0.641025641025641  
mysql      C        mysql-5.1.42/strings/ctype-gb2312.c                                            5735       40 0.692640692640693  
python     C        Python-2.6.4/Mac/Modules/res/_Resmodule.c                                      1621       12 0.734843845682792  
python     C        Python-2.6.4/Mac/Modules/drag/_Dragmodule.c                                    1046        8 0.759013282732448  
postgresql C        postgresql-8.4.2/contrib/hstore/hstore_op.c                                     522        4 0.760456273764259  
python     C        Python-2.6.4/Mac/Modules/list/_Listmodule.c                                    1022        8 0.776699029126214  
python     C        Python-2.6.4/Mac/Modules/te/_TEmodule.c                                        1198       10 0.827814569536424  
python     C        Python-2.6.4/Mac/Modules/cg/_CGmodule.c                                        1190       10 0.833333333333333  
postgresql C        postgresql-8.4.2/contrib/hstore/hstore_io.c                                     451        4 0.879120879120879  
postgresql C        postgresql-8.4.2/src/interfaces/ecpg/preproc/preproc.c                        36905      330 0.886262924667651  
python     C        Python-2.6.4/Modules/clmodule.c                                                2379       23 0.957535387177352  
python     C        Python-2.6.4/Mac/Modules/folder/_Foldermodule.c                                 306        3 0.970873786407767  


Какие десять самых длинных файлов (на основе строк кода), не имеют ни одного комментария вообще? Исключая заголовок и YAML файлы.

> sqlite3 code.db 'select project, file, nCode from t where nComment = 0 and language not in ("C/C++ Header", "YAML") order by nCode desc limit 10;' | sqlite_formatter

Project File                                                  nCode 
_______ _____________________________________________________ _____ 
python  Python-2.6.4/PC/os2emx/python26.def                    1188 
python  Python-2.6.4/Lib/test/cjkencodings_test.py             1019 
python  Python-2.6.4/Tools/msi/schema.py                        920 
python  Python-2.6.4/Lib/msilib/schema.py                       920 
perl    perl-5.10.0/symbian/config.sh                           810 
perl    perl-5.10.0/uconfig.sh                                  771 
python  Python-2.6.4/Tools/pybench/Lookups.py                   700 
mysql   mysql-5.1.42/scripts/mysql_fix_privilege_tables_sql.c   658 
python  Python-2.6.4/Tools/pybench/Numbers.py                   637 
python  Python-2.6.4/Tools/pybench/Arithmetic.py                596


Какие языки наиболее популярные (в плане строк кода) в каждом проекте?

> 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 
__________ __________________ _______ 
mysql      C++                 521041 
mysql      C                   393602 
mysql      C/C++ Header        142779 
mysql      Bourne Shell         74525 
mysql      Perl                 22703 
mysql      m4                   10497 
mysql      make                  4447 
mysql      XML                   4107 
mysql      SQL                   3433 
mysql      Assembly              1304 
mysql      yacc                  1048 
mysql      lex                    879 
mysql      Teamcenter def         701 
mysql      Javascript             427 
mysql      Pascal                 377 
mysql      HTML                   250 
mysql      Bourne Again Shell      48 
mysql      DOS Batch               36 
perl       Perl                292281 
perl       C                   140483 
perl       C/C++ Header         44042 
perl       Bourne Shell         36882 
perl       Lisp                  7515 
perl       make                  2044 
perl       C++                   2000 
perl       XML                   1972 
perl       yacc                  1549 
perl       YAML                   489 
perl       DOS Batch              322 
perl       HTML                    98 
postgresql C                   563865 
postgresql C/C++ Header         40990 
postgresql Bourne Shell         28486 
postgresql SQL                  25862 
postgresql yacc                 22825 
postgresql Perl                  4894 
postgresql lex                   3638 
postgresql make                  3453 
postgresql m4                    1431 
postgresql Teamcenter def        1104 
postgresql HTML                   410 
postgresql DOS Batch              188 
postgresql XSLT                   111 
postgresql Assembly               105 
postgresql D                       65 
postgresql CSS                     44 
postgresql sed                     15 
postgresql Python                  12 
python     Python              365716 
python     C                   332551 
python     C/C++ Header         58234 
python     Bourne Shell         44626 
python     Assembly              9755 
python     m4                    7124 
python     Lisp                  2933 
python     HTML                  2912 
python     make                  2785 
python     Teamcenter def        2075 
python     Objective C            635 
python     DOS Batch              424 
python     CSS                    308 
python     vim script             105 
python     XML                     62 
python     Expect                  60 
python     NAnt scripts            30 
python     Visual Basic            12 
sqlite     C                    68944 
sqlite     Bourne Shell         25849 
sqlite     m4                    6557 
sqlite     C/C++ Header          1077 
sqlite     make                    13 


Третье поколения факторов языкового масштабирования

Cloc версии до 1.50 по умолчанию вычисляется, за предоставленные входов, грубая оценка того, сколько строк кода будет нужно написать тот же код в гипотетическом языке третьего поколения компьютера. Для получения этого вывода один теперь должны использовать переключатель --3.

Масштабные коэффициенты были получены от версии языка соотношениях зацеплением перечисленных на веб-сайте Mayes Consulting, http://softwareestimator.com/IndustryData2.htm 2006 года с использованием этого уравнения:

Cloc масштабный коэффициент для языка X = 3-го поколения умолчанию коэффициент финансовой зависимости / язык X соотношения собственных и заемных

например,

Cloc масштабный фактор 3-го поколения для DOS Batch = 80/128 = 0,625

Самый большой недостаток этого подхода заключается в том, что для передач отношения определены для логических строк исходного кода не физические линии (который Cloc отсчетов). Значения в Cloc в "scale" и "3rd gen. equiv." колонки должны быть приняты с большим недоверием.


Ограничения

Определение комментарии в исходном коде сложнее, чем можно было бы ожидать. Многие языки потребуется полный парсер считаться правильно. Cloc не пытайтесь разобрать любой из языков он стремится рассчитывать, и поэтому является несовершенным инструментом. Ниже приведены известные проблемы:

1. Строки, содержащие как исходный код и комментарии считаются строк кода.

2. Маркеры комментариев в строках или документах-здесь рассматриваются как фактические маркеры комментариев, а не строчных литер. Например следующие строки кода C

printf(" /* ");
for (i = 0; i < 100; i++) {
    a += i;
}
printf(" */ ");

по всей видимости, Cloc как две линии C кода (линии с черным текстом) и трех линий комментарии (линии, которые имеют только красный текст - линии с черной и красной текста рассматриваются как код).

3. длинные комментарии Lua, не признаются.


Как заказать поддержку для дополнительных языков?

Если Cloc не признает язык в подсчете которого вы заинтересованы, разместите следующую информацию в Feature Request на SourceForge странице Cloc:

1. Расширения, связанные с языком. Если язык не полагается на расширения файлов, а вместо этого работает с фиксированными именами файлов или с #! стилем программных вызовов, объясните, что это так.

2. Описание того, как комментарии определены.

3. Ссылки на пример кода.


Автор

Al Danial


Благодарности

Wolfram Rösler обеспечил большинство примеров кода в наборе тестов. Эти примеры пришли из его Hello World Collection.

Ismet Kursunoglu нашел ошибки с MUMPS счетчиком и обеспечил доступ к компьютеру с большим телом кода MUMPS, чтобы протестировать Cloc.

Tod Huggins дал полезные советы для фильтров Visual Basic.

Антон Демичев нашел изъян с JSP счетчиком в Cloc v0.76 и написал XML выводящий генератор опции --xml.

Reuben Thomas отметил, что ИСО С99 позволяет // как маркера комментария, предоставил код для опций --no3 и --stdin-name, посчитал язык m4, и предложил несколько усовершенствований пользовательского интерфейса.

Michael Bello предоставил код для опций --opt-match-f, --opt-not-match-f, --opt-match-d и --opt-not-match-d.

Mahboob Hussain вдохновил на опции --original-dir и --skip-uniqueness, нашел ошибку в логике обнаружения дубликатов файлов и улучшил фильтр JSP.

Randy Sharo обнаружил и исправил неинициализированную переменной ошибку для shell скриптов, имеющих только одну строку.

Steven Baker обнаружил и исправил проблему с генератором вывода YAML.

Greg Toth предоставил код для улучшения обнаружения пустой строки в COBOL.

Joel Oliveira предоставил код, позволяющий --exclude-list-file управлять исключениями имен каталогов.

Blazej Kroll предоставил код производящий XSLT-файл, cloc-diff.xsl, при формировании внешнего XML для опции --diff.

Денис Силаков усовершенствовал код, который генерирует cloc.xsl когда используются опции --by-file и --by-file-by-lang и предоставил XSL файл, который работает с выходом --diff.

Andy (awalshe@sf.net) предоставил код для исправления некоторых ошибок: правильный вывод из --counted, так, что только те файлы, которые используются при подсчете кода появляются и эти результаты показанные языком скорее чем имя файла; позволяют вывод --diff из нескольких запусков быть просуммированными вместе с --sum-reports.

Jari Aalto создал первоначальный вариант cloc.1.pod и поддерживает пакет Debian для Cloc.

Mikkel Christiansen (mikkels@gmail.com) предоставил определения счетчика для Clojure и ClojureScript.

Erik Gooven Arellano Casillas предоставил обновление для MXML счетчика для распознавания комментариев Actionscript.

Gianluca Casati создал cloc CPAN package.

Ryan Lindeman реализовал функцию --by-percent.

Kent C. Dodds, @kentcdodds, создал и поддерживает npm пакет для cloc.

Развитие cloc частично финансируется Northrop Grumman Corporation.


Авторское право

Copyright (c) 2006-2015,


Лицензия

Эта программа является бесплатным программным обеспечением; вы можете распространять ее и/или изменять ее в соответствии с условиями GNU General Public License, опубликованной Free Software Foundation; или версии 2 Лицензии, либо (по вашему выбору) любой более поздней версии.


Оригинал: http://cloc.sourceforge.net/

Домашняя страница