Érdekes

CLOC (Gróf Sornyi Kódot)

Az eredeti http://cloc.sourceforge.net/

Áttekintés

cloc számít üres sorok, hozzászólás vonalak, fizikai vonalak a forráskód számos programozási nyelven. Adott két változata kód alap, cloc kiszámíthatjuk különbségek üres, hozzászólás, forrás vonalak. Meg van írva, teljesen Perl nem függőségek kívül a szokásos megoszlása Perl v5.6., illetve magasabb (kód: néhány külső modul van ágyazva cloc) , szóval elég hordozható. cloc ismert, hogy fut a sok ízek Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, z/OS, a Windows. (Futni a Perl forrás változata cloc Windows kell ActiveState Perl 5.6.1 vagy magasabb, Strawberry Perl, Cygwin, vagy MobaXTerm a Perl plugin telepítése. Alternatív megoldásként lehet használni a Windows bináris a cloc generált a PAR::Csomagoló, hogy fut a Windows számítógépek esetén sem Perl sem Cygwin.)

cloc olyan kódot tartalmaz, a David Wheeler SLOCCount, Damian Conway, Abigail Perl-module Regexp::Common, Sean M. Burke Perl-module Win32::Autoglob, Tye McQueen Perl-module Algoritmus::Diff. A nyelvi skála tényezők származnak Mayes Tanácsadás, LLC weboldal http://softwareestimator.com/IndustryData2.htm.

Telepítse keresztül csomagkezelő

Attól függően, hogy az operációs rendszer, az egyik a telepítési módszerek is működik:

  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

Letöltés stabil kiadás

A forráskód, kiadási megjegyzések, a Windows futtatható, Unix csomag a jelenlegi stabil verzió megtalálható a http://sourceforge.net/projects/cloc/files/cloc/v1.64/.

Letöltés fejlesztési változat

A forráskód a legújabb Cvs commit megtalálható a http://sourceforge.net/p/cloc/code/HEAD/tree/trunk/cloc.

Licenc

cloc licence GNU General Public License v2 , kivéve részek, amelyek másolt más forrásokból. Kód másolt a Regexp::Common, Win32::Autoglob, Algoritmus::Diff Perl modulok feltétele, hogy a Artistic licenc.

Miért Használja cloc? 

cloc számos jellemzője, hogy könnyen használható, alapos, bővíthető, hordozható:

  1. Létezik egy egységes, önálló fájl szükséges minimális telepítés erőfeszítésn – csak töltse le a fájlt, majd futtassa.
  2. Olvassa nyelv hozzászólás meghatározások a fájlt, ezáltal potenciálisan dolgozni a számítógép-nyelvek, amelyek még nem léteznek.
  3. Lehetővé teszi az eredmények több fut, hogy foglalta össze a nyelv, valamint a projekt.
  4. Képes eredményeket a különböző formátumok: egyszerű szöveg, SQL, XML, YAML, vesszővel elválasztott értékek.
  5. Számolni kód belül tömörített archívumok (tar golyó, Zip fájlokat, Java .fül-fájlok).
  6. Számos hibaelhárítási lehetőségeket.
  7. Kezeli a fájl, illetve könyvtár neve terek, valamint egyéb szokatlan karakterek.
  8. Nem függőségek kívül a szokásos Perl engedély.
  9. Fut a Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, z/OS rendszerek Perl 5.6, vagy magasabb. A forrás verzió fut a Windows vagy ActiveState Perl, Strawberry Perl, Cygwin, vagy MobaXTerm+Perl plugin. Alternatív megoldásként a Windows nem lehet futtatni a Windows bináris, amelyek nincsenek függőségek.

Más Számlálók

Ha cloc nem felel meg ön igényeinek, itt más szabadon elérhető számlálók, hogy fontolja meg:

  • Sonar
  • Ohcount
  • SLOCCount
  • sclc
  • USC – CODECOUNT
  • loc

Egyéb referenciák:

  • QSM – könyvtár kód számolja eszközök.
  • Wikipedia bejegyzést forráskód vonal számít.

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

