Man Linux: Main Page and Category List


       sloccount - count source lines of code (SLOC)


       sloccount  [--version]  [--cached]  [--append]  [ --datadir directory ]
       [--follow] [--duplicates]  [--crossdups]  [--autogen]  [--multiproject]
       [--filecount]  [--wide] [--details] [ --effort F E ] [ --schedule F E ]
       [ --personcost cost ] [ --overhead overhead ] [ --addlang language ]  [
       --addlangall ] [--] directories


       sloccount  counts the physical source lines of code (SLOC) contained in
       descendants of the specified  set  of  directories.   It  automatically
       determines  which  files  are  source  code files, and it automatically
       determines the computer language used in  each  file.   By  default  it
       summarizes  the  SLOC  results  and presents various estimates (such as
       effort and cost to develop),  but  its  output  can  be  controlled  by
       various options.

       If  you  give  sloccount  a list of two or more directories, the counts
       will be broken up according to  that  list.   There  is  one  important
       limitation:  the  basenames of the directories given as parameters must
       be  different,  because  those  names  are  used   to   group   summary
       information.    Thus,   you   can’t   run   "sloccount   /usr/src/hello
       /usr/local/src/hello".  This limitation only applies to  parameters  of
       sloccount  - subdirectories descended from the top directories can have
       the same basename.

       If you give sloccount only  a  single  directory,  sloccount  tries  to
       automatically find a reasonable breakdown for purposes of reporting (so
       it’ll produce a useful report).  In this case, if the directory has  at
       least two subdirectories, then those subdirectories will be used as the
       breakdown.   If  the  single  directory  contains  files  as  well   as
       directories  (or if you give sloccount some files as parameters), those
       files will be assigned to the directory "top_dir" so you can tell  them
       apart  from  other  contents.  Finally, if there’s a subdirectory named
       "src", then that subdirectory  is  again  broken  down,  with  all  the
       further  subdirectories  prefixed  with "src_".  Thus, if directory "X"
       has  a  subdirectory  "src",  which  contains  subdirectory  "modules",
       sloccount will report a separate count for "src_modules".

       sloccount  normally  considers  all  descendants  of these directories,
       though unless told otherwise it ignores symbolic links.

       sloccount is  the  usual  front-end  of  the  package  of  tools  named
       "SLOCCount".   Note  that  the  name  of the entire package has capital
       letters, while the name of this front-end program does not.

       sloccount will normally report estimates of schedule time, effort,  and
       cost,  and  for single projects it also estimates the average number of
       active developers.  These are merely estimates, not  etched  in  stone;
       you can modify the parameters used to improve the estimates.


       --version   Report  the  version  number  of  SLOCCount and immediately
                   exit.  This option can’t  be  usefully  combined  with  any
                   other option.

       --cached    Do  not  recalculate;  instead,  use  cached results from a
                   previous  execution.   Without  the  --cached  or  --append
                   option,  sloccount automatically removes the data directory
                   and recreates it.

       --append    Do  not  remove  previous  calculations   from   the   data
                   directory;   instead,  add  the  analysis  to  the  current
                   contents of the data directory.

       --datadir directory
                   Store or use cached  data  in  the  given  data  directory;
                   default value is "~/.slocdata".

       --follow    Follow symbolic links.

                   Count  all  duplicates.   Normally,  if  files  have  equal
                   content (as determined using MD5 hash values), only one  is

       --crossdups Count duplicates if they occur in different portions of the
                   breakdown.   Thus,  if  the  top  directory  contains  many
                   different   projects,   and  you  want  the  duplicates  in
                   different projects to count in each  project,  choose  this

       --autogen   Count  source  code  files  that appear to be automatically
                   generated.  Normally these are excluded.

                   The different  directories  represent  different  projects;
                   otherwise, it’s assumed that all of the source code belongs
                   to a single project.  This doesn’t change the total  number
                   of  files or SLOC values, but it does affect the effort and
                   schedule estimates.  Given this option, effort is  computed
                   separately  for  each  project  (and  then summed), and the
                   schedule is the estimated schedule of the largest  project.

       --filecount Display counts of files instead of SLOC.

       --wide      Display in the "wide" (tab-separated) format.

       --details   Display  details,  that  is,  results for every source code

       --effort F E
                   Change the  factor  and  exponent  for  the  effort  model.
                   Effort (in person-months) is computed as F*(SLOC/1000)^E.

       --schedule F E
                   Change  the  factor  and  exponent  for the schedule model.
                   Schedule (in months) is computed as F*(effort)^E.

       --personcost cost
                   Change the average annual salary to cost.

       --overhead overhead
                   Change the overhead value to overhead.  Estimated  cost  is
                   computed as effort * personcost * overhead.

       --addlang language
                   Add   a   language  not  considered  by  default  to  be  a
                   ‘‘language’’ to be  reported.   Currently  the  only  legal
                   values  for  language  are  "makefile",  "sql", and "html".
                   These files are not normally included in the  SLOC  counts,
                   although their SLOCs are internally calculated and they are
                   shown in the file counts.  If you want to include more than
                   one  such  language,  do  it by passing --addlang more than
                   once, e.g., --addlang makefile --addlang sql.

                   Add all languages not normally included in final reports.


       As with many other programs using Unix-like options, directories  whose
       names  begin  with a dash (‘‘-’’) can be misinterpreted as options.  If
       the directories to be analyzed might begin with a dash, use the double-
       dash  (‘‘- -’’)  to  indicate the end of the option list before listing
       the directories.


       Filenames  with  embedded  newlines  (in  the  directories   or   their
       descendants)  won’t  be  handled correctly; they will be interpreted as
       separate filenames where the newlines are inserted.  An attacker  could
       prevent  sloccount  from  working  by  creating  filenames  of the form
       /normal/directory ... NEWLINE/dev/zero.  Such filenames are exceedingly
       rare  in  source  code  because they’re a pain to work with using other
       tools, too.  Future versions  of  sloccount  may  internally  use  NUL-
       separated filenames (like GNU find’s -print0 command) to fix this.

       There are many more languages not yet handled by SLOCCount.

       SLOCCount only reports physical source lines of code.  It would be very
       useful if it could also report logical lines of code, and perhaps other
       common  metrics  such  as  McCabe’s  complexity measures and complexity
       density (complexity/SLOC for each function or procedure).


       See the SLOCCount website at   Note
       that  more  detailed documentation is available both on the website and
       with the SLOCCount package.


       David A. Wheeler (