Cloc – Contele de linii de cod

Original: http://cloc.sourceforge.net/

cloc este acum in curs de dezvoltare la https://github.com/AlDanial/cloc

Comunicate de Legacy (1,64 și mai devreme) pot fi găsite aici.


Prezentare generală
Descarca (ultima versiune: 1.64, lansat 2015-06-27)
NPM, apt-get, yum, Pacman, PKG, port
Versiune stabilă
Versiunea de dezvoltare
SourceForge Proiectului Pagina
Licenţă
De ce să folosiți cloc?
Alte Contoare
Utilizarea de bază
Construirea un Windows executabil
Opțiuni
Recunoscute Limbi
Cum functioneaza
Utilizarea avansată
Scoateți Observațiile Source Code
Lucrul cu comprimate Arhive
Diferențele
Creați Definiții Limba personalizate
Combina Rapoarte
SQL
A treia generație Factori Scale Limba
Limitări
Cum pentru a solicita asistență pentru limbi suplimentare
Autor
Mulțumiri
Drepturi de autor
Licenţă

Privire de ansamblu ^

cloc numără liniile goale, linii de comentarii, și linii fizice de cod sursă în mai multe limbaje de programare. Având în vedere două versiuni ale unui cod de bază, cloc poate calcula diferențele de linii goale, comentariu, și sursa. Este scris în întregime în Perl fără dependențe în afara distribuției standard a Perl v5.6 și mai mare (codul din unele module externe este încorporat în cloc), și așa este destul de portabil. cloc este cunoscut pentru a rula pe mai multe arome de Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, z / OS și Windows. (Pentru a rula versiunea sursă Perl a cloc pe Windows are nevoie de ActiveState Perl 5.6.1 sau mai mare, căpșuni Perl, Cygwin, sau MobaXTerm cu Perl plug-in-instalat. Alternativ se poate folosi binar Windows a cloc generate cu PAR :: Packer pentru a rula pe computerele Windows care nu au nici Perl nici Cygwin.)

cloc conține cod de David Wheeler lui SLOCCount, Damian Conway și Abigail lui Perl modul regexp :: comună, Perl modul Sean M. Burke Win32 :: Autoglob, și Tye McQueen Perl modul Algoritmul :: Dif. Factorii de scalare Limba au fost derivate din Mayes Consulting, site-ul web LLC http://softwareestimator.com/IndustryData2.htm.

Instalați prin managerul de pachete ^

În funcție de sistemul de operare, una dintre aceste metode de instalare pot lucra pentru tine:

 

  npm install -g cloc                    # https://www.npmjs.com/package/cloc
  sudo apt-get install cloc              # Debian, Ubuntu
  sudo yum install cloc                  # Red Hat, Fedora
  sudo pacman -S cloc                    # Arch
  sudo pkg install cloc                  # FreeBSD
  sudo port install cloc                 # Mac OS X with MacPorts

 

Descarcă versiune stabilă ^

Codul sursă, notele de lansare, Windows executabilul, și pachetul de Unix pentru versiunea stabilă curentă pot fi găsite la http://sourceforge.net/projects/cloc/files/cloc/v1.64/.

Descărca versiunea de dezvoltare ^

Codul sursă pentru cele mai recente Subversion Comiterea pot fi găsite la http://sourceforge.net/p/cloc/code/HEAD/tree/trunk/cloc.

Licență ^

cloc este licențiat sub GNU General Public License, v2, cu excepția porțiuni care sunt copiate din alte surse. Codul copiat din regexp :: comună, Win32 :: Autoglob, și algoritmul de :: modulele Diff Perl este supusă licența Artistic.

De ce să folosiți cloc? ^

cloc are multe caracteristici care fac usor de folosit, aprofundată, extensibila, si portabile:

  1.     Există ca un singur fișier, autonom, care necesită un efort minim de instalare — doar să descărcați fișierul și rulați-l.
  2.     Poate citi definiții comentariu limbă dintr-un fișier și, prin urmare, potențial lucreze cu limbaje de calculator care nu există încă.
  3.     Permite rezultatele de la mai multe serii a fi însumate împreună de limbă și de proiect.
  4.     Poate produce rezultate într-o varietate de formate: text simplu, SQL, XML, YAML, virgulă valori separate.
  5.     Poate conta cod în arhive comprimat (bile gudron, fișiere Zip, fișiere Java .ear).
  6.     Are numeroase opțiuni de depanare.
  7.     Manere de fișiere și director nume cu spații și alte caractere neobișnuite.
  8.     Nu are dependențe în afara distribuției standard de Perl.
  9.     Ruleaza pe Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, și a sistemelor de z / OS, care au Perl 5.6 sau mai mare. Versiunea sursă rulează pe Windows, fie cu ActiveState Perl, Strawberry Perl, Cygwin, sau MobaXTerm + Perl plugin. Alternativ pe Windows se poate executa binar pentru Windows care nu are dependențe.


