objective-ci 0.0.1

data/externals/sloccount/get_sloc

@@ -0,0 +1,544 @@
+#!/usr/bin/perl -w
+
+# get_sloc
+# Take a list of dirs, and get the SLOC or filecount data from them.
+# NOTE: The intended input data ignores zero-length files & ignores dups,
+# so if that's true for the input data, it'll be true for the output data!
+
+# This code works but is NOT cleaned up-- it basically grew like
+# topsy.  Many of the variable names are misleading, as my needs for
+# output changed.
+
+# This is part of SLOCCount, a toolsuite that counts
+# source lines of code (SLOC).
+# Copyright (C) 2001-2004 David A. Wheeler.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# 
+# To contact David A. Wheeler, see his website at:
+#  http://www.dwheeler.com.
+
+
+
+# Default values for the effort estimation model; the model is
+# effort = ($effort_factor * KiloSLOC) ** $effort_exponent.
+# The following numbers are for basic COCOMO:
+
+$effort_factor =  2.40;
+$effort_exponent =  1.05;
+$effort_estimation_message = "Basic COCOMO model,";
+
+$schedule_factor =  2.5;
+$schedule_exponent =  0.38;
+$schedule_estimation_message = "Basic COCOMO model,";
+
+# Average Salary / year.
+# Source: ComputerWorld, Sep. 4, 2000 Salary Survey,
+# average (U.S.) programmer/analyst salary.
+
+$person_cost = 56286.;
+
+# Overhead; the person cost is multiplied by this value to determine
+# true annual costs.
+
+$overhead = 2.4;
+
+@license_list = ( "GPL", "LGPL", "MIT", "BSD", "distributable",
+                  "public domain", "MPL");
+
+%license_of = ();   # input is name of program, output is license.
+
+$no_license_total = 0;
+
+%non_language_list = (
+ "dup" => 1,
+ "not" => 1,
+ "unknown" => 1,
+ "auto" => 1,
+ "zero" => 1,
+);
+
+%ignore_language_list = (
+ "makefile" => 1,
+ "sql" => 1,
+ "html" => 1,
+);
+
+# Default input values
+$dirs_in_stdin = 0; # 0: dirs to analyze as arguments, 1: in stdin
+
+# Default Output Values:
+
+$computing_sloc = 1; # 0= showing filecounts, 1= showing SLOC.
+$narrow = 1;
+$sort_by = "total";  # If empty, sort by name; else "total" or lang name.
+$show_effort = 0;  # Show effort for each component?
+$break_line = 1; # Break up long lines into multiple lines?
+$show_non_lang = 0; # Show non-language counts?
+$one_program = 0; # Are all files part of a single program?
+$show_header = 1; # Show header?
+$show_footer = 1; # Show footer?
+
+
+# Global variables:
+
+@dirs = (); # Directories to examine
+
+%examined_directories = ();  # Keys = Names of directories examined this run.
+
+# Subroutines.
+
+sub commify {
+# TODO: Needs to be internationalized.
+  my $text = reverse $_[0];
+  $text =~ s/(\d\d\d)(?=\d)(?!\d*\.)/$1,/g;
+  return scalar reverse $text;
+}
+
+sub numformat {
+# Format number nicely with commas.
+ my $num = shift;
+ my $digits = shift;
+ return commify(sprintf("%0.${digits}f", $num));
+}
+
+sub effort_person_months {
+ # Given the SLOC, reply an estimate of the number of person-months
+ # needed to develop it traditionally.
+ my $total_sloc = shift;
+ return ( ($effort_factor*(($total_sloc/1000.0)**$effort_exponent)));
+}
+
+sub estimate_schedule {
+ # Given the person-months, reply an estimate of the number of months
+ # needed to develop it traditionally.
+ my $person_months = shift;
+ return ($schedule_factor*($person_months**$schedule_exponent));
+}
+
+sub get_lang_total {
+ my $lang = shift;
+ if (defined($lang_total{$lang}))  {return $lang_total{$lang}}
+ else {return 0;}
+}
+
+# MAIN PROGRAM
+
+
+# Process options (if any):
+
+if ($#ARGV < 0) {
+ print STDERR "Error! You must list at least one directory to process, or --stdin.\n";
+ exit(1);
+}
+
+while ((scalar (@ARGV) > 0) && ($ARGV[0] =~ m/^-/)) {
+ $arg = shift;
+ if ($arg eq "--") {last;}
+ elsif ($arg eq "--filecount") {$computing_sloc = 0;}
+ elsif ($arg eq "--filecounts") {$computing_sloc = 0;}
+ elsif ($arg eq "--sloc") {$computing_sloc = 1;}
+ elsif ($arg eq "--narrow") {$narrow = 1;}
+ elsif ($arg eq "--wide") {$narrow = 0;}
+ elsif ($arg eq "--break") {$break_line = 1;}
+ elsif ($arg eq "--nobreak") {$break_line = 0;}
+ elsif ($arg eq "--sort") {$sort_by = shift;}  # Must be "total" or a lang.
+ elsif ($arg eq "--nosort") {$sort_by = "";}
+ elsif ($arg eq "--showother") {$show_non_lang = 1;}
+ elsif ($arg eq "--noshowother") {$show_non_lang = 0;}
+ elsif ($arg eq "--oneprogram") {$one_program = 1;}
+ elsif ($arg eq "--noheader") {$show_header = 0;}
+ elsif ($arg eq "--nofooter") {$show_footer = 0;}
+ elsif ($arg eq "--addlang") { $lang = shift;
+                               if (!defined($ignore_language_list{$lang})) {
+                                  die "Sorry, but $lang isn't ignored"; };
+                               delete $ignore_language_list{$lang}; }
+ elsif ($arg eq "--addlangall") { %ignore_language_list = (); }
+ elsif ($arg eq "--effort") {$effort_factor = (shift)*1.0;
+                             $effort_exponent = (shift)*1.0;
+                             $effort_estimation_message = "effort model"}
+ elsif ($arg eq "--schedule") {$schedule_factor = (shift)*1.0;
+                             $schedule_exponent = (shift)*1.0;
+                             $schedule_estimation_message = "schedule model"}
+ elsif ($arg eq "--personcost") {$person_cost = (shift)*1.0;}
+ elsif ($arg eq "--overhead")   {$overhead = (shift)*1.0;}
+ elsif ($arg eq "--stdin")   {$dirs_in_stdin = 1;}
+ else {die "Unknown option: $arg\n";}
+}
+
+
+# Determine the languages to show:
+
+
+if ($computing_sloc) { $show_non_lang = 0; }
+
+if (!$show_non_lang) {
+ # Add the non_language_list to the ignored languages.
+ foreach $langname (keys(%non_language_list))
+   {$ignore_language_list{$langname} = 1;}
+}
+
+
+%lang_total    = ();
+%license_total = ();
+
+@data_lines = ();
+
+$sloc = 0;
+$total_sloc = 0;
+$total_lang_sloc = 0;
+$grand_total_sloc = 0;
+$grand_total_lang_sloc = 0;
+$effort = 0.0;
+$grand_total_effort = 0.0;
+$grand_schedule = 0.0;
+
+if (!$narrow) {
+ # Ouch!  To accurately determine the column positions and names,
+ # without "pre-knowing" them, we need to look through the data.
+ # So, we'll do it twice.  This isn't efficient - if needed,
+ # speed it up by rewriting this to do it in-memory.
+ while (defined($_ = <DATAFILE>)) {
+   ($lang, $sloc) = split;
+   next if ( (!defined($lang)) || (!defined($sloc)) );
+   next if ($ignore_language_list{$lang});
+   $lang_total{$lang} = 0;
+ }
+}
+
+
+# Print the header.
+if ($show_header) {
+if ($narrow) {
+ if ($computing_sloc) { print "SLOC\t"; }
+ else                 { print "#Files\t"; }
+ if ($show_effort) {print "P.Y.\t";}
+ print "Directory\t";
+ if ($computing_sloc) { print "SLOC-by-Language (Sorted)"; }
+ else                 { print "#Files-by-Language (Sorted)"; }
+ print "\n";
+} else {
+ if ($computing_sloc) { print "SLOC\t"; }
+ else                 { print "#Files\t"; }
+ if ($show_effort) {print "P.M.\t";}
+ printf "%-22s\t", "Dir";
+ foreach $lang (keys(%lang_total)) {
+  print "$lang\t";
+  $lang_total{$lang} = 0;
+ };
+ print "\n";
+}
+}
+
+if ($dirs_in_stdin == 1) {
+  while (defined($dir = <STDIN>)) {
+    chomp ($dir);
+    push (@dirs, $dir);
+  }
+}
+
+while ($dir = shift) {
+  push (@dirs, $dir);
+}
+
+
+foreach $dir (@dirs) {
+ if (! -d "$dir") {
+   # print "Skipping non-directory $dir\n";
+   next;
+ } 
+ 
+ # Skip previously-examined directories.
+ if ($examined_directories{$dir}) {
+   # print "Skipping already-examined directory $dir\n";
+   next;
+ }
+ $examined_directories{$dir} = 1;
+ 
+ if (! -r "${dir}/filelist") {
+   # print "Skipping directory $dir; it doesn't contain a file 'filelist'\n";
+   next;
+ }
+
+
+ $simplename = $dir;
+ $simplename =~ s!^.*\/!!;
+ $total_sloc = 0;
+ $total_lang_sloc = 0;
+ $preceding_entry = 0;
+
+ $line = "";
+ %lang_data = ();
+
+ if ($computing_sloc) {
+     $filename = "${dir}/all-physical.sloc";
+ } else {
+     $filename = "${dir}/all.filecount";
+ }
+ if (open(DATAFILE, "<$filename")) {
+   while (defined($_ = <DATAFILE>)) {
+     ($lang, $sloc) = split;
+     next if ( (!defined($lang)) || (!defined($sloc)) );
+     next if ($ignore_language_list{$lang});
+     if ($narrow) { if ($sloc) {$lang_data{$lang} = $sloc;}}
+     else { $line .= "${sloc}\t"; }
+     if ($lang eq $sort_by) {$interesting_lang_sloc = $sloc;}
+     $total_sloc += $sloc;
+     $total_lang_sloc += $sloc unless ($non_language_list{$lang});
+     $lang_total{$lang} += $sloc;
+   }
+   close(DATAFILE);
+ } else {
+   print STDERR "Error openinig $filename\n";
+ }
+ if ($narrow) {
+      # For narrow view, sort the language entries.
+      foreach $entry (sort {$lang_data{$b} <=> $lang_data{$a}} keys %lang_data){
+        if ($preceding_entry) {$line .= ",";}
+        $preceding_entry = 1;
+        $line .= "${entry}=${lang_data{$entry}}";
+      }
+      if (!$preceding_entry) {$line .= "(none)";}
+ }
+
+ $grand_total_sloc += $total_sloc;
+ $grand_total_lang_sloc += $total_lang_sloc;
+
+ $effort = effort_person_months($total_sloc);
+ $grand_total_effort += $effort;
+
+ $schedule = estimate_schedule($effort);
+ if ($schedule > $grand_schedule) {
+    $grand_schedule = $schedule;   # The longest leg wins.
+ }
+
+ $displayed_effort = "";
+ if ($show_effort) { $displayed_effort = sprintf "%.2f\t", $effort; }
+ if ($narrow) {
+   $displayed_name = "$simplename";
+ } else {
+   $displayed_name = sprintf "%-22s\t", $simplename;
+ }
+
+ # Add to the corresponding license, if the license is known.
+ $license = "";
+ if (open(LICENSE_FILE, "<${dir}/PROGRAM_LICENSE")) {
+   $license = <LICENSE_FILE>;
+   chomp($license);
+   close(LICENSE_FILE);
+   if ($license) {
+     $license_of{$simplename} = $license;  # Hash currently unused.
+     if (! defined($license_total{$license})) {
+       $license_total{$license} = 0;
+     }
+     $license_total{$license} = $license_total{$license} + $total_sloc;
+   }
+ } else {
+  $no_license_total += $total_sloc;
+ }
+
+ if ($narrow) {
+    $line = sprintf "%-7d %s%-15s %-s\n", $total_sloc, $displayed_effort,
+                                          $simplename, $line;
+    if ($break_line && (length($line) > 77)) { # Break up long line.
+      $line =~ s/(.{71})([^,]*),(.*)/$1$2,\n                        $3/;
+    }
+    if ($license) {
+      $line .= "                        [$license]\n";
+    }
+ } else {
+    $line = "${total_sloc}\t${displayed_effort}${displayed_name}${line}\n";
+ }
+ if ($sort_by) {
+   if ($sort_by eq "total") {$line = "$total_sloc\t$line";}
+   else {$line = "$interesting_lang_sloc\t$line";}
+   $data_lines[$#data_lines+1] = $line;   # Add to data lines.
+ } else {
+   print $line;  # No sort - print immediately for speed.
+ }
+
+}
+
+if ($sort_by) {
+ # Print sorted version.  This is a little inefficient, but for
+ # only a few hundred or thousand values it doesn't matter.
+ @sorted_data_lines = sort { ($b =~ /^(\d+)/)[0] <=> ($a =~ /^(\d+)/)[0] }
+                        @data_lines;
+ foreach $line (@sorted_data_lines) {
+    $short_line = $line;
+    $short_line =~ s/^[^\t]*\t//;  # Remove sort field.
+    print $short_line;
+ }
+}
+
+
+if (! $show_footer) {exit(0);}
+if ($grand_total_sloc == 0) {
+  print "SLOC total is zero, no further analysis performed.\n";
+  exit(1);
+}
+
+# Print the footer.
+if ($narrow) {
+ print "\n";
+ print "\n";
+ print "Totals grouped by language (dominant language first):\n";
+ # If you don't want the list sorted by size of language, just do:
+ # foreach $lang (@language_list) {
+ foreach $lang (sort {&get_lang_total($b) <=> &get_lang_total($a) } keys(%lang_total) ) {
+  $percent = get_lang_total($lang) * 100.0 / $grand_total_sloc;
+  if ($percent > 0.0) {
+    printf "%-9s %9d (%.2f%%)\n", $lang . ":", $lang_total{$lang}, $percent;
+  }
+ };
+
+ if ($show_non_lang) {
+  # The previous list showed "non-languages", so now we'll show only the
+  # data for data associated with a normal language:
+  print "\n";
+  print "\n";
+  foreach $lang (sort {&get_lang_total($b) <=> &get_lang_total($a) } keys(%lang_total)) {
+   next if (defined($non_language_list{$lang}));
+   $percent = $lang_total{$lang} * 100.0 / $grand_total_lang_sloc;
+   if ($percent > 0.0) {
+     printf "%-9s %9d (%.2f%%)\n", $lang . ":", $lang_total{$lang}, $percent;
+   }
+  };
+ }
+
+} else {  # Not narrow.
+ 
+ print "$grand_total_sloc\t";
+ if ($show_effort) {printf "%.2f\t", $grand_total_effort;}
+
+ printf "%-22s", "Totals";
+ foreach $lang (keys(%lang_total)) {
+  print "\t$lang_total{$lang}";
+ };
+ 
+ print "\t";
+ if ($show_effort) {printf "\t";}
+ printf "%-22s\t", "Percentages";
+ foreach $lang (keys(%lang_total)) {
+  $percent = $lang_total{$lang} * 100.0 / $grand_total_sloc;
+  printf "\t%0.2f", $percent;
+ };
+ print "\n";
+ 
+ print "\t";
+ if ($show_effort) {printf "\t";}
+ printf "%-22s\t", "Code Percentages";
+ foreach $lang (keys(%lang_total)) {
+   next if (defined($non_language_list{$lang}));
+   $percent = $lang_total{$lang} * 100.0 / $grand_total_lang_sloc;
+   printf "\t%0.2f", $percent;
+ };
+ print "\n";
+}
+
+print "\n";
+print "\n";
+
+
+if (%license_total) {
+ # We have license info on something, so if there's anything
+ # unallocated, add that to the list.
+ if ($no_license_total) {
+   $license_total{"Not listed"} = $no_license_total;
+ }
+ print "Licenses:\n";
+ foreach $license (sort {$license_total{$b} <=> $license_total{$a} } keys(%license_total)) {
+  $percent = $license_total{$license} * 100.0 / $grand_total_sloc;
+  if ($percent > 0.0) {
+     printf "%9d (%.2f%%) %s\n", $license_total{$license}, $percent, $license;
+   }
+ };
+ print "\n";
+ print "\n";
+
+ print "Percentage of Licenses containing selected key phrases:\n";
+ %license_phrase = ();
+ foreach $license (keys(%license_total)) {
+   foreach $phrase (@license_list) {
+     if ($license =~ m/\b$phrase\b/i) {
+       if (!defined($license_phrase{$phrase})) {$license_phrase{$phrase} = 0;}
+       $license_phrase{$phrase} = $license_phrase{$phrase} +
+                                  $license_total{$license};
+     }
+   }
+ }
+
+ foreach $phrase (sort {$license_phrase{$b} <=> $license_phrase{$a} } keys(%license_phrase)) {
+  $percent = $license_phrase{$phrase} * 100.0 / $grand_total_sloc;
+  if ($percent > 0.0) {
+     printf "%9d (%.2f%%) %s\n", $license_phrase{$phrase}, $percent, $phrase;
+   }
+ };
+
+}
+
+
+print "\n";
+print "\n";
+
+if ($computing_sloc) {
+ if ($one_program) {
+   # If it's one program, override the grand total of effort
+   # and the schedule calculations by using the total SLOC.
+
+   $grand_total_effort = effort_person_months($grand_total_sloc);
+   $grand_schedule = estimate_schedule($grand_total_effort);
+ }
+ printf "Total Physical Source Lines of Code (SLOC)                = %s\n",
+        commify($grand_total_sloc);
+
+ printf "Development Effort Estimate, Person-Years (Person-Months) = %s (%s)\n",
+       numformat($grand_total_effort/12.0, 2),
+       numformat($grand_total_effort, 2);
+ print " ($effort_estimation_message " .
+        "Person-Months = $effort_factor * (KSLOC**$effort_exponent))\n";
+
+ printf "Schedule Estimate, Years (Months)                         = %s (%s)\n",
+       numformat($grand_schedule/12.0, 2),
+       numformat($grand_schedule, 2);
+ print " ($schedule_estimation_message " .
+       "Months = $schedule_factor * (person-months**$schedule_exponent))\n";
+
+ # Don't show this if there are multiple programs, because the computation
+ # is essentially meaningless: after the "smaller" projects have completed,
+ # the longest one would keep going:
+ if ($one_program && ($grand_schedule > 0.0)) {
+ printf "Estimated Average Number of Developers (Effort/Schedule)  = %s\n",
+       numformat($grand_total_effort / $grand_schedule, 2);
+ }
+
+
+ $value = ($grand_total_effort / 12.0) * $person_cost * $overhead;
+ printf "Total Estimated Cost to Develop                           = \$ %s\n",
+      numformat($value, 0);
+ printf " (average salary = \$%s/year, overhead = %0.2f).\n",
+      commify($person_cost), $overhead;
+
+} else {
+print "Total Number of Files = $grand_total_sloc\n";
+print "Total Number of Source Code Files = $grand_total_lang_sloc\n";
+}
+print "SLOCCount, Copyright (C) 2001-2004 David A. Wheeler\n";
+print "SLOCCount is Open Source Software/Free Software, licensed under the GNU GPL.\n";
+print "SLOCCount comes with ABSOLUTELY NO WARRANTY, and you are welcome to\n";
+print "redistribute it under certain conditions as specified by the GNU GPL license;\n";
+print "see the documentation for details.\n";
+print "Please credit this data as \"generated using David A. Wheeler's 'SLOCCount'.\"\n";
+

data/externals/sloccount/get_sloc_details

@@ -0,0 +1,103 @@
+#!/usr/bin/perl -w
+
+# get_sloc_details
+# Take a list of dirs, and get the detailed SLOC entries for every file.
+
+# This is part of SLOCCount, a toolsuite that counts
+# source lines of code (SLOC).
+# Copyright (C) 2001-2004 David A. Wheeler.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# 
+# To contact David A. Wheeler, see his website at:
+#  http://www.dwheeler.com.
+
+
+sub print_data
+{
+ my $dir = shift;
+ my $langfile = shift;
+ my $saw_total = 0;
+ my $filename = "${dir}/${langfile}";
+ my $lang = $langfile;
+ $lang =~ s/_outfile\.dat$//;
+
+ open(RAWDATA, "<$filename") ||
+     return;
+ #     die "Can't open file in $dir for language $lang.\n";
+
+ if ($lang eq "asm") {
+   while (<RAWDATA>) {
+     if (m/^Total:/) {
+       $saw_total = 1;
+       last;
+     }
+     chomp;
+     if (m/^([0-9]+)\s+\([^\)]+\)\s+(.*)/) {
+       print "$1\t$lang\t$dir\t$2\n";
+     } else {
+       print STDERR "Warning: file $filename has unexpected text: $_\n";
+     }
+   }
+ } else {
+   while (<RAWDATA>) {
+     if (m/^Total:/) {
+       $saw_total = 1;
+       last;
+     }
+     chomp;
+     if (m/^([0-9]+)\s+(.*)/) {
+       print "$1\t$lang\t$dir\t$2\n";
+     } else {
+       print STDERR "Warning: file $filename has unexpected text: $_\n";
+     }
+   }
+ }
+ close(RAWDATA);
+ if (! $saw_total) {
+   print STDERR "Warning! No 'Total' line in $filename.\n";
+ }
+}
+
+# MAIN PROGRAM
+
+
+if ($#ARGV < 0) {
+ print STDERR "Error! You must list at least one directory to process.\n";
+ exit(1);
+}
+
+
+while ( $dir = shift ) {
+
+ if (! -d "$dir") {
+   # print "Skipping non-directory $dir\n";
+   next;
+ } 
+ 
+ if (! -r "${dir}/filelist") {
+   # print "Skipping directory $dir; it doesn't contain a file 'filelist'\n";
+   next;
+ }
+
+  opendir(DATADIR, $dir) || die "can't opendir $dir: $!";
+  @outfiles = grep { /outfile\.dat$/ } readdir(DATADIR);
+  closedir DATADIR;
+  foreach $langfile (@outfiles) {
+    print_data($dir, $langfile);
+ }
+
+}
+