Bár cloc nem kell Perl modulok kívül azok is megtalálható a normál eloszlás, cloc nem támaszkodnak néhány külső modul. Kód a három külső modulok–Regexp::Common, Win32::Autoglob, a Algorithm::Diff – van ágyazva cloc. A negyedik modul, s Digest::MD5, csak akkor használja, ha elérhető. Ha cloc talál Regexp::Common vagy Algoritmus::Diff telepített helyi fogja használni azokat a telepítés. Ha nem, cloc telepíti a részei Regexp::Common és/vagy Algoritmus:Diff kell ideiglenes könyvtárak létrehozott elején egy cloc fut majd eltávolították, amikor a futam teljes. A szükséges kódot a Regexp::Common v2.120, illetve Algoritmus::Diff v1.1902-ben a beágyazott belül a cloc forrás kódot (lásd a szubrutinok Install_Regexp_Common() es Install_Algorithm_Diff() ). Csak három vonal van szükség a Win32::Autoglob ezek szerepelnek közvetlenül cloc.

Továbbá, cloc fogja használni, s Digest::MD5 érvényesíteni egyediségét között bemeneti fájlokat, ha Digest::MD5 helyi telepítése. Ha Digest::MD5 nem található a fájl egyediség ellenőrzése kimarad.

A Windows bináris épül egy számítógép, amely mind Regexp::Common es Digest::MD5 telepített helyben.

Az Epület Egy Windows Futtatható

Az alapértelmezett Windows letöltés, cloc-1.64.exe épült a PAR::Packer egy Windows 7-es számítógépet, Strawberry Perl. Windows futtatható a cloc verziók 1.60, korábban épültek perl2exe egy 32 bites Windows XP rendszerű számítógépen. Egy kis módosítás történt, hogy a cloc forráskód előtt halad, hogy perl2exe; vonalak, 87, 88 voltak megjegyzésként:

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;

Miért van az, hogy a Windows futtatható olyan nagy?

A Windows futtatható a cloc verziók 1.60 korábban létrehozott perl2exe mint fentebb, 1.6 MB, míg az újabb verziókban létrehozott PAR::Packer, 11 MB. Miért van az újabb programot, sokkal nagyobb? Az én elméletem az, hogy perl2exe használ okosabb fa metszés logika, mint PAR::Packer, de ez csak spekuláció.

Saját futtatható

Ha rendelkezik perl2exe, hogy lehet használni, hogy hozzon létre egy szűk Windows futtatható. Lásd vonalak 84-87 a cloc forráskód egy kisebb kód módosítás, amely szükséges, ha a perl2exe.

Egyébként, hogy építsenek egy Windows futtatható a pp a PAR::Packer, először telepíteni egy Windows-alapú Perl engedély (például Strawberry Perll vagy ActivePerl) követve az utasításokat. Ezután nyissa meg egy parancssort, azaz egy DOS ablak, majd telepítse a PAR::Packer modul. Végül, hivatkozhat az újonnan telepített pp parancsot a cloc souce kódot hoz létre .exe fájlt:

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

Egy variáció a fenti, ha telepítve van a hordozható változat Strawberry Perl, lesz szükség-hoz fuss portableshell.bat első, hogy megfelelően van-e beállítva a környezet. Az Strawberry Perl származtatott futtatható a SourceForge letöltés területen jött létre a hordozható változat a Windows 7 számítógépet.

Alapvető Használat

cloc egy parancssori programot, amely kerül fájlt, könyvtárat és/vagy archív nevek, mint a bemenet. Itt egy példa futó cloc ellen a Perl v5.10.0 forrás elrendezése:

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

Futni cloc Windows számítógépek, meg kell nyitni egy parancs (aka DOS) ablakot, majd hivatkozhat cloc.exe a parancssorból.

Lehetőségek

  
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.

Felismert Nyelvek

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)

A fenti lista testre szabható, az olvasás nyelv, fogalmak a fájlt a –read-lang-def vagy a –force-lang-def lehetőségeket.

Nyolc fájlokat több nyelv leképezések:

  • .cl fájlokat lehet Lisp vagy OpenCL
  • .inc fájlokat lehet PHP, vagy Pascal
  • .jl fájlokat lehet Lisp vagy Julia
  • .m fájlokat lehet MATLAB, a Higany, a MUMPSZ vagy a Objective C
  • .o fájlokat lehet a D vagy a dtrace
  • .pl fájlokat lehet Perl vagy Prolog
  • .pp fájlokat lehet Pascal vagy Puppet
  • .pro fájlokat lehet IDL, Prolog, vagy egy Qt Project