Alte Contoare ^

Dacă cloc nu se potrivi nevoilor dvs. aici sunt alte contoare primare să ia în considerare:


Alte referințe:


Regexp :: comună, Digest :: MD5, Win32 :: Autoglob, algoritmul :: Diff

Deși cloc nu are nevoie de module Perl afara cele gasite in distributia standard, cloc se bazează pe câteva module externe. Codul din trei dintre aceste module externe – regexp :: comună, Win32 :: Autoglob, iar algoritmul :: Dif – este încorporat în cloc. Un al patrulea modul, Digest :: MD5, este utilizat numai în cazul în care este disponibil. Dacă cloc găsește regexp :: comună sau Algoritmul :: Dif instalat local se va folosi pe cei de instalare. În cazul în care nu, cloc va instala părți ale regexp :: comună și / sau algoritm: Dif de care are nevoie pentru a directoarele temporare care sunt create la începutul o centrare cloc apoi eliminate atunci când pe termen este completă. Codul necesar de regexp :: v2.120 comună și algoritmul :: Dif v1.1902 sunt inglobate în codul sursă cloc (a se vedea subrutine Install_Regexp_Common () și Install_Algorithm_Diff ()). Doar trei linii sunt necesare de la Win32 :: Autoglob și acestea sunt incluse direct în cloc.

În plus, cloc va folosi Digest :: MD5 pentru a valida unicitatea printre fișiere de intrare în cazul în care Digest :: MD5 este instalat local. Dacă Digest :: MD5 nu este găsit fișierul verificarea unicitate este sărit.

Binar Windows este construit pe un computer care are atât regexp :: comună și Digest :: MD5 instalat local.

Construirea un Windows executabil ^

Implicit Windows Descarca, cloc-1.64.exe, a fost construit cu PAR :: Packer pe un computer cu Windows 7 cu capsuni Perl. Executabile Windows a cloc versiunile 1.60 si mai devreme au fost construite cu perl2exe pe un 32 de biți Windows XP calculator. O modificare mică a fost făcută la codul sursă cloc înainte de a trece la o perl2exe; Liniile 87 și 88 au fost decomentat:

 

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


De ce este executabil pentru Windows atât de mare?

Executabile Windows a cloc versiunile 1.60 și anterioare, create cu perl2exe ca sa menționat mai sus, sunt aproximativ 1,6 MB, în timp ce versiunile mai noi, create cu PAR :: Packer, 11 MB. De ce sunt atât de noi executabile mult mai mare? Teoria mea este că perl2exe foloseste inteligent copac logică tăiere decât PAR :: Packer, dar asta e pură speculație.

Creați-vă propriul executabil

Dacă aveți acces la perl2exe, îl puteți folosi pentru a crea un Windows executabil strâns. Vezi linii 84-87 din codul sursă cloc de modificare cod minor care este necesar atunci când se utilizează perl2exe.

În caz contrar, pentru a construi un executabil Windows, cu pp de la PAR :: Packer, în primul rând a instala o distribuție Perl bazate pe Windows (de exemplu, Strawberry Perl sau ActivePerl) conform instrucțiunilor lor. Apoi, deschideți un prompt de comandă, alias o fereastră DOS și instalați modulul PAR :: Packer. În cele din urmă, invoca comanda PP nou instalat cu codul sos cloc pentru a crea un fișier .exe:

 

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

 

O variație pe cele de mai sus este dacă ați instalat versiunea portabilă a căpșuni Perl, va trebui să rulați portableshell.bat primul pentru a stabili corect mediul dumneavoastră. Strawberry Perl derivat executabil pe zona de descărcare SourceForge a fost creat cu versiunea portabil pe un computer cu Windows 7.

De bază de utilizare ^

cloc este un program de linie de comandă care are fișier, director, și / sau nume de arhivă ca intrări. Iată un exemplu de funcționare cloc împotriva distribuția Perl sursa v5.10.0:

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

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

 

