Ubuntu Manpage: sloccount - count source lines of code (SLOC)

NAME

       sloccount - count source lines of code (SLOC)

SYNOPSIS

       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

DESCRIPTION

       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.

OPTIONS

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

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

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

--addlangall
Add all languages not normally included in final reports.

NOTES

       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.

BUGS

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

AUTHOR

       David A. Wheeler (dwheeler@dwheeler.com).