Provided by: sloccount_2.26-5.2_amd64 bug


       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


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

       --follow    Follow symbolic links.

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

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

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

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


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


       David A. Wheeler (