Pentru a rula cloc pe computerele Windows, trebuie să deschideți mai întâi o comandă (aka DOS) fereastră și invoca cloc.exe din linia de comandă acolo.

Opțiuni ^

 

prompt> cloc

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

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

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

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

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

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

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

 

Limbi recunoscute ^

 

prompt> cloc --show-lang

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

 

Lista de mai sus poate fi personalizat prin citirea definiții lingvistice dintr-un fișier cu --read-lang-def or --force-lang-def.

Opt extensii de fișiere au mai multe mapări de limbă:

  •     Fișierele .cl ar putea fi Lisp sau OpenCL
  •     Fișierele .inc ar putea fi PHP sau Pascal
  •     Fișierele .jl ar putea fi Lisp sau Julia
  •     Fișierele .M ar putea fi MATLAB, Mercur, urlian sau Objective C
  •     Fișierele .p ar putea fi D sau DTrace
  •     fișiere .pl ar putea fi Perl sau Prolog
  •     Fișierele .PP ar putea fi Pascal sau de Papusi
  •     Fișierele .pro ar putea fi IDL, Prolog, sau un proiect Qt


cloc are subrutine care încearcă să identifice limba corectă pe baza conținutului fișierului pentru aceste cazuri speciale. Precizia de identificare Limba este o funcție de cât de mult cod fișierul conține; fișiere .M cu doar una sau două linii de exemplu, au rareori suficiente informații pentru a distinge corect între MATLAB, Mercur, urlian sau Obiectiv C.

Limbile cu coliziuni extensie de fișier sunt dificil de a personaliza cu –read-lang-def sau –force-lang-def ca nu au mecanism de identificare limbi cu extensii comune. În această situație trebuie să modifice codul sursă cloc.

Cum funcționează ^

Metoda cloc lui de funcționare seamănă lui SLOCCount: În primul rând, a crea o listă de fișiere de luat în considerare. Apoi, încercați pentru a determina dacă este sau nu fișiere găsite conțin cod sursă limbaj de calculator recunoscut. În cele din urmă, pentru fișierele identificate ca fișiere sursă, invoca rutine specifice limbii pentru a contoriza numărul de linii sursă.

