C:> cpan -i Digest::MD5
C:> cpan -i Regexp::Common
C:> cpan -i Algorithm::Diff
C:> cpan -i PAR::Packer
C:> pp -M Digest::MD5 -c -x -o cloc-1.74.exe cloc

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

Uso básico ▲

cloc é um programa de linha de comando que leva nomes de arquivo, diretório e / ou arquivo como entradas. Aqui está um exemplo de execução de cloc contra a distribuição de origem do Perl v5.22.0:

prompt> cloc perl-5.22.0.tar.gz
    5605 text files.
    5386 unique files.
    2176 files ignored.

https://github.com/AlDanial/cloc v 1.65  T=25.49 s (134.7 files/s, 51980.3 lines/s)
-----------------------------------------------------------------------------------
Language                         files          blank        comment           code
-----------------------------------------------------------------------------------
Perl                              2892         136396         184362         536445
C                                  130          24676          33684         155648
C/C++ Header                       148           9766          16569         147858
Bourne Shell                       112           4044           6796          42668
Pascal                               8            458           1603           8592
XML                                 33            142              0           2410
YAML                                49             20             15           2078
C++                                 10            313            277           2033
make                                 4            426            488           1986
Prolog                              12            438              2           1146
JSON                                14              1              0           1037
yacc                                 1             85             76            998
Windows Message File                 1            102             11            489
DOS Batch                           14             92             41            389
Windows Resource File                3             10              0             85
D                                    1              5              7              8
Lisp                                 2              0              3              4
-----------------------------------------------------------------------------------
SUM:                              3434         176974         243934         903874
-----------------------------------------------------------------------------------

Para executar o cloc em computadores com Windows, primeiro é preciso abrir uma janela de comando (aka DOS) e invocar cloc.exe da linha de comando lá.

Opções ▲

prompt> cloc --help

Usage: cloc [options]  |   | 

 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.
   --vcs=VCS                 Invoke a system call to VCS to obtain a list of
                             files to work on.  If VCS is 'git', then will
                             invoke 'git ls-files' to get a file list and
                             'git submodule status' to get a list of submodules
                             whose contents will be ignored.  See also --git
                             which accepts git commit hashes and branch names.
                             If VCS is 'svn' then will invoke 'svn list -R'.
                             The primary benefit is that cloc will then skip
                             files explicitly excluded by the versioning tool
                             in question, ie, those in .gitignore or have the
                             svn:ignore property.
                             Alternatively VCS may be any system command
                             that generates a list of files.
                             Note:  cloc must be in a directory which can read
                             the files as they are returned by VCS.  cloc will
                             not download files from remote repositories.
                             'svn list -R' may refer to a remote repository
                             to obtain file names (and therefore may require
                             authentication to the remote repository), but
                             the files themselves must be local.
   --unicode                 Check binary files to see if they contain Unicode
                             expanded ASCII text.  This causes performance to
                             drop noticeably.

 Processing Options
   --autoconf                Count .in files (as processed by GNU autoconf) of
                             recognized languages.  See also --no-autogen.
   --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.  If --out or --report-file is given,
                             three output files will be created, one for each
                             of the two counts and one for the diff.  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 any mix of files, directories, archives,
                             or git commit hashes (Unix only).
                             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/Mathematica/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).
   --git                     Forces the inputs to be interpreted as git targets
                             (commit hashes, branch names, et cetera) if these
                             are not first identified as file or directory
                             names.  This option overrides the --vcs=git logic
                             if this is given; in other words, --git gets its
                             list of files to work on directly from git using
                             the hash or branch name rather than from
                             'git ls-files'.  This option can be used with
                             --diff to perform line count diffs between git
                             commits, or between a git commit and a file,
                             directory, or archive.  Use -v/--verbose to see
                             the git system commands cloc issues.
   --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.
   --no-autogen[=list]       Ignore files generated by code-production systems
                             such as GNU autoconf.  To see a list of these files
                             (then exit), run with --no-autogen list
                             See also --autoconf.
   --original-dir            [Only effective in combination with
                             --strip-comments]  Write the stripped files
                             to the same directory as the original files.
   --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.  (Use - as the input name to
                             receive source code via STDIN.)
   --strip-comments=EXT      For each file processed, write to the current
                             directory a version of the file which has blank
                             and commented lines removed (in-line comments
                             persist).  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.
   --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.
   --use-sloccount           If SLOCCount is installed, use its compiled
                             executables c_count, java_count, pascal_count,
                             php_count, and xml_count instead of cloc's
                             counters.  SLOCCount's compiled counters are
                             substantially faster than cloc's and may give
                             a performance improvement when counting projects
                             with large files.  However, these cloc-specific
                             features will not be available: --diff,
                             --count-and-diff, --strip-comments, --unicode.
   --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 and subdirectories that have /.cache/
                             or /test/ as their parent directory.
                             Directories named .bzr, .cvs, .hg, .git, .svn,
                             and .snapshot are always excluded.
                             This option only works with individual directory
                             names so including file path separators is not
                             allowed.  Use --fullpath and --not-match-d=REGEX
                             to supply a regex matching multiple subdirectories.
   --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.
   --fullpath                Modifies the behavior of --match-f, --not-match-f,
                             and --not-match-d to include the file's path
                             in the regex, not just the file's basename.
                             (This does not expand each file to include its
                             absolute path, instead it uses as much of
                             the path as is passed in to cloc.)
                             Note:  --match-d always looks at the full
                             path and therefore is unaffected by --fullpath.
   --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/.  Unlike --not-match-d,
                             --match-f, and --not-match-f, --match-d always
                             compares the fully qualified path against the
                             regex.
   --not-match-d=REGEX       Count all files except those in directories
                             matching the Perl regex.  Only the trailing
                             directory name is compared, for example, when
                             counting in /usr/local/lib, only 'lib' is
                             compared to the regex.
                             Add --fullpath to compare parent directories to
                             the regex.
                             Do not include file path separators at the
                             beginning or end of the 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.
                             Add --fullpath to include parent directories
                             in the regex instead of just the basename.
   --not-match-f=REGEX       Count all files except those whose basenames
                             match the Perl regex.  Add --fullpath to include
                             parent directories in the regex instead of just
                             the basename.
   --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.
   --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.
   --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.
   --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).
   -verbose[=N]              Long form of -v.
   --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
   --json                    Write the results as JavaScript Object Notation
                             (JSON) formatted output.
   --md                      Write the results as Markdown-formatted text.
   --out=FILE                Synonym for --report-file=FILE.
   --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.

Idiomas Reconhecidos ▲

prompt> cloc --show-lang

ABAP                       (abap)
ActionScript               (as)
Ada                        (ada, adb, ads, pad)
ADSO/IDSM                  (adso)
AMPLE                      (ample, dofile, startup)
Ant                        (build.xml, build.xml)
ANTLR Grammar              (g, g4)
Apex Trigger               (trigger)
Arduino Sketch             (ino, pde)
ASP                        (asa, asp)
ASP.NET                    (asax, ascx, asmx, aspx, master, sitemap, webinfo)
AspectJ                    (aj)
Assembly                   (asm, s, S)
AutoHotkey                 (ahk)
awk                        (awk)
Blade                      (blade.php)
Bourne Again Shell         (bash)
Bourne Shell               (sh)
BrightScript               (brs)
builder                    (xml.builder)
C                          (c, ec, pgc)
C Shell                    (csh, tcsh)
C#                         (cs)
C++                        (C, c++, cc, cpp, CPP, cxx, pcc)
C/C++ Header               (H, h, hh, hpp, hxx)
CCS                        (ccs)
Chapel                     (chpl)
Clean                      (dcl, icl)
Clojure                    (clj)
ClojureC                   (cljc)
ClojureScript              (cljs)
CMake                      (cmake, CMakeLists.txt)
COBOL                      (CBL, cbl, COB, cob)
CoffeeScript               (coffee)
ColdFusion                 (cfm)
ColdFusion CFScript        (cfc)
Coq                        (v)
Crystal                    (cr)
CSON                       (cson)
CSS                        (css)
Cucumber                   (feature)
CUDA                       (cu, cuh)
Cython                     (pyx)
D                          (d)
DAL                        (da)
Dart                       (dart)
diff                       (diff)
DITA                       (dita)
DOORS Extension Language   (dxl)
DOS Batch                  (bat, BAT, BTM, btm, CMD, cmd)
Drools                     (drl)
DTD                        (dtd)
dtrace                     (d)
ECPP                       (ecpp)
EEx                        (eex)
Elixir                     (ex, exs)
Elm                        (elm)
ERB                        (erb, ERB)
Erlang                     (erl, hrl)
Expect                     (exp)
F#                         (fsi, fs, fs)
F# Script                  (fsx)
Focus                      (focexec)
Forth                      (4th, e4, f83, fb, forth, fpm, fr, frt, ft, fth, rx, fs, f, for)
Fortran 77                 (F, f77, F77, FOR, ftn, FTN, pfo, f, for)
Fortran 90                 (F90, f90)
Fortran 95                 (f95, F95)
Freemarker Template        (ftl)
GDScript                   (gd)
Glade                      (glade, ui)
GLSL                       (comp, frag, geom, glsl, tesc, tese, vert)
Go                         (go)
Grails                     (gsp)
GraphQL                    (gql, graphql)
Groovy                     (gant, gradle, groovy)
Haml                       (haml)
Handlebars                 (handlebars, hbs)
Harbour                    (hb)
Haskell                    (hs, lhs)
Haxe                       (hx)
HLSL                       (cg, cginc, hlsl, shader)
HTML                       (htm, html)
IDL                        (idl, pro)
Idris                      (idr)
INI                        (ini)
InstallShield              (ism)
Java                       (java)
JavaScript                 (es6, js)
JavaServer Faces           (jsf)
JCL                        (jcl)
JSON                       (json)
JSP                        (jsp, jspf)
JSX                        (jsx)
Julia                      (jl)
Kermit                     (ksc)
Korn Shell                 (ksh)
Kotlin                     (kt, kts)
LESS                       (less)
lex                        (l)
LFE                        (lfe)
liquid                     (liquid)
Lisp                       (asd, el, lisp, lsp, cl, jl)
Literate Idris             (lidr)
LiveLink OScript           (oscript)
Logtalk                    (lgt, logtalk)
Lua                        (lua)
m4                         (ac, m4)
make                       (am, Gnumakefile, gnumakefile, Makefile, makefile, mk)
Mako                       (mako)
Markdown                   (md)
Mathematica                (mt, wl, wlt, m)
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)
Nemerle                    (n)
Nim                        (nim)
Objective C                (m)
Objective C++              (mm)
OCaml                      (ml, mli, mll, mly)
OpenCL                     (cl)
Oracle Forms               (fmt)
Oracle Reports             (rex)
Pascal                     (dpr, p, pas)
Pascal/Puppet              (pp)
Patran Command Language    (pcl, ses)
Perl                       (perl, plh, plx, pm, pm6, pl)
PHP                        (php, php3, php4, php5, phtml)
PHP/Pascal                 (inc)
Pig Latin                  (pig)
PL/I                       (pl1)
PO File                    (po)
PowerBuilder               (sra, srf, srm, srs, sru, srw)
PowerShell                 (ps1, psd1, psm1)
Prolog                     (P, pl, pro)
Protocol Buffers           (proto)
Pug                        (pug)
PureScript                 (purs)
Python                     (py)
QML                        (qml)
Qt                         (ui)
Qt Linguist                (ts)
Qt Project                 (pro)
R                          (r, R)
Racket                     (rkt, rktl, scrbl)
RapydScript                (pyj)
Razor                      (cshtml)
Rexx                       (rexx)
RobotFramework             (robot, tsv)
Ruby                       (rake, rb)
Ruby HTML                  (rhtml)
Rust                       (rs)
SAS                        (sas)
Sass                       (sass, scss)
Scala                      (scala)
Scheme                     (sc, sch, scm, sld, sls, ss)
sed                        (sed)
SKILL                      (il)
SKILL++                    (ils)
Slice                      (ice)
Slim                       (slim)
Smalltalk                  (st, cs)
Smarty                     (smarty, tpl)
Softbridge Basic           (SBL, sbl)
Solidity                   (sol)
Specman e                  (e)
SQL                        (psql, SQL, sql)
SQL Data                   (data.sql)
SQL Stored Procedure       (spc.sql, spoc.sql, sproc.sql, udf.sql)
Standard ML                (fun, sig, sml)
Stata                      (do, DO)
Stylus                     (styl)
Swift                      (swift)
Tcl/Tk                     (itk, tcl, tk)
Teamcenter met             (met)
Teamcenter mth             (mth)
TeX                        (bst, dtx, sty, tex)
TITAN Project File Information (tpd)
Titanium Style Sheet       (tss)
TOML                       (toml)
TTCN                       (ttcn, ttcn2, ttcn3, ttcnpp)
Twig                       (twig)
TypeScript                 (tsx, 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)
Vuejs Component            (vue)
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)
XHTML                      (xhtml)
XMI                        (xmi, XMI)
XML                        (XML, xml)
XQuery                     (xq, xquery)
XSD                        (XSD, xsd)
XSLT                       (xsl, XSL, XSLT, xslt)
yacc                       (y)
YAML                       (yaml, yml)
zsh                        (zsh)