cloc van a szubrutinok, hogy megpróbálja azonosítani a megfelelő nyelvi alapján a fájl tartalma miatt ezek a speciális esetben. Nyelv azonosító pontosságának függvénye, hogy mennyi kódot a fájl tartalmaz; .m fájlok csak egy vagy két sorban például ritkán van elég információt ahhoz, hogy helyesen megkülönböztetni MATLAB, Mercury, MUMPS vagy Objective C.

Nyelvek a fájl kiterjesztését ütközések nehéz testre –read-lang-def vagy a –force-lang-def mivel nincs mechanizmus azonosítása nyelvek közös fájlokat. Ebben a helyzetben kell módosítani a cloc forráskód.

Hogyan Működik

cloc módszer művelet hasonlít SLOCCount: Először hozzon létre egy listát a fájlokat, hogy fontolja meg. A jövő, megpróbálja-e vagy nem talált fájlok tartalmazzák elismert számítógépes nyelv forráskód. Végül, a fájlok azonosított forrás fájlokat, hivatkozhat nyelv-specifikus rutinok, hogy számolja meg a forrás vonalak.

Részletes leírás:

  1. Ha a bemeneti fájl egy archív ( .tar.gz vagy .zip fájl), hozzon létre egy ideiglenes könyvtárba, majd bontsa ki az archívum ott a rendszer hívni, hogy megfelelő alapul szolgáló segédprogram (tar, bzip2, unzip, stb.), majd adjuk hozzá ezt az ideiglenes könyvtárban, mint a bemenet. (Ez működik megbízhatóan Unix, mint a Windows.)
  2. Használja a File::Keresse meg, hogy rekurzívan leereszkedni a bemeneti könyvtárak, valamint egy listán a jelölt fájl nevét. Figyelmen kívül hagyja a bináris nulla méretű fájlokat.
  3. Ellenőrizze, hogy a fájlokat a jelöltlistára egyedi tartalom (első összehasonlításával fájl méret, akkor a hasonló méretű fájlok, hasonlítsa össze az MD5 hash-eket a fájl tartalmát Digest::MD5). Minden sor azonos fájlokat, távolítsa el az összes, de az első példányt által meghatározott egy lexikális sort, az azonos fájlokat a forgatásról. Az eltávolított fájlok nem szerepel a jelentésben. (A –skip-egyediség kapcsoló hatására az egyediség vizsgálatok, valamint erők másolatok fájlokat tartalmazza a jelentés.) Lásd még a  –ignored= hogy melyik fájlokat volt figyelmen kívül hagyni, hogy miért.
  4. Vizsgálat a jelölt fájl lista a fájlokat, amelyek cloc társult, programozási nyelvek (lásd a — show-lang es –show-ext opciók). Fájlok, amelyek megfelelnek a minősülnek tartalmazó forráskód nyelvet. Minden fájlt anélkül, hogy egy fájlokat nyit meg, az első sort olvasta, hogy ha ez egy Unix shell script (bármi, ami azzal kezdődik #!). Ha shell szkript, a fájl titkosított által parancsnyelv (ha a nyelvet ismeri fel). Ha a fájl nem rendelkezik elismert kiterjesztés, vagy nem recognzied parancsnyelv, a fájl figyelmen kívül hagyni.
  5. Egész hátralévő fájl, a jelölt, lista, most forrásfájlok ismert programozási nyelvek. Az egyes ezeket a fájlokat:
    1. Olvassa el a teljes fájlt a memóriából.
    2. Gróf a sorok száma (= Loriginal).
    3. Távolítsa el az üres sorok, akkor újra számolni (= Lnon_blank).
    4. Hurkot a hozzászólás szűrők meghatározott ezt a nyelvet. (Például C++ két szűrőkkel: (1) távolítsa el a sorok, amelyek bármivel opcionális üres követi // vagy (2) távolítsa el a szöveg között /* es */) kell Alkalmazni minden szűrő a kódot, hogy távolítsa el a megjegyzéseket. Gróf a megmaradt vonal (= Lcode).
    5. Mentse az számít ezen a nyelven:
      üres sorok =Loriginal – Lnon_blank
      hozzászólás sorok = Lnon_blank – Lcode
      kód sorok = Lcode

A beállítások módosítása az algoritmus enyhén. Lehetőség –read-lang-def például lehetővé teszi a felhasználó számára, hogy olvassa el meghatározások hozzászólás szűrők, ismert fájlkiterjesztések, ismert scripting nyelvek fájlból. A kód, ez a lehetőség feldolgozott között Lépéseket 2 es 3.

Speciális

Távolítsa el a Megjegyzéseket a forráskód

Hogyan állapítható meg, ha cloc helyesen azonosítja a hozzászólások? Az egyik módja, hogy meggyőzze magát, cloc ez a helyes dolog, hogy használja a –strip-comments lehetőség, hogy távolítsa el észrevételeit, üres sorok a fájlokat, majd hasonlítsa össze az lecsupaszított fájlok eredeti.

Próbáljuk ki az SQLite összeolvadást, egy C fájl, amely tartalmazza az összes szükséges kódot kell építeni az SQLite könyvtár mellett egy fejléc fájlt:

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

A megtestesülése érvet adott –strip-comments az önkényes; itt nc használták, mint egy rövidítés a “nem nyilatkozik”.

cloc eltávolított több mint 31,000 vonalak a fájlt:

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

Most hasonlítsd össze a orignial fájlt, sqlite3.c es megfosztva észrevételek, sqlite3.c.nc olyan eszközökkel, mint a diff vagy vimdiff, aztán meglátjuk, mi pontosan cloc vett észrevételeket, valamint üres sorok. Egy alapos bizonyíték arra, hogy a lecsupaszított fájl tartalmazza ugyanazt a C kód, mint az eredeti, hogy össze ezeket a fájlokat, majd hasonlítsa össze ellenőrzőösszegeket a kapott objektum fájlokat.

Az első, az eredeti forrás fájl:

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

Következő a verzió megjegyzések nélkül:

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

cloc eltávolított több mint 31,000 sorok megjegyzések, üres, de nem módosíthatja a forráskód lényeges módon, mivel az így kapott objektum fájl megegyezik az eredeti.

A munka Tömörített Archívumok

Változatai cloc v1 előtt.07 szükséges –extract-with=<cmd> lehetőséget, hogy elmondja cloc, hogy bontsa ki egy archív fájl. Kezdve v1.07 ez a kivonás kísérlet automatikusan. Abban a pillanatban az automatikus extrakciós módszer viszonylag jól működik, hogy a Unix típusú OS rendszer, a következő fájl típusok: .tar.gz, .tar.bz2, .tgz, .zip .ear. Néhány ezek a kiterjesztések nem működik a Windows, ha egy WinZip telepítve van az alapértelmezett helyen található (C:\Program Files\WinZip\WinZip32.exe). Továbbá, az újabb verziók WinZip, a parancssorban kiegészítő szükséges a helyes működés; ebben az esetben egy hivatkozhat cloc, mint
–extract-with=”\”c:\Program Files\WinZip\wzunzip\” -e -o >FILE< .” (ref. fórum post).

Olyan helyzetekben, ahol az automatikus kitermelés sikertelen, próbáld meg a –extract-with=<cmd> lehetőséget, hogy gróf sornyi kódot belül tar fájlokat, Zip-fájlokat, vagy más tömörített archívumok, amely vonatkozásában az extrakciós eszköz. cloc kerül a felhasználó által megadott kitermelés parancsot, majd kitágul az archívum egy ideiglenes könyvtárba (a létrehozott Fájl::Temp), számít a sor kódot az ideiglenes könyvtárba, majd eltávolítja, hogy a könyvtár. Bár nem különösen hasznos, ha foglalkozik a tömörített archívum (végül is, ha beírod a kitermelés parancs egyébként miért nem kézzel bontsa ki az archívum?) ez az opció hasznos, dolgozó több archives egyszerre.

Tegyük fel például, hogy az alábbi forrás tarballs egy Unix gép

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

te akarod számolni az összes kód belül. A parancs lenne

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

Ha Unix gép GNU tar (amely tömörítse, majd bontsa ki egy lépésben) a parancs lehet rövidíteni, hogy

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

Windows a WinZip telepített c:\Program Files\WinZip a parancs, hogy nézne ki

cloc.exe --extract-with="\"c:\Program Files\WinZip\WinZip32.exe\" -e -o >FILE< ." perl-5.8.5.tar.gz Python-2.4.2.tar.gz

Java .ear fájl Zip-fájlokat is tartalmaznak további Zip fájlokat. cloc kezelni beágyazott tömörített archívumok nehézség nélkül–feltéve, hogy az ilyen fájlok tömörített, valamint archivált azonos módon. Példák a számolás egy Java .ear fájl Unix, Windows:

Unix> cloc --extract-with="unzip -d . >FILE< " Project.ear

DOS> cloc.exe --extract-with="\"c:\Program Files\WinZip\WinZip32.exe\" -e -o >FILE< ." Project.ear

Különbségek

A –diff kapcsoló lehetővé teszi, hogy megmérjék a relatív változás a forrás kódot, majd megjegyzések között két változata egy fájl, könyvtár, vagy az archívumban. A különbségeket mutatják sokkal több, mint abszolút kód számít a két fájl verzió. Tegyük fel például, hogy egy forrás fájl 100 vonalak, valamint a fejlesztő biztosít egy újabb változat 102 vonalak. Betett két hozzászólás vonalak, vagy törölni tizenhét forrás vonalak, majd add hozzá a tizennégy forrás vonalak öt hozzászólás vonalak, vagy csinált egy teljes újraírása, a halak mind a 100 eredeti vonalak, hozzátéve, 102 vonalak minden új forrás? A különbség az opció megmondja, hogy hány sorban a forrás hozzáadása, eltávolítása, módosítása vagy nem változott, hány sornyi megjegyzések hozzáadása, eltávolítása, módosítása vagy a régi maradt.

Amellett, hogy a fájl pár, lehet adni cloc pár könyvtárak, vagy pár fájl archívum, vagy egy fájl archívum, könyvtár. cloc megpróbálja összehangolni fájl pár belül a könyvtárak vagy levéltárba, majd hasonlítsa össze diffi, hogy minden párt. Például, hogy lássuk, mi változott GCC 4.4.0 es 4.5.0 képes

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

Készen kell várni egy kicsit, hogy az eredmények ellenére; a –diff opció fut, sokkal lassabban, mint az abszolút kód szám.

Látni, hogy cloc igazítja a fájlok között a két levéltár, használja a –diff-igazítás beállítás

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

előállításához a fájl align.txt ami azt mutatja, hogy a fájl páros, valamint fájlokat hozzáadni, majd el kell hagyni. A szimbólumok,== es != mielőtt minden fájl pár jelzik, ha a fájlok azonosak (==), vagy ha különböző tartalmak (!=).

Itt van a minta kimenet mutatja a különbség a között, hogy a Python 2.6.6 es 2.7 kiadások:

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

Megjegyzés: a két hiba a fájl Python-X/Mac/Modules/qd/qdsupport.py. Ez a fájl a Python docstrings (szöveg közötti pár tripla idézetek) tartalmaz C megjegyzések. cloc kezeli docstrings hozzászólás kezeli őket az első átkonvertálni C megjegyzéseket, akkor használja a C hozzászólás eltávolítása reguláris kifejezés. Beágyazott C hozzászólások hozam hibás eredmények azonban.

Ott is kimenetet a nyelv “(ismeretlen)”. Fájlok ebben a kategóriában nem-forrás fájlokat, ezért nem számít; a jelenléte, csupán megjegyezte, mivel megszüntették, hozzáadott vagy módosított.

Hozzon Létre Egyéni Nyelvi Fogalmak 

cloc lehet írni a nyelv hozzászólás meghatározások, hogy egy fájl vagy olvasni hozzászólás meghatározások a fájlban, felülbírálva a beépített meghatározások. Ez akkor lehet hasznos, ha azt szeretné, hogy cloc számolni vonalak egy nyelvet, még nem szerepelnek, változtatni egyesület fájl kiterjesztések nyelven, vagy módosítani, ahogy a meglévő nyelvek számítanak.

A legegyszerűbb módja annak, hogy hozzon létre egy egyéni nyelvi meghatározás fájlt, hogy cloc írja a meghatározások egy fájlt, akkor módosítsa ezt a fájlt:

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

létrehozza a fájlt my_definitions.txt ami lehet módosítani, akkor olvasd vissza a a vagy a –read-lang-def vagy a –force-lang-def lehetőség. A különbség a között, hogy a lehetőségek korábbi egyesíti nyelv, fogalmak a megadott fájlt a cloc belső meghatározások a cloc’taking elsőbbséget, ha vannak átfedések. A –force-lang-def lehetőség, másrészt, helyettesíti cloc meghatározások teljesen. Ez az opció van egy hátránya, hogy megakadályozzák a cloc a számolás nyelvek, akinek a fájlokat térkép, hogy több nyelven is, mivel ezek a nyelvek igényel további logika, amely nem könnyen kifejezni, meghatározások fájlt.

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

Minden nyelv bejegyzés négy részből áll:

  1. A nyelv neve kezdve oszlop az 1.
  2. Egy vagy több hozzászólás szűrők kezdve oszlop 5.
  3. Egy vagy több kiterjesztésű kezdve oszlop 5.
  4. Generációs 3 léptéktényező kezdve oszlop 5. Ezt a bejegyzést akkor kell megadni, de az érték nem az a fontos, hacsak nem akarod, hogy hasonlítsa össze a nyelv, hogy egy feltételezett harmadik generációs programozási nyelv.

A szűrő meghatározza, egy módszer, hogy távolítsa el hozzászólás szöveget a forrás fájlt. Például a bejegyzést C++ úgy tűnik, ez

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++ nak két szűrő: először távolítsa el a sorok, amelyek bármivel opcionális üres, követi //. Ezután távolítsa el az összes a C megjegyzést. C hozzászólások nehéz kifejezni, mint a reguláris kifejezések tehát egy hívás, hogy Regexp::Gyakori, hogy a megfelelő reguláris kifejezés, hogy megfeleljen a C megjegyzések, amelyeket aztán eltávolították.

Egy teljesebb kifejtése, különböző szűrési lehetőségek is itt jelennek meg a jövőben. A kimenet cloc –write-lang-def lehetőséget kell biztosítania ahhoz, példák motivált egyének módosítására vagy kiterjesztésére cloc nyelvi fogalmak.

Össze Jelentések

Ha sikerül több szoftver projektek, lehet, hogy érdekelné vonal számít a projekt, nem csak a nyelv által. Mondd, hogy sikerül három szoftver projektek úgynevezett MySQL, PostgreSQL, SQLite. A csapat felelős minden ilyen projektek futnak cloc a forrás kódot, majd az ön számára a kimenet. Például a MySQL csapata

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

biztosítja, hogy a fájl mysql-5.1.42.txt. A tartalmát a három fájlt kapsz

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

Amíg ez a három fájlok érdekes azt is látni, hogy a kombinált számít a projektek. Hogy lehet tenni cloc -sum_reports lehetőség:

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

A jelentés kombináció termel két kimeneti fájlokat, egy-egy összegeket által programozási nyelv (databases.lang), valamint egy projekt (databases.file). A tartalom

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

Jelentés fájlok magukat lehet foglalta össze. Mondd, neked is sikerül fejlesztése, Perl es Python, hogy nyomon akarom követni azokat a vonal számít külön-külön az adatbázisból projektek. Az első jelentések létrehozása, a Perl es Python külön:

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

aztán összeg ezekkel együtt

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

Végül keverjük össze a kombináció fájlokat:

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 tud írni eredmények formájában SQL tábla létrehozása, majd helyezze kimutatások használja a relációs adatbázis-kezelő programok-például az SQLite, MySQL, PostgreSQL, Oracle vagy a Microsoft SQL. Ha a kód gróf adatok adatbázisban, az információ kihallgatják, megjelenik érdekes módon.

Létrehozott adatbázis a cloc SQL-kimenet két asztal, metaadata es t:

metadata

Mező Típus
  időbélyeg  szöveg
  projekt  szöveg
  elapsed_s  valódi

 

t

Mező Típus
  projekt szöveg
  nyelv szöveg
  fájl  szöveg
  nBlank  egész szám
  nComment egész szám
  nCode egész szám
  nScaled  valódi

Metaadat táblázat tartalmaz információt, amikor a cloc futni készült. A –sql-appendhozzá kapcsoló lehetővé teszi, hogy össze sok fut egy egységes adatbázis; minden egyes futtatni hozzáteszi, egy sorban, hogy a metaadat-táblázat. A kód gróf információ található táblázat t.

Ismételjük meg a kódot gróf példa, Perl, Python, SQLite, MySQL, PostgreSQL tarballs látható a össze jelentések a fenti példa is mutatja, ez az idő, az SQL kimeneti opciók lehetőséget, majd a SQLite adatbázis motor.

A –sql kapcsoló azt mondja, cloc generálni kimenet formájában SQL tábla létrehozása, majd helyezze be a parancsokat. A kapcsoló vesz egy érv a fájl nevét kell írni ezeket az SQL utasítások be, vagy ha azt az érvet 1 (numerikus) patakok kimenet STDOUT, patakok kimenet szabványos kimenetre. Mivel az SQLite parancssori programot, sqlite3, olvassa el parancsokat STDIN, meg tudjuk tekinteni tárolása SQL utasítások, hogy egy fájlt, majd –sql 1 cső adatokat közvetlenül az SQLite futtatható:

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

A –sql-project mysql része opcionális; nem kell, hogy adja meg a projekt nevét, amikor a munka csak egy kód alap. Mivel azonban mi lesz, hozzátéve kód számít a másik négy tarballs, csak legyen képes azonosítani adatok bemeneti forrást, ha a kínálat a projekt nevét minden futam.

Most, hogy van egy adatbázis, meg kell adni a –sql-append kapcsoló mondani cloc, hogy ne törölje ki ezt az adatbázist, de ehelyett a hozzáadás további adatok:

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

Most kezdődik a móka – van egy adatbázis, code.db, sok információt arról, hogy az öt projekt kezdődik, lekérdezése ez a mindenféle érdekes tényeket.

Melyik a leghosszabb fájl több, mint projektek?

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

sqlite|sqlite-3.6.22/sqlite3.c|110860

sqlite3 alapértelmezett kimeneti formátum hagy némi kívánnivalót maga után. Tehetünk hozzá egy lehetőség, hogy a program rc fájlt, az ~/.sqliterc, hogy megmutassa az oszlop fejlécek:
.header on
Lehet, hogy a kísértés, hogy azt is tartalmazza
.mode column
a ~/.sqliterc de ez okozza a problémát, ha a kimeneti már több, mint egy sor, mivel a szélessége bejegyzések az első sorban szabályozza a maximális szélesség az összes további sor. Gyakran ez vezet a csonka kimenet-egyáltalán nem desireable. Az egyik lehetőség, hogy írj egy egyéni SQLite kimeneti formatter például sqlite_formatter. Használják, például így:

>  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

Megjegyzés is, hogy az sqlite3 van egy HTML kimenet opció, –html, hogy ez is hasznos lehet.

Melyik a leghosszabb fájl minden egyes projekt?

> 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 

Amely fájlok minden egyes projekt van a legtöbb kód vonalak?

> 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 

Ami a C source files több mint 300 vonalak egy hozzászólás aránya 1% alatt?

> 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  

Mi az a tíz leghosszabb fájlok (alapuló kód vonalak), hogy nincs észrevétele? Kizárja a fejléc, YAML fájlokat.

> 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

Mi a leg népszerű nyelven (ami a sorok kód) az egyes projekt?

> 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 

Harmadik Generációs Nyelv Skála Tényezők

cloc verziók előtt 1.50 alapértelmezés szerint számított, a biztosított bemenet, egy durva becslés, hány sornyi kódot kell írni ugyanazt a kódot egy feltételezett harmadik generációs számítógép nyelv. Termelni ezt a kimenetet kell használni a –3 kapcsoló.

Skála tényezők származnak a 2006-os változat a nyelvi áttétel arány felsorolt Mayes Tanácsadó weboldal, http://softwareestimator.com/IndustryData2.htm, használja ezt az egyenletet:

cloc skála tényező a nyelv X = 3 generációs alapértelmezett áttétel arány/nyelv X áttétel arány

például,

cloc 3 generációs léptéktényező DOS Batch = 80 / 128 = 0.625

A legnagyobb hátránya ennek a megközelítésnek, hogy az áttétel arány határozza meg a logikai sorok, a forráskód nem fizikai vonalak (ami cloc számít). Az értékek cloc “skála”, “generációs egyenértékű” oszlopok kell venni, egy nagy csipet sót.

Korlátozások

Azonosító hozzászólások belül forráskód trükkösebb, mint az elvárható lenne. Sok nyelven kell egy teljes parser kell számítani megfelelően. cloc nem próbálja meg értelmezni a nyelv célja, hogy számolni, ezért tökéletlen eszköz. A következő ismert problémák:

  1. Vonalak, amely mind a forráskód, észrevételek számítanak sornyi kódot.
  2. Hozzászólás markerek belül húrok, vagy itt dokumentumokat kezelni, mint általában a hozzászólás markerek nem string közvetlen használata erősen kerülendő. Például a következő sornyi C kód
    printf(" /* ");
    for (i = 0; i < 100; i++) {
        a += i;
    }
    printf(" */ ");

    úgy tűnik, hogy cloc, mint két sornyi C kód (a vonalak fekete szöveg), valamint három sornyi hozzászólások (a vonalak, melyek csak a piros szöveg, hogy-vonalak mind fekete-piros szöveg kezelik kód).

  3. Lua hosszú megjegyzések nem kerülnek elszámolásra.

Hogyan kell kérni Támogatást További Nyelvek

Ha cloc nem ismeri fel a nyelv érdekli a számolás, a post a következő információkat egy Szolgáltatás Kérése cloc van SourceForge oldal:

  1. Fájlokat társul a nyelvet. Ha a nyelv nem támaszkodik fájlokat, ehelyett működik a rögzített fájl nevét, vagy a #! stílus program könyörgések, magyarázza el, mik ezek.
  2. Egy leírás, hogy milyen hozzászólások vannak meghatározva.
  3. A linkek minta kódot.

Szerző

Al Danial

Köszönetnyilvánítás

Wolfram Rösler feltéve, hogy a legtöbb kód példák a test suite. Ezek a példák származnak, a Helló Világ Gyűjtemény.

Ismet Kursunoglu hibákat talált a MUMPS számláló, feltéve, hogy hozzáférést a számítógéphez egy nagy test, MUMPS kód teszt cloc.

Tod Huggins adott hasznos javaslatokat a Visual Basic szűrők.

Anton Demichev találtam hibát a JSP számláló a cloc v0.76 írt az XML kimenet generátor –xml lehetőséget.

Reuben Thomas rámutatott arra, hogy az ISO C99 lehetővé teszi, // mint egy hozzászólás a jelölő, amennyiben a kód a –no3 es –stdin-name lehetőségeket, beleértve az m4 nyelvet, s azt javasolta, több user-interface fejlesztések.

Michael Bello biztosított kódot –opt-match-f, –opt-not-match-f, –opt-match-d, es –opt-not-match-d lehetőségeket.

Mahboob Hussain ihlette a –original-dir es –skip-uniqueness lehetőségek, találtam egy hibát a duplikált fájlok észlelése a logic, valamint javult a JSP szűrő.

Randy Sharo találtak, javítva egy inicializálatlan változó bogár a shell szkriptek, hogy csak egy sort.

Steven Baker találtak, javítva a probléma a YAML kimeneti generátor.

Greg Toth feltéve kód javítása üres sor érzékelési a COBOL.

Joel Oliveira, feltéve kód hagyni –exclude-list-file kezelni a könyvtár neve kizárás.

Blazej Kroll, feltéve, kód, hogy készítsen egy XSLT fájlt, cloc-diff.xsl, amikor a termelő XML kimenet a  –diff lehetőség.

Denis Silakov megerősített a kódot, amely generál cloc.xsl használata –by-file, majd –by-file-by-lang lehetőség, feltéve, egy XSL fájl, ami működik –diff kimenet.

Andy (awalshe@sf.net) biztosított kódot, a fix több hiba: a megfelelő kimeneti –counted, hogy csak használt fájlok a kód szám jelenik meg, az eredményeket a nyelv által, mint inkább a fájl neve; hagyni, hogy –diff kimeneti több fut, hogy össze –sum-reports.

Jari Aalto létre, a kezdeti változata cloc.1.pod, de fenntartja a Debian csomag cloc.

Mikkel Christiansen (mikkels@gmail.com), feltéve, hogy a counter-meghatározások a Clojure es ClojureScript.

Erik Gooven Arellano Casillas amennyiben egy frissítést az MXML számláló felismerni Actionscript megjegyzést.

Gianluca Casati létre a cloc CPAN csomag.

Ryan Lindeman hajtotta végre a –by-percent  funkciót.

Kent C. Dodds, @kentcdodds létrehozott, de fenntartja a npm csomag cloc.

A fejlesztés cloc részben finanszírozott, a Northrop Grumman Cég.

Szerzői jogok

Copyright (c) 2006-2015, 

Engedély

Ez a program szabad szoftver; terjeszthető és/vagy módosítható a feltételek a GNU General Public License által közzétett, a Free Software Foundation közölte; akár a 2-es verzió a Licenc, akár (választásod alapján) bármely későbbi verzió szerint.

Vissza a főoldalra 

Leave a Reply