O descriere mai detaliată:

  1.     Dacă fișierul de intrare este o arhivă (cum ar fi un .tar.gz sau .zip), a crea un director temporar și să se extindă arhiva acolo folosind un apel sistem pentru un utilitar de bază corespunzător (gudron, bzip2, unzip, etc.) apoi se adaugă acest director temporar ca unul dintre intrările. (Aceasta funcționează mai fiabil pe Unix decât pe Windows.)
  2.     Utilizați fișier :: Cauta să coboare recursiv directoarele de intrare și să facă o listă de nume de fișiere candidat. Ignoră fișiere binare și zero mijlocii.
  3.     Asigurați-vă că fișierele din lista de candidate au un conținut unic (în primul rând prin compararea fișiere de dimensiuni, atunci, pentru fișierele în mod similar de dimensiuni, compara hash-uri MD5 a conținutului fișierului cu Digest :: MD5). Pentru fiecare set de fișiere identice, elimina toate dar primul exemplar, așa cum este determinat de un fel lexicală, de fișiere identice din setul. Fișierele eliminate nu sunt incluse în raport. (Comutatorul –skip-unicitatea dezactivează testele unicitatea și forțează toate copiile de fișiere pentru a fi incluse în raport.) A se vedea, de asemenea, = –ignored trece pentru a vedea ce fișiere au fost ignorate și de ce.
  4.     Scanare lista de fișiere candidat pentru extensii de fișiere care asociați cloc cu limbaje de programare (vezi —show-Lang și –show-EXT opțiuni). Fișierele care se potrivesc sunt clasificate ca conțin codul sursă pentru acea limbă. Fiecare fișier fără un extensii este deschisă și prima linie a citi pentru a vedea dacă acesta este un script de shell Unix (ceva care începe cu #!). Dacă este script de shell, fișierul este clasificat de care limbaj de scripting (dacă limba este recunoscută). Dacă fișierul nu are o extensie recunoscută sau nu este un limbaj de scripting recognzied, fișierul este ignorat.
  5.     Toate fișierele rămase în lista substanțelor candidate ar trebui să fie acum fișierele sursă pentru limbaje de programare cunoscute. Pentru fiecare dintre aceste fișiere:
    1.         Citiți întregul dosar în memorie.
    2.         Conta numărul de linii (= Loriginal).
    3.         Elimina liniile goale, apoi conta din nou (= Lnon_blank).
    4.         Bucla peste filtrele comentariu definite pentru această limbă. (De exemplu, C ++ are două filtre: (1) elimina liniile care incep cu un spațiu opțional urmată de // și (2) șterge Text între / * și * /) Aplica fiecare filtru la codul pentru a elimina comentariile. Numărați rămase liniile (= Lcode).
    5.         Salvați contează pentru această limbă:
      linii goale = Loriginal – Lnon_blank
      linii de comentarii Lnon_blank – Lcode
      linii de cod = Lcode


Opțiunile modifica algoritmul ușor. Opțiunea –read-lang-def, de exemplu permite utilizatorului să citească definițiile filtre comentariu, extensii de fișiere cunoscute, și limbaje de scripting cunoscute dintr-un fișier. Codul pentru această opțiune este procesat între pașii 2 și 3.

Utilizarea avansate ^

Scoateți Comentariile Source Code ^

Cum pot să vă spun dacă cloc identifică corect comentariu? O modalitate de a va convinge cloc este de a face ceea ce trebuie este de a utiliza opțiunea –strip-un comentariu pentru a elimina comentarii și linii goale din fișiere, apoi comparați fișierele dezbrăcat-jos pentru a originalelor.
Să încercăm asta cu fuziunea SQLite, un dosar care conține toate cod C necesare pentru a construi biblioteca SQLite, împreună cu un fișier antet:

 

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

 

Argumentul extindere acordată –strip-comentarii este arbitrară; aici nc a fost folosit ca o abreviere pentru “comentarii”.

cloc eliminate peste 31.000 de linii de fișier:

 

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

 

Putem compara acum fișierul orignial, sqlite3.c și cel dezbrăcat de comentarii, sqlite3.c.nc cu instrumente, cum ar fi dif sau vimdiff și a vedea ceea ce exact cloc considerat comentarii și linii goale. O dovadă riguroasă că fișierul dezbrăcat-jos conține același cod C ca și originalul este de a compila aceste fișiere și să compare sumele de control ale fișierelor obiect rezultate.

În primul rând, fișierul original sursa:

 

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


Apoi, versiunea fără comentarii:

 

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

cloc eliminat peste 31.000 de linii de comentarii și semifabricate, dar nu a modificat codul sursă în mod semnificativ de la fișierul obiect rezultat se potrivește cu originalul.

Lucrul cu comprimate Arhiva ^

Versiunile de cloc înainte v1.07 necesară o = <cmd> opțiune cu –extract a spune cloc cum să-și extindă un fișier arhivă. Începând cu v1.07 acest lucru este de extracție se încearcă în mod automat. În momentul în care metoda de extracție automată funcționează destul de bine pe Unix de tip OS lui pentru următoarele tipuri de fișiere: .tar.gz, .tar.bz2, .tgz, .zip, .ear. Unele dintre aceste extensii de lucru pe Windows, dacă a instalat WinZip în locația implicită (C: \ Program Files \ WinZip \ WinZip32.exe). În plus, cu versiunile mai noi ale WinZip, linia de comandă add-on este necesar pentru funcționarea corectă; În acest caz, s-ar invoca cloc cu ceva de genul
--extract-with="\"c:\Program Files\WinZip\wzunzip\" -e -o >FILE< ." (ref. forum post).

În situațiile în care extracția automată nu reușește, se poate încerca opțiunea –extract cu = <cmd> pentru a număra de linii de cod în fișiere de gudron, fișiere Zip sau alte arhive comprimate pentru care o are un instrument de extracție. cloc ia comanda de extracție prevăzut de utilizator și extinde arhiva într-un director temporar (creat cu File :: Temp), numără liniile de cod în directorul temporar, atunci indeparteaza acel director. Deși nu deosebit de util atunci când se ocupă cu un singur comprimat arhivă (la urma urmei, dacă ai de gând să tastați comanda de extracție oricum de ce nu doar extinde manual arhiva?) Această opțiune este la îndemână pentru a lucra cu mai multe arhive simultan.

De exemplu, presupunem că aveți următoarele Fișierele tar cu surse de pe o mașină de Unix
perl-5.8.5.tar.gz
Python-2.4.2.tar.gz

si doriti sa numeri tot codul în cadrul acestora. Comanda va fi

 

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

 

Dacă asta mașină Unix are GNU gudron (care poate decomprima și extrage într-o etapă) comanda poate fi redus la

 

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

 

Pe un computer cu Windows cu WinZip instalat în C: \ Program Files \ WinZip comanda ar arăta

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

 

Fișierele Java .ear sunt fișiere Zip care conțin fișiere Zip suplimentare. cloc poate mâner imbricate arhive comprimat fără dificultate – cu condiția ca toate aceste fișiere sunt comprimate și arhivate în același mod. Exemple de numărare un fișier .ear Java în Unix si 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

 

Diferențele ^

Comutatorul –diff permite să măsoare schimbarea relativă în codul sursă și comentariile între două versiuni ale unui fișier, director, sau arhiva. Diferențele dezvăluie mult mai mult decât numărul de cod ale absolute două versiuni de fișiere. De exemplu, spune un fișier sursă are 100 de linii si dezvoltator de oferă o versiune mai nouă, cu 102 linii. Ți-a se adaugă două linii de comentarii, sau șterge șaptesprezece linii sursă și adăugați paisprezece linii sursă și cinci linii comentariu, sau a făcut o rescriere completă, aruncând toate liniile 100 originale și adăugarea 102 de linii de toate nouă sursă? Opțiunea dif spune cum s-au adăugat mai multe linii de sursă, eliminat, modificat sau a rămas la fel, și modul în care s-au adăugat mai multe linii de comentarii, eliminat, modificat sau a rămas la fel.

În plus față de perechi de fișiere, se poate da de perechi cloc de directoare, sau perechi de arhive de fișiere, sau o arhivă fișier și un director. cloc va încerca să se alinieze perechi de fișiere în directoarele sau arhivele și comparați diff pentru fiecare pereche. De exemplu, pentru a vedea ce sa schimbat între GCC 4.4.0 și 4.5.0 se poate face

 

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

 

Fiți pregătit să aștepte un timp pentru rezultatele, deși; opțiunea –diff ruleaza mult mai lent decât un număr absolut de cod.

Pentru a vedea cum cloc aliniază fișiere între cele două arhive, utilizați opțiunea –diff-aliniere

 

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

 

pentru a produce align.txt dosar care arată perechi de fișiere, precum și fișierele adăugate și șterse. Simbolurile == și! = Înainte de fiecare pereche de fișiere indică dacă fișierele sunt identice (==) sau dacă au un conținut diferit (! =).

Iată de ieșire probă care arată diferența dintre Python 2.6.6 și 2.7 versiuni:

 

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

 

Notă cele două erori pentru fișierul Python-X / Mac / module / qd / qdsupport.py. Acest fișier are docstrings Python (text între perechi de ghilimele triple), care conțin comentarii C. tratează cloc docstrings fi comentarii și să le ocupă mai întâi le convertirea la comentariile C, apoi folosind comentariul C eliminarea expresie regulată. Comentariile imbricate C da rezultate eronate cu toate acestea.

Există, de asemenea ieșire pentru limba “(necunoscut)”. Fișierele din această categorie sunt fișiere non-source și, prin urmare, nu numărate; prezența lor este numai la faptul ca a fost suprimată, adăugate, sau modificate.

Creați Definiții Limba personalizate ^

cloc pot scrie definițiile sale comentariu limbă într-un fișier sau poate citi definiții comentariu dintr-un fișier, imperative definițiile built-in. Acest lucru poate fi util atunci când doriți să utilizați cloc a conta linii de-o limbă care nu sunt încă incluse, pentru a schimba asocierea de extensii de fișiere de limbi, sau pentru a modifica modul în care limbile existente sunt numărate.

Cel mai simplu mod de a crea un fișier personalizat definiție limba este de a face cloc scrie definițiile sale într-un fișier, apoi modificați acest fișier:

 

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

 

creează my_definitions.txt fișier care poate fi modificat apoi redate cu nici opțiunea –read-lang-def sau –force-lang-def. Diferența dintre opțiuni este fostul definiții fuziuni lingvistice din fișierul dat cu definițiile interne cloc despre cloc’taking prioritate în cazul în care există suprapuneri. Opțiunea –force-lang-def, pe de altă parte, inlocuieste definiții cloc complet. Această opțiune are un dezavantaj in prevenirea cloc de numărare limbi ale căror extensii hartă a mai multe limbi ca urmatoarele limbi necesită logică suplimentară care nu este exprimat cu ușurință într-un fișier definiții.

 

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

 

Fiecare intrare limbă are patru părți:

  1.     Numele limbii începând în coloana 1.
  2.     Unul sau mai multe filtre comentariu începând în coloana 5.
  3.     Unul sau mai multe extensii de fișiere începând în coloana 5.
  4.     Un factor de scara generație treia începând din coloana 5. trebuie să fie prevăzute Această intrare, dar valoarea sa nu este important dacă doriți să comparați limba la un treia generație limbaj de programare ipotetic.


Un filtru definește o metodă pentru a elimina comentariu textul din fișierul sursă. De exemplu, intrarea pentru C ++ arata ca acest lucru

 

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

 

C ++ are două filtre: în primul rând, elimina liniile care încep cu un spațiu opțional și sunt urmate de //. Apoi, scoateți toate comentariile C. Comentariile C sunt greu de exprimat expresii ca regulate, astfel se face un apel la regexp :: comună pentru a obține expresia regulată corespunzătoare pentru a se potrivi C comentarii, care sunt apoi eliminate.

O discuție mai completă a diferitelor opțiuni de filtrare pot apărea aici, în viitor. Ieșirea opțiune –write-lang-def cloc ar trebui să ofere destule exemple de persoane motivate de a modifica sau de a extinde definiții lingvistice cloc lui.

Combina Rapoarte ^

Dacă gestionați mai multe proiecte software te-ar interesa să vadă numărul de linii de proiect, nu doar în funcție de limbă. Spuneți că ați gestiona trei proiecte software numit MySQL, PostgreSQL, SQLite și. Echipele responsabile pentru fiecare din aceste proiecte rula cloc pe codul sursă și a vă oferi cu ieșire. De exemplu, echipa de MySQL nu

 

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

 

și vă oferă cu fișierul mysql-5.1.42.txt. Conținutul celor trei fișierelor pe care le obține sunt

 

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

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

 

În timp ce aceste trei fișiere sunt interesante, de asemenea, vă doriți să vedeți contează combinate din toate proiectele. Care se poate face cu opțiunea –sum_reports cloc lui:

 

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

 

Combinația raport produce două fișierele de ieșire, una pentru sume de limbajul de programare (databases.lang) și unul de proiect (databases.file). Conținutul lor sunt

 

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

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

 

Raport fișiere se poate fi rezumat împreună. Spuneți că ați gestionați de asemenea, dezvoltarea de Perl si Python si doriti sa țină evidența acestor linii numără separat de proiectele dvs. de baze de date. În primul rând a crea rapoarte pentru Perl și Python separat:

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

 

apoi suma acestea, împreună cu

 

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

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

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


În cele din urmă, se combină fișierele combinație:

 

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

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

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

 

SQL ^

Cloc pot scrie rezultate sub forma de tabel SQL crea și introduce declarații pentru a fi utilizate cu programe de baze de date relaționale, cum ar fi SQLite, MySQL, PostgreSQL, Oracle, Microsoft SQL sau. După informațiile numărul de cod este o bază de date, informațiile pot fi interogat și afișate în moduri interesante.

O bază de date creată de ieșire SQL cloc are două mese, metadate și t:

metadata

Field Type
  timestamp   text
  project   text
  elapsed_s   real

t

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


Tabelul metadate conține informații despre care a fost făcută pe termen cloc. Comutatorul –sql-append permite să combine mai multe ruleaza într-o singură bază de date; fiecare rulare adaugă un rând la masa de metadate. Informațiile număr de cod se află în tabelul t.

Să repetăm ​​exemplele count cod de Perl, Python, SQLite, MySQL și PostgreSQL Arhivele tar prezentate în exemplul de mai sus, combine rapoarte de data aceasta folosind opțiunile de ieșire SQL și motorului bazei de date SQLite.

Comutatorul –sql spune cloc pentru a genera ieșire în formă de tabel SQL crea și introduceți comenzi. Comutatorul are un argument de un nume de fișier pentru a scrie aceste declarații SQL în, sau, în cazul în care argumentul este de 1 (numeric o), fluxuri de ieșire la stdout. Având în vedere că SQLite programul linia de comandă, SQLite3, poate citi comenzi de la stdin, putem renunța la stocarea instrucțiuni SQL într-un fișier și de a folosi –sql 1 la datele de conducte direct în executabil SQLite:

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

 

Partea MySQL –sql-proiect este opțională; nu este nevoie să specificați un nume de proiect atunci când se lucrează cu un singur cod de bază. Cu toate acestea, din moment ce vom fi adăugarea de numărul de cod de alte patru tar, vom fi în măsură să identifice datele de sursa de intrare, dacă vom furniza un nume de proiect pentru fiecare probă numai.

Acum, că avem o bază de date va trebui să treacă în comutatorul –sql-append pentru a spune cloc nu a șterge această bază de date, dar în loc adăuga mai multe date:

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

 

Acum începe distracția – avem o bază de date, code.db, cu o mulțime de informații despre cele cinci proiecte și pot începe interogarea-o pentru tot felul de lucruri interesante.

Care este cel mai lung fișierul peste toate proiectele?

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

sqlite|sqlite-3.6.22/sqlite3.c|110860

 

formatul de ieșire implicit SQLite3 lasă un pic de dorit. Putem adăuga o opțiune pentru a fișier rc programului, ~ / .sqliterc, pentru a arăta antete de coloane:
.header pe
S-ar putea fi tentat să includă, de asemenea,
coloană .mode
în ~ / .sqliterc dar aceasta cauzează probleme la ieșirea are mai mult de un rând de la lățimile intrări în primul rând guverna lățimea maximă pentru toate rândurile următoare. Adesea, acest lucru duce la ieșire trunchiată – deloc de dorit. O opțiune este de a scrie o ieșire de formatare SQLite personalizate, cum ar fi sqlite_formatter. Acesta este utilizat astfel:

 

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

Project File                    nL     
_______ _______________________ ______ 
sqlite  sqlite-3.6.22/sqlite3.c 110860


Rețineți, de asemenea că SQLite3 are o opțiune de ieșire HTML, –html, care s-ar putea dovedi, de asemenea, utile.

Care este cel mai lung fișierul în fiecare proiect?

 

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

Project    File                                          nL     
__________ _____________________________________________ ______ 
perl       perl-5.10.0/t/op/mkdir.t                       22658 
python     Python-2.6.4/Lib/email/quoprimime.py           28091 
postgresql postgresql-8.4.2/contrib/pgcrypto/pgp-pgsql.c  40041 
mysql      mysql-5.1.42/netware/mysqldump.def             51841 
sqlite     sqlite-3.6.22/config.sub                      110860 

 

Ce fișiere în fiecare proiect au cele mai multe linii de cod?

 

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

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

Ce sursă C fișiere cu mai mult de 300 de linii au un raport de comentariu sub 1%?

 

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

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

 

Care sunt cele zece mai lungi de fișiere (în funcție de linii de cod), care au nici un comentariu, la toate? Exclude antet și fișierele YAML.

 

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

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

 

Care sunt cele mai populare limbi (în ceea ce privește linii de cod), în fiecare proiect?

 

> sqlite3 code.db 'select project, language, sum(nCode) as SumCode from t group by project,language order by project,SumCode desc;' | sqlite_formatter

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

 

A treia generație Factorii Scale Limba ^

Versiunile cloc înainte 1.50 implicit calculat, pentru intrările prevăzute, o estimare a modului în care ar fi nevoie de multe linii de cod pentru a scrie același cod într-o a treia generație limbaj de calculator ipotetic. Pentru a produce aceasta iesire trebuie să folosească acum comutatorul –3.

Factorii de scalare au fost derivate din versiunea din 2006 a raporturi de angrenare lingvistice enumerate la site-ul web Mayes Consulting, http://softwareestimator.com/IndustryData2.htm, folosind această ecuație:

factorului de scală cloc pentru limba X = treia generație implicit pregătește raportul / limba X pregătește raportul

de exemplu,

cloc 3-a generație factorului de scală pentru DOS Batch = 80/128 = 0,625

Cea mai mare defect cu această abordare este că Gradul de îndatorare sunt definite pentru linii logice de cod sursă nu linii fizice (care numără cloc). Valorile din “scara” cloc și “treilea gen. echiv. ” coloane ar trebui să fie luate cu un bob mare de sare.

Limitări ^

Identificarea comentarii la codul sursa este mai complicată decât s-ar aștepta. Mai multe limbi ar avea nevoie de un parser complet să fie numărate corect. cloc nu încearcă să analiza oricare dintre limbile ea își propune să conta și, prin urmare este un instrument imperfect. Următoarele sunt probleme cunoscute:

  1.     Linii care conțin atât codul sursă și comentariile sunt considerate ca linii de cod.
  2.     Comentariu markeri în siruri de caractere sau aici, documentele sunt tratate ca markeri comentariu reale și nu literale șir. De exemplu, următoarele linii de cod C

 

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

 

par să cloc ca două linii de cod C (liniile cu text negru) și trei linii de comentarii (liniile din care au numai text roșu – linii cu text atât negru și roșu sunt tratate ca cod).

3.    Comentariile lungi Lua nu sunt recunoscute.

Cum pentru a solicita asistență pentru limbi suplimentare ^

Dacă cloc nu recunoaște o limbă sunteți interesat de numărare, posta următoarele informații într-o cerere caracteristică la pagina SourceForge cloc lui:

  1.     Extensii de fișiere asociate cu limba. În cazul în care limba nu se bazează pe extensii de fișiere și, în loc funcționează cu nume de fișiere fix sau cu #! invocații programului stil, explica ce sunt cele.
  2.     O descriere a modului în care sunt definite comentarii.
  3.     Link-uri pentru a gusta cod.


Autor ^

Al Danial

Mulțumiri ^

Wolfram Rösler condiția de cele mai multe exemple de cod în suita de teste. Aceste exemple provin din Hello sa colectie Mondial.

Ismet Kursunoglu constatat erori cu tejghea oreionului și asigurat acces la un calculator cu un corp mare de cod MUMPS pentru a testa cloc.

Tod Huggins a dat sugestii utile pentru filtrele Visual Basic.

Anton Demichev găsit un defect cu contor JSP în v0.76 cloc și a scris generatorul ouput XML pentru opțiunea –xml.

Ruben Thomas a subliniat că ISO C99 permite // ca un comentariu marker, cu condiția cod pentru opțiunile –no3 și –stdin nume, numărând limba m4, și a sugerat o serie de îmbunătățiri de interfață de utilizator.

Michael Bello prevăzut codul pentru –opt-meci-F, opțiuni –opt-nu-meci-f, –opt-meci-d, și –opt-nu-meci-d.

Mahboob Hussain inspirat –original-dir și –skip-unicitate opțiuni, a găsit un bug în logica de detecție fișier duplicat și îmbunătățit filtrul JSP.

Randy Sharo găsit și fixe un bug variabilă neinitializata pentru scripturi shell cu o singură linie.

Steven Baker găsit și a stabilit o problemă cu generatorul de ieșire YAML.

Greg Toth furnizate de cod pentru a imbunatati detectarea linie goală în COBOL.

Joel Oliveira furnizat cod pentru a permite –exclude-list-file numele directorului mâner excludere.

Blazej Kroll furnizat cod pentru a produce un fișier XSLT, cloc-diff.xsl, la producerea de ieșire XML pentru opțiunea –diff.

Denis Silakov îmbunătățit codul care generează cloc.xsl atunci când se utilizează –by-fișier și –by-file-de-Lang opțiuni, și a oferit un fișier XSL care funcționează cu ieșire –diff.

Andy ([email protected]) prevăzut de cod pentru a rezolva bug-uri mai multe: de ieșire corectă a –counted astfel încât numai fișierele care sunt utilizate în numărul de cod apar și care sunt afișate rezultatele de limbă, mai degrabă decât de nume de fișier; permite –diff de ieșire de la mai multe serii a fi însumate împreună cu –sum-rapoarte.

Jari Aalto a creat versiunea inițială a cloc.1.pod și menține pachetul Debian pentru cloc.

Mikkel Christiansen ([email protected]) prevăzut definiții contra pentru Clojure și ClojureScript.

Dezvoltarea cloc a fost partial finantat de catre Northrop Grumman Corporation.

Drepturi de autor ^

Copyright (c) 2006 – 2015,.

Licență ^

Acest program este software liber; îl puteți redistribui și / sau modifica în conformitate cu termenii GNU General Public License publicată de Free Software Foundation; fie versiunea 2 a Licenței, sau (la opțiunea dumneavoastră) orice versiune ulterioară.


Get cloc at SourceForge.net. Fast, secure and Free Open Source software downloads

Comments are closed.