A lista acima pode ser personalizada, lendo definições de linguagem de um arquivo com o --read-lang-def ou a opçaõ --force-lang-def.

Estas extensões de arquivos mapeiam vários idiomas:

• .cl arquivos podem ser Lisp ou OpenCL
• .d os arquivos podem ser D ou Dtrace
• .f ou .for arquivos poderiam ser Fortran ou Forth
• .fs arquivos podem ser Forth ou F#
• .inc arquivos podem ser PHP ou Pascal
• .jl arquivos podem ser Lisp ou Julia
• .m arquivos podem ser MATLAB, Mathematica, Mercury, MUMPS ou Objective C
• .pl os arquivos podem ser Perl ou Prolog
• .pp arquivos podem ser Pascal ou Puppet
• .pro arquivos podem ser IDL, Prolog ou um Projeto Qt
• .ts os arquivos podem ser TypeScript ou Qt Linguist
• .v arquivos Coq ou Verilog/SystemVerilog

Cloc tem sub-rotinas que tentam identificar o idioma correto com base no conteúdo do arquivo para esses casos especiais. A precisão da identificação da linguagem é uma função da quantidade de código que o arquivo contém; arquivos .m com apenas uma ou duas linhas, por exemplo, raramente têm informações suficientes para distinguir corretamente entre MATLAB, Mercury, MUMPS ou Objective C.

Os idiomas com colisões de extensão de arquivo são difíceis de personalizar com --read-lang-def ou --force-lang-def pois não possuem mecanismos para identificar idiomas com extensões comuns. Nesta situação, é necessário modificar o código-fonte do cloc.

Como funciona ▲

O método de operação do cloc se assemelha a SLOCCount: primeiro, crie uma lista de arquivos a considerar. Em seguida, tente determinar se os arquivos encontrados ou não possuem código-fonte de idioma de computador reconhecido. Finalmente, para arquivos identificados como arquivos de origem, invoque rotinas específicas do idioma para contar o número de linhas de origem.

Uma descrição mais detalhada:

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

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

3. Certifique-se de que os arquivos na lista de candidatos possuem conteúdos exclusivos (primeiro, comparando tamanhos de arquivo, então, para arquivos de tamanho similar, compare os hashes MD5 do conteúdo do arquivo com Digest :: MD5). Para cada conjunto de arquivos idênticos, remova tudo, exceto a primeira cópia, conforme determinado por um tipo lexical, de arquivos idênticos do conjunto. Os arquivos removidos não estão incluídos no relatório. (O --skip-uniqueness desligar desativa os testes de singularidade e força todas as cópias de arquivos a serem incluídas no relatório.) Veja também o --ignored= mude para ver quais arquivos foram ignorados e por que.

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

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

   1. Leia todo o arquivo na memória.
   2. Contar o número de linhas (= L_original).
   3. Remova as linhas em branco, então conte novamente (= L_{non_blank}).
   4. Loop sobre os filtros de comentários definidos para este idioma. (Por exemplo, C ++ tem dois filtros: (1) remova linhas que começam com espaços em branco opcionais seguidos de // e (2) remova texto entre / * e * /) Aplique cada filtro no código para remover comentários. Conte a esquerda sobre linhas (= L_code).
   5. Salve as contagens para este idioma:
      • linhas em branco = L_original - L_{non_blank}
      • linhas de comentários = L_{non_blank} - L_code
      • linhas de código = L_code

As opções modificam o algoritmo ligeiramente. o --read-lang-def a opção, por exemplo, permite ao usuário ler definições de filtros de comentários, extensões de arquivos conhecidas e linguagens de script conhecidas a partir de um arquivo. O código para esta opção é processado entre os Passos 2 e 3.

Uso Avançado ▲

Remover comentários do código-fonte ▲

Como você pode dizer se o cloc identifica corretamente os comentários? Uma maneira de convencer-se de que o cloc está fazendo o certo é usar seu --strip-comments opção para remover comentários e linhas em branco de arquivos, em seguida, compare os arquivos despojados para originais.

Vamos tentar isso com a amalgamação SQLite, um arquivo C contendo todos os códigos necessários para criar a biblioteca SQLite juntamente com um arquivo de cabeçalho:

prompt> tar zxf sqlite-amalgamation-3.5.6.tar.gz
prompt> cd sqlite-3.5.6/
prompt> cloc --strip-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
-------------------------------------------------------------------------------

O argumento de extensão dado a --strip-comments é arbitrário; aqui nc foi usado como abreviatura de "nenhum comentário".

O cloc removeu mais de 31.000 linhas do arquivo:

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

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

Primeiro, o arquivo original:

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

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

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

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

Trabalhar com arquivos compactados ▲

As versões de cloc antes da v1.07 exigiram uma --extract-with=CMD opção para dizer ao cloc como expandir um arquivo de arquivo. Começando com v1.07, esta é a tentativa de extração automaticamente. No momento, o método de extração automática funciona razoavelmente bem nos sistemas operacionais de tipo Unix para os seguintes tipos de arquivos: .tar.gz, .tar.bz2, .tar.xz, .tgz, .zip, .ear, .deb. Algumas dessas extensões funcionam no Windows se alguém tiver o WinZip instalado no local padrão (C:\Program Files\WinZip\WinZip32.exe). Além disso, com versões mais recentes do WinZip, o [http://www.winzip.com/downcl.htm](command line add-on) é necessário para uma operação correta; neste caso, invocaria cloc com algo como

 --extract-with="\"c:\Program Files\WinZip\wzunzip\" -e -o >FILE< ."
 

Em situações em que a extração automática falha, pode-se tentar o --extract-with=CMD opção para contar linhas de código dentro de arquivos tar, arquivos Zip ou outros arquivos compactados para os quais se possui uma ferramenta de extração. cloc leva o comando de extração fornecido pelo usuário e expande o arquivo para um diretório temporário (criado com File :: Temp), conta as linhas de código no diretório temporário e, em seguida, remove esse diretório. Embora não seja especialmente útil ao lidar com um único arquivo comprimido (afinal, se você for digitar o comando de extração de qualquer maneira, por que não apenas expandir manualmente o arquivo?), Esta opção é útil para trabalhar com vários arquivos ao mesmo tempo..

Por exemplo, diga que você tem os seguintes tarballs de origem em uma máquina Unix

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

e você quer contar todo o código dentro deles. O comando seria

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

Se essa máquina Unix tiver GNU tar (que pode descompactar e extrair em um passo), o comando pode ser encurtado para

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

Em um computador Windows com WinZip instalado em c:\Program Files\WinZip o comando pareceria

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 arquivos são arquivos Zip que contêm arquivos Zip adicionais. O cloc pode lidar com arquivos comprimidos aninhados sem dificuldade - desde que todos esses arquivos sejam compactados e arquivados da mesma maneira. Exemplos de contar um Java .ear file in Unix and 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

Differences

O --diff O interruptor permite medir a mudança relativa no código-fonte e os comentários entre duas versões de um arquivo, diretório ou arquivo. As diferenças revelam muito mais do que as contagens de código absoluto de duas versões de arquivos. Por exemplo, digamos que um arquivo fonte possui 100 linhas e seu desenvolvedor oferece uma versão mais recente com 102 linhas. O desenvolvedor adicionou duas linhas de comentários ou excluiu dezessete linhas de origem e adicionou quatorze linhas de origem e cinco linhas de comentários, ou o desenvolvedor fez uma reescrita completa, descartando todas as 100 linhas originais e adicionando 102 linhas de todas as novas fontes? A opção diff indica quantas linhas de fonte foram adicionadas, removidas, modificadas ou permaneceram as mesmas, e quantas linhas de comentários foram adicionadas, removidas, modificadas ou permaneceram as mesmas.

Além dos pares de arquivos, pode-se dar pares de diretórios de cloc, ou pares de arquivos, ou um arquivo de arquivo e um diretório. Cloc tentará alinhar pares de arquivos dentro dos diretórios ou arquivos e comparar diffs para cada par. Por exemplo, para ver o que mudou entre o GCC 4.4.0 e 4.5.0, pode-se fazer

cloc --diff gcc-4.4.0.tar.bz2  gcc-4.5.0.tar.bz2

Esteja preparado para esperar um pouco pelos resultados; a --diff A opção corre muito mais devagar do que uma contagem absoluta de código.

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

cloc --diff-aligment=align.txt gcc-4.4.0.tar.bz2  gcc-4.5.0.tar.bz2

para produzir o arquivo align.txt que mostra os pares de arquivos, bem como os arquivos adicionados e excluídos. Os símbolos == e != antes de cada par de arquivos indicar se os arquivos são idênticos (==) ou se eles tiverem conteúdo diferente (!=).

Aqui está a saída da amostra mostrando a diferença entre os lançamentos do Python 2.6.6 e 2.7:

prompt> cloc --diff Python-2.7.9.tgz Python-2.7.10.tar.xz
    4315 text files.
    4313 text files.s
    2173 files ignored.

4 errors:
Diff error, exceeded timeout:  /tmp/8ToGAnB9Y1/Python-2.7.9/Mac/Modules/qt/_Qtmodule.c
Diff error, exceeded timeout:  /tmp/M6ldvsGaoq/Python-2.7.10/Mac/Modules/qt/_Qtmodule.c
Diff error (quoted comments?):  /tmp/8ToGAnB9Y1/Python-2.7.9/Mac/Modules/qd/qdsupport.py
Diff error (quoted comments?):  /tmp/M6ldvsGaoq/Python-2.7.10/Mac/Modules/qd/qdsupport.py

https://github.com/AlDanial/cloc v 1.65  T=298.59 s (0.0 files/s, 0.0 lines/s)
-----------------------------------------------------------------------------
Language                   files          blank        comment           code
-----------------------------------------------------------------------------
Visual Basic
 same                          2              0              1             12
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
make
 same                         11              0            340           2952
 modified                      1              0              0              1
 added                         0              0              0              0
 removed                       0              0              0              0
diff
 same                          1              0             87            105
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
CSS
 same                          0              0             19            327
 modified                      1              0              0              1
 added                         0              0              0              0
 removed                       0              0              0              0
Objective C
 same                          7              0             61            635
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
NAnt script
 same                          2              0              0             30
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
XML
 same                          3              0              2             72
 modified                      1              0              0              1
 added                         0              0              0              1
 removed                       0              1              0              0
Windows Resource File
 same                          3              0             56            206
 modified                      1              0              0              1
 added                         0              0              0              0
 removed                       0              0              0              0
Expect
 same                          6              0            161            565
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
HTML
 same                         14              0             11           2344
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
vim script
 same                          1              0              7            106
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
C++
 same                          2              0             18            128
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
Windows Module Definition
 same                          7              0            187           2080
 modified                      2              0              0              0
 added                         0              0              0              1
 removed                       0              1              0              2
Prolog
 same                          1              0              0             24
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
Javascript
 same                          3              0             49            229
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
Assembly
 same                         51              0           6794          12298
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
Bourne Shell
 same                         41              0           7698          45024
 modified                      1              0              0              3
 added                         0             13              2             64
 removed                       0              0              0              0
DOS Batch
 same                         29              0            107            494
 modified                      1              0              0              9
 added                         0              1              0              3
 removed                       0              0              0              0
MSBuild script
 same                         77              0              3          38910
 modified                      0              0              0              0
 added                         0              0              0              0
 removed                       0              0              0              0
Python
 same                       1947              0         109012         430335
 modified                    192              0             94            950
 added                         2            323            283           2532
 removed                       2             55             58            646
m4
 same                         18              0            191          15352
 modified                      1              0              0              2
 added                         1             31              0            205
 removed                       0              0              0              0
C
 same                        505              0          37439         347837
 modified                     45              0             13            218
 added                         0             90             33            795
 removed                       0              9              2            148
C/C++ Header
 same                        255              0          10361          66635
 modified                      5              0              5              7
 added                         0              1              3            300
 removed                       0              0              0              0
---------------------------------------------------------------------
SUM:
 same                       2986              0         172604         966700
 modified                    251              0            112           1193
 added                         3            459            321           3901
 removed                       2             66             60            796
---------------------------------------------------------------------

Ocorreu um par de erros. O primeiro par foi causado pelo tempo limite ao calcular diffs do arquivo Python-X/Mac/Modules/qt/_Qtmodule.c em cada versão do Python. Este arquivo tem > 26,000 linhas do código C e leva mais de 10 segundos - a duração máxima padrão para difamar um único arquivo - no meu computador lento. (Nota: refere-se a realizar diferenças com o sdiff() funciona no Perl Algorithm::Diff modulo, não a linha de comando diff utilidade.) Este erro pode ser superado aumentando o tempo para, digamos, 20 segundos com --diff-timeout 20.

O segundo erro é mais problemático. Os arquivos Python-X/Mac/Modules/qd/qdsupport.py incluir Python docstring (texto entre pares de cotações triplas) contendo comentários C. O cloc trata igrejas como comentários e manipula-os primeiro convertendo-os para comentários C, em seguida, usando o comentário C removendo a expressão regular. Os comentários C aninhados produzem resultados errôneos no entanto.

Criar definições de idioma personalizado ▲

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

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

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

cria o arquivo my_definitions.txt que pode ser modificado e depois lido de volta com o --read-lang-def ou --force-lang-def opção. A diferença entre as opções é o anterior mescla as definições de linguagem do arquivo fornecido com as definições internas do cloc com a prioridade do cloc se houver sobreposições. o --force-lang-def opção, por outro lado, substitui completamente as definições de cloc. Esta opção tem uma desvantagem na prevenção do cloc da contagem idiomas cujas extensões mapeiam para vários idiomas como essas linguas requerem lógica adicional que não é facilmente expressa em um arquivo de definições.

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

Cada entrada de idioma tem quatro partes:

• O nome do idioma que começa style="text-decoration: none;" na coluna 1.
• Um ou mais comentários filters starting in column 5.
• Uma ou mais extensões de nome de arquivo começando na coluna 5.
• Um fator de escala de 3ª geração a partir da coluna 5. Essa entrada deve ser fornecida, mas seu valor não é importante a menos que você queira comparar seu idioma com uma linguagem de programação hipotética de terceira geração.

Um filtro define um método para remover texto de comentários do arquivo de origem. Por exemplo, a entrada para C ++ parece assim

C++
    filter call_regexp_common C++
    filter remove_inline //.*$
    extension C
    extension c++
    extension cc
    extension cpp
    extension cxx
    extension pcc
    3rd_gen_scale 1.51
    end_of_line_continuation \\$

C ++ tem dois filtros: primeiro, remova as linhas que correspondem ao regex do comentário C ++ do Regexp :: Common. O segundo filtro usando remove_inline está atualmente não utilizado. Sua intenção é identificar linhas com código e comentários e pode ser implementada no futuro.

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

Combinar relatórios ▲

Se você gerencia vários projetos de software, talvez esteja interessado em ver contagens de linhas por projeto, não apenas por idioma. Digamos que você gerencie três projetos de software chamados MariaDB, PostgreSQL e SQLite. As equipes responsáveis por cada um desses projetos executam cloc no código-fonte e fornecem o resultado. Por exemplo, a equipe da MariaDB faz

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

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

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

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

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

Embora esses três arquivos sejam interessantes, você também deseja ver as contagens combinadas de todos os projetos. Isso pode ser feito com opção cloc --sum_reports:

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

A combinação de relatórios produz dois arquivos de saída, um para somas pela linguagem de programação (databases.lang) e um por projeto (databases.file). Seus conteúdos são

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

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

Os arquivos do relatório podem ser resumidos. Digamos que você também gerencie o desenvolvimento de Perl e Python e que deseja acompanhar essas contas de linha separadamente dos projetos de banco de dados. Primeiro crie relatórios para Perl e Python separadamente:

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

em seguida, somem estes em conjunto com

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

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

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

Finalmente, combine os arquivos de combinação:

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

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

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

SQL ▲

O Cloc pode escrever resultados na forma de tabela SQL criar e inserir instruções para uso com programas de banco de dados relacionais, como SQLite, MySQL, PostgreSQL, Oracle ou Microsoft SQL. Uma vez que as informações de contagem de código estão em um banco de dados, a informação pode ser interrogada e exibida de maneiras interessantes.

Um banco de dados criado a partir de saída cloc SQL tem duas tabelas, metadata e t:

Table metadata:

Table t:

A tabela metadata contém informações sobre quando o relógio foi executado. o --sql-append alternar permite combinar muitas execuções em um único banco de dados; cada execução adiciona uma linha à tabela de metadados. A informação de contagem de código reside na tabela t.

Vamos repetir os exemplos de contagem de códigos de tarballs Perl, Python, SQLite, MySQL e PostgreSQL mostrados no Combinar relatórios exemplo acima, desta vez usando as opções de saída SQL e o SQLite mecanismo de banco de dados.

O --sql switch diz ao cloc para gerar saída style="text-decoration: none;" na forma de tabela SQL create e comandos insert. O switch leva um argumento de um nome de arquivo para escrever essas instruções SQL, ou, se o argumento for 1 (numérico), o fluxo de saída para STDOUT. Como o programa de linha de comando SQLite, sqlite3, pode ler os comandos do STDIN, podemos dispensar o armazenamento de instruções SQL em um arquivo e usar --sql 1 para transmitir dados diretamente no executável SQLite:

cloc --sql 1 --sql-project mariadb mariadb-server-10.1.zip | sqlite3 code.db

A parte --sql-project mariadb é opcional; não há necessidade de especificar um nome de projeto ao trabalhar com apenas uma base de código. No entanto, uma vez que iremos adicionando contagens de códigos de outros quatro mapas, só poderemos identificar dados por fonte de entrada se fornecemos um nome de projeto para cada execução.

Agora que temos um banco de dados, precisaremos passar no --sql-append mude para dizer ao cloc que não limpe este banco de dados, mas, em vez disso, adicione mais dados:

cloc --sql 1 --sql-project postgresql --sql-append postgresql-9.4.4.tar.bz2        | sqlite3 code.db
cloc --sql 1 --sql-project sqlite     --sql-append sqlite-amalgamation-3081101.zip | sqlite3 code.db
cloc --sql 1 --sql-project python     --sql-append Python-2.7.10.tar.xz            | sqlite3 code.db
cloc --sql 1 --sql-project perl       --sql-append perl-5.22.0.tar.gz              | sqlite3 code.db

Agora a diversão começa - temos um banco de dados, code.db, with lots of information about the five projects and can query it for all manner of interesting facts.

Qual é o arquivo mais longo em todos os projetos?

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

sqlite|sqlite-amalgamation-3081101/sqlite3.c|161623

sqlite3 formato de saída padrão deixa um pouco a desejar. Podemos adicionar uma opção ao arquivo rc do programa, ~/.sqliterc, para mostrar cabeçalhos de coluna:

  .header on

Pode-se ter a impressão de incluir também

  .mode column

em ~/.sqliterc mas isso causa problemas quando a saída tem mais de uma linha, uma vez que as larguras das entradas na primeira linha governam a largura máxima para todas as linhas subseqüentes. Muitas vezes isso leva a saída truncada - não é desejável. Uma opção é escrever um formatador de saída SQLite personalizado, como sqlite_formatter, incluído com cloc.

Para usá-lo, simplesmente passe sqlite3's STDOUT entre sqlite_formatter através de um tubo:

prompt> sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t
                         where nL = (select max(nBlank+nComment+nCode) from t)' | ./sqlite_formatter
  
  -- Loading resources from ~/.sqliterc
  Project File                                  nL
  _______ _____________________________________ ______
  sqlite  sqlite-amalgamation-3081101/sqlite3.c 161623
  

Se a linha "Project File" não aparecer, adicione .header on para o seu ~/.sqliterc arquivo conforme explicado acima.

Qual é o arquivo mais longo em todos os projetos??

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

Project File                                  nL
_______ _____________________________________ ______
sqlite  sqlite-amalgamation-3081101/sqlite3.c 161623

Qual é o arquivo mais longo em cada projeto?

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

Project    File                                                             nL
__________ ________________________________________________________________ ______
python     Python-2.7.10/Mac/Modules/qt/_Qtmodule.c                          28091
postgresql postgresql-9.4.4/src/interfaces/ecpg/preproc/preproc.c            54623
mariadb    server-10.1/storage/mroonga/vendor/groonga/lib/nfkc.c             80246
perl       perl-5.22.0/cpan/Locale-Codes/lib/Locale/Codes/Language_Codes.pm 100747
sqlite     sqlite-amalgamation-3081101/sqlite3.c                            161623

Quais arquivos em cada projeto possuem a maioria das linhas de código?

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

Project    File                                                             nL
__________ ________________________________________________________________ ______
perl       perl-5.22.0/cpan/Locale-Codes/lib/Locale/Codes/Language_Codes.pm 100735
sqlite     sqlite-amalgamation-3081101/sqlite3.c                             97469
mariadb    server-10.1/storage/mroonga/vendor/groonga/lib/nfkc.c             80221
postgresql postgresql-9.4.4/src/interfaces/ecpg/preproc/preproc.c            45297
python     Python-2.7.10/Mac/Modules/qt/_Qtmodule.c                          26705

Quais arquivos de origem C com mais de 300 linhas têm uma relação de comentários abaixo de 1%?

prompt> sqlite3 code.db 'select project, file, nCode, nComment,
                         (100.0*nComment)/(nComment+nCode) as comment_ratio from t
                         where language="C" and nCode > 300 and
                         comment_ratio < 1 order by comment_ratio;' | sqlite_formatter

Project    File                                                                                            nCode nComment comment_ratio
__________ _______________________________________________________________________________________________ _____ ________ __________________
mariadb    server-10.1/storage/mroonga/vendor/groonga/lib/nfkc.c                                           80221       14 0.0174487443135789
python     Python-2.7.10/Python/graminit.c                                                                  2175        1 0.0459558823529412
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_turkish.c                            2095        1 0.0477099236641221
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_french.c                             1211        1 0.0825082508250825
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_french.c                        1201        1 0.0831946755407654
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_hungarian.c                          1182        1 0.084530853761623
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_hungarian.c                     1178        1 0.0848176420695505
mariadb    server-10.1/strings/ctype-eucjpms.c                                                             67466       60 0.0888546633889169
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_english.c                            1072        1 0.0931966449207828
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_english.c                       1064        1 0.0938967136150235
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_spanish.c                            1053        1 0.094876660341556
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_spanish.c                       1049        1 0.0952380952380952
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_italian.c                            1031        1 0.0968992248062016
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_italian.c                       1023        1 0.09765625
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_portuguese.c                          981        1 0.10183299389002
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_portuguese.c                     975        1 0.102459016393443
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_romanian.c                            967        1 0.103305785123967
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_2_romanian.c                       961        1 0.103950103950104
mariadb    server-10.1/strings/ctype-ujis.c                                                                67177       79 0.117461639110265
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_finnish.c                             720        1 0.13869625520111
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_porter.c                              717        1 0.139275766016713
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_finnish.c                        714        1 0.13986013986014
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_porter.c                         711        1 0.140449438202247
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_KOI8_R_russian.c                            660        1 0.151285930408472
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_russian.c                             654        1 0.152671755725191
python     Python-2.7.10/Mac/Modules/qt/_Qtmodule.c                                                        26705       42 0.157026956294164
python     Python-2.7.10/Mac/Modules/icn/_Icnmodule.c                                                       1521        3 0.196850393700787
mariadb    server-10.1/strings/ctype-extra.c                                                                8282       18 0.216867469879518
postgresql postgresql-9.4.4/src/bin/psql/sql_help.c                                                         3576        8 0.223214285714286
mariadb    server-10.1/strings/ctype-sjis.c                                                                34006       86 0.252258594391646
python     Python-2.7.10/Python/Python-ast.c                                                                6554       17 0.258712524729874
mariadb    server-10.1/strings/ctype-cp932.c                                                               34609       92 0.265122042592432
perl       perl-5.22.0/keywords.c                                                                           2815        8 0.283386468296139
python     Python-2.7.10/Mac/Modules/menu/_Menumodule.c                                                     3263       10 0.305530094714329
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_dutch.c                               596        2 0.334448160535117
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_dutch.c                          586        2 0.340136054421769
mariadb    server-10.1/strings/ctype-gbk.c                                                                 10684       38 0.354411490393583
python     Python-2.7.10/Mac/Modules/qd/_Qdmodule.c                                                         6694       24 0.357249181303959
python     Python-2.7.10/Mac/Modules/win/_Winmodule.c                                                       3056       11 0.358656667753505
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_german.c                              476        2 0.418410041841004
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_german.c                         470        2 0.423728813559322
mariadb    server-10.1/strings/ctype-euc_kr.c                                                               9956       44 0.44
postgresql postgresql-9.4.4/src/backend/utils/fmgrtab.c                                                     4815       23 0.475403059115337
python     Python-2.7.10/Mac/Modules/ctl/_Ctlmodule.c                                                       5442       28 0.511882998171846
python     Python-2.7.10/Mac/Modules/ae/_AEmodule.c                                                         1347        7 0.51698670605613
python     Python-2.7.10/Mac/Modules/app/_Appmodule.c                                                       1712        9 0.52295177222545
mariadb    server-10.1/strings/ctype-gb2312.c                                                               6377       35 0.54585152838428
mariadb    server-10.1/storage/tokudb/ft-index/third_party/xz-4.999.9beta/src/liblzma/lzma/fastpos_table.c   516        3 0.578034682080925
python     Python-2.7.10/Mac/Modules/evt/_Evtmodule.c                                                        504        3 0.591715976331361
python     Python-2.7.10/Modules/expat/xmlrole.c                                                            1256        8 0.632911392405063
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_UTF_8_danish.c                              312        2 0.636942675159236
postgresql postgresql-9.4.4/src/backend/snowball/libstemmer/stem_ISO_8859_1_danish.c                         310        2 0.641025641025641
python     Python-2.7.10/Mac/Modules/res/_Resmodule.c                                                       1621       12 0.734843845682792
python     Python-2.7.10/Mac/Modules/drag/_Dragmodule.c                                                     1046        8 0.759013282732448
python     Python-2.7.10/Mac/Modules/list/_Listmodule.c                                                     1021        8 0.777453838678329
python     Python-2.7.10/Mac/Modules/te/_TEmodule.c                                                         1198       10 0.827814569536424
python     Python-2.7.10/Mac/Modules/cg/_CGmodule.c                                                         1190       10 0.833333333333333
python     Python-2.7.10/Modules/clmodule.c                                                                 2379       23 0.957535387177352
python     Python-2.7.10/Mac/Modules/folder/_Foldermodule.c                                                  306        3 0.970873786407767

Quais são os dez arquivos mais longos (com base em linhas de código) que não têm comentários? Excluir cabeçalho, .html e arquivos YAML.

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

Project File                                                                 nCode
_______ ____________________________________________________________________ _____
perl    perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/ja.pl                 1938
python  Python-2.7.10/PCbuild/pythoncore.vcproj                               1889
python  Python-2.7.10/PC/VS8.0/pythoncore.vcproj                              1889
mariadb server-10.1/mysql-test/extra/binlog_tests/mysqlbinlog_row_engine.inc  1862
perl    perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/zh_strk.pl            1589
perl    perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/zh_zhu.pl             1563
mariadb server-10.1/storage/mroonga/vendor/groonga/configure.ac               1526
perl    perl-5.22.0/cpan/Unicode-Collate/Collate/Locale/zh_pin.pl             1505
mariadb server-10.1/mysql-test/suite/funcs_1/storedproc/storedproc_02.inc     1465
python  Python-2.7.10/PC/VS8.0/_bsddb.vcproj                                  1463

Quais são as línguas mais populares (em termos de linhas de código) em cada projeto?

prompt> sqlite3 code.db 'select project, language, sum(nCode) as SumCode from t
                         group by project,language
                         order by project,SumCode desc;' | sqlite_formatter
Project    Language                  SumCode
__________ _________________________ _______
mariadb    C++                        983026
mariadb    C                          715018
mariadb    C/C++ Header               209394
mariadb    Bourne Shell                61943
mariadb    Perl                        35562
mariadb    Pascal                      32541
mariadb    HTML                        16489
mariadb    Javascript                  15540
mariadb    m4                          14215
mariadb    CMake                       12206
mariadb    XML                          5210
mariadb    Ruby                         4998
mariadb    Puppet                       3848
mariadb    make                         3631
mariadb    SQL                          3405
mariadb    Python                       2545
mariadb    Bourne Again Shell           1604
mariadb    Windows Module Definition    1211
mariadb    lex                           991
mariadb    yacc                          810
mariadb    DOS Batch                     700
mariadb    Prolog                        448
mariadb    RobotFramework                441
mariadb    CSS                           393
mariadb    JSON                          359
mariadb    dtrace                        306
mariadb    Windows Resource File         250
mariadb    Assembly                      237
mariadb    WiX source                    155
mariadb    Visual Basic                   88
mariadb    YAML                           65
mariadb    PHP                            24
mariadb    SKILL                          16
mariadb    sed                            16
mariadb    Windows Message File            6
mariadb    D                               4
mariadb    diff                            4
perl       Perl                       536445
perl       C                          155648
perl       C/C++ Header               147858
perl       Bourne Shell                42668
perl       Pascal                       8592
perl       XML                          2410
perl       YAML                         2078
perl       C++                          2033
perl       make                         1986
perl       Prolog                       1146
perl       JSON                         1037
perl       yacc                          998
perl       Windows Message File          489
perl       DOS Batch                     389
perl       Windows Resource File          85
perl       D                               8
perl       Lisp                            4
postgresql HTML                       785991
postgresql C                          736519
postgresql C/C++ Header                57014
postgresql SQL                         51926
postgresql yacc                        28491
postgresql Bourne Shell                17170
postgresql Perl                         9456
postgresql lex                          4285
postgresql make                         4114
postgresql m4                           1642
postgresql Windows Module Definition    1152
postgresql XSLT                          294
postgresql DOS Batch                      92
postgresql Assembly                       69
postgresql CSS                            69
postgresql D                              66
postgresql Windows Resource File          62
postgresql Lisp                           16
postgresql sed                            15
postgresql Python                         13
postgresql Bourne Again Shell             10
postgresql Windows Message File            5
python     Python                     434015
python     C                          375555
python     C/C++ Header                66942
python     Bourne Shell                45091
python     MSBuild script              38910
python     m4                          15559
python     Assembly                    12298
python     make                         2953
python     HTML                         2344
python     Windows Module Definition    2081
python     Objective C                   635
python     Expect                        565
python     DOS Batch                     506
python     CSS                           328
python     Javascript                    229
python     Windows Resource File         207
python     C++                           128
python     vim script                    106
python     diff                          105
python     XML                            74
python     NAnt script                    30
python     Prolog                         24
python     Visual Basic                   12
sqlite     C                          101454
sqlite     C/C++ Header                 1546

Fatores de escala de linguagem de terceira geração ▲

As versões de cloc antes de 1.50 por computação padrão, para as entradas fornecidas, uma estimativa aproximada de quantas linhas de código seriam necessárias para escrever o mesmo código em uma hipotética linguagem computacional de terceira geração. Para produzir esta saída, é preciso usar o switch --3.

Os fatores de escala foram derivados da versão de 2006 dos índices de engrenagem da linguagem listados no site da Mayes Consulting, http://softwareestimator.com/IndustryData2.htm, usando esta equação:

fator de escala de cloc para linguagem X = razão de engrenagem padrão de terceira geração / relação de engrenagem X do idioma

Por exemplo, cloc fator de escala de 3ª geração para DOS Batch = 80/128 = 0.625.

A maior falha com esta abordagem é que as relações de engrenagem são definidas para linhas lógicas de código-fonte e não linhas físicas (que conta cloc). Os valores na "escala" e na "terceira geração" do cloc. equiv. as colunas devem ser colhidas com um grande grão de sal.

Limitações ▲

Identificar comentários dentro do código-fonte é mais complicado do que se poderia esperar. Muitas línguas precisariam de um analisador completo para ser contado corretamente. cloc não tenta analisar qualquer uma das línguas que pretende contar e, portanto, é uma ferramenta imperfeita. Os seguintes são problemas conhecidos:

1. As linhas que contêm código fonte e comentários são contadas como linhas de código.
2. Marcadores de comentários dentro de strings ou here-documents são tratados como marcadores de comentários reais e não literais de string. Por exemplo, as seguintes linhas de código C

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

   look to cloc like this:

   printf(" xxxxxxx
   xxxxxxx
   xxxxxxx
   xxxxxxx
   xxxxxxx     ");
   

   onde `xxxxxxx` representa a visão de cloc do texto comentado. Portanto, cloc conta as cinco linhas como duas linhas de código C e três linhas de comentários (as linhas com código e comentários são contadas como código).

Como solicitar suporte para idiomas adicionais ▲

Se o cloc não reconhecer um idioma que esteja interessado em contar, crie um GitHub issue solicitando suporte para o seu idioma. Inclua esta informação:

1. Extensões de arquivo associadas ao idioma. Se o idioma não depender de extensões de arquivo e, em vez disso, funciona com nomes de arquivos fixos ou com invocações de programa de estilo `#!`, Explique o que são.
2. Uma descrição de como os comentários são definidos.
3. Links para código de exemplo.

Recursos atualmente em desenvolvimento ▲

Aqui, em nenhuma ordem específica e sem promessa de entrega futura, os recursos e as capacidades estão atualmente em desenvolvimento:

1. produce reStructuredText output with `--rst`
2. código de contagem (por exemplo, Javascript) incorporado em arquivos HTML

Os pedidos de envio para esses recursos receberão consideração extra.

Reconhecimentos ▲

Wolfram Rösler forneceu a maioria dos exemplos de código no conjunto de testes. Estes exemplos vêm da sua Coleção Hello World.

Ismet Kursunoglu encontrou erros com o contador MUMPS e forneceu acesso a um computador com um grande código de MUMPS para testar o cloc.

Tod Huggins deu sugestões úteis para os filtros do Visual Basic.

Anton Demichev encontrou uma falha no contador JSP no cloc v0.76 e escreveu o gerador de saída XML para a opção --xml.

Reuben Thomas apontou que o ISO C99 permite // como um marcador de comentário, forneceu o código para o --no3 e --stdin-name opções, contando o idioma m4, e sugeriu vários aprimoramentos da interface do usuário.

Michael Bello forneceu um código para o --opt-match-f, --opt-not-match-f, --opt-match-d, e as opções --opt-not-match-d.

Mahboob Hussain inspirou o --original-dir e as opções --skip-uniqueness, encontrou um erro na lógica de detecção de arquivos duplicados e melhorou o filtro JSP.

Randy Sharo encontrou e corrigiu um erro de variável não inicializado para scripts de shell com apenas uma linha.

Steven Baker encontrou e corrigiu um problema com o gerador de saída YAML.

Greg Toth forneceu código para melhorar a detecção de linha em branco no COBOL.

Joel Oliveira forneceu código para deixar --exclude-list-file lidar com exclusão de nome de diretório.

Blazej Kroll forneceu código para produzir um arquivo XSLT, cloc-diff.xsl, ao produzir saída XML para a opção --diff.

Denis Silakov aprimorou o código que gera cloc.xsl ao usar --by-file e --by-file-by-lang opções, e forneceu um arquivo XSL que funciona com a saida --diff.

Andy (awalshe@sf.net) código fornecido para corrigir vários erros: saída correta de --counted de modo que apenas aparecem arquivos que são usados na contagem de códigos e que os resultados são mostrados pelo idioma em vez do nome do arquivo; permitir --diff saída de várias corridas para serem somadas --sum-reports.

Jari Aalto criou a versão inicial de cloc.1.pod e mantém o pacote Debian para cloc.

Mikkel Christiansen (mikkels@gmail.com) forneceu definições de contador para Clojure e ClojureScript.

Erik Gooven Arellano Casillas provided an update to the MXML counter to recognize Actionscript comments.

Gianluca Casati criou um pacote CPAM CPOC.

Ryan Lindeman implementou a característica --by-percent.

Kent C. Dodds, @kentcdodds, criou e mantém o pacote npm de cloc.

O desenvolvimento do cloc foi parcialmente financiado pela Northrop Grumman Corporation.

Direito Autoral ▲

Copyright (c) 2006-2017, Al Danial