objective-ci 0.0.1

data/externals/oclint/oclint-xcodebuild

@@ -0,0 +1,216 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import json
+import argparse
+import re
+import shlex
+import StringIO
+import glob
+import itertools
+
+
+SUPPORTED_COMPILERS = [
+    "clang",
+    "clang\+\+",
+    "llvm-cpp-4.2",
+    "llvm-g\+\+",
+    "llvm-g\+\+-4.2",
+    "llvm-gcc",
+    "llvm-gcc-4.2",
+    "arm-apple-darwin10-llvm-g\+\+-4.2",
+    "arm-apple-darwin10-llvm-gcc-4.2",
+    "i686-apple-darwin10-llvm-g\+\+-4.2",
+    "i686-apple-darwin10-llvm-gcc-4.2",
+    "gcc",
+    "g\+\+",
+    "c\+\+",
+    "cc"
+]
+
+DEFAULT_INPUT_FILE = "xcodebuild.log"
+
+JSON_COMPILATION_DATABASE = "compile_commands.json"
+
+
+_find_unsafe = re.compile('[ "\\\\]').search
+
+def clang_quote(s):
+    """
+    Return a minimally-escaped version of the string *s* that clang-based tools understand.
+    (See http://clang.llvm.org/docs/JSONCompilationDatabase.html)
+    ex:
+      clang_quote('aa') == r'aa'
+      clang_quote('a"a') == r'"a\"a"'
+      clang_quote('--my-option=a"a') == r'"--my-option=a\"a"'
+    """
+    if not s:
+        return '""'
+
+    if _find_unsafe(s) is None:
+        return s
+
+    return '"' + s.replace('\\', '\\\\').replace('"', '\\"') + '"'
+
+
+_find_quoting = re.compile('[\'"\\\\]').search
+
+def tokenize_command(c):
+    """Compute the list of shell arguments in *c* using shlex.split (note: make an explicit call to StringIO for compatibility with Python 2)."""
+    if _find_quoting(c) is None:
+        return map(str.strip, c.strip().split(' '))
+    else:
+        return shlex.split(StringIO.StringIO(c))
+
+# global table to map pth files to (source) pch files
+_pch_dictionary = {}
+
+def register_source_for_pth_file(clang_command, directory):
+    tokens = iter(tokenize_command(clang_command))
+    src_file = ""
+    pth_file = ""
+    try:
+        while 1:
+            tok = tokens.next()
+            if tok == '-c':
+                file = tokens.next()
+                src_file = file
+            elif tok == '-o':
+                file = tokens.next()
+                if file.endswith('.pch.pth') or file.endswith('.pch.pch'):
+                    pth_file = file
+    except StopIteration:
+        if src_file and pth_file:
+            _pch_dictionary[pth_file] = src_file
+
+def get_source_for_pth_file(file):
+    src_file = _pch_dictionary.get(file + '.pth')
+    if src_file is not None:
+        return src_file
+    return _pch_dictionary.get(file + '.pch')
+
+def process_clang_command(clang_command, directory):
+    tokens = iter(tokenize_command(clang_command))
+    command = []
+    source_file = None
+
+    try:
+        while 1:
+            tok = tokens.next()
+            if tok == '-include':
+                include_file = tokens.next()
+                if not os.path.isfile(include_file):
+                    src_file = get_source_for_pth_file(include_file)
+                    if src_file is not None:
+                        include_file = src_file
+                    else:
+                        print "cannot find original pch source file for %s" % include_file
+                        exit(3)
+                command.append(tok)
+                command.append(clang_quote(include_file))
+
+            elif tok == '-c':
+                source_file = tokens.next()
+                command.append(tok)
+                command.append(clang_quote(source_file))
+
+            else:
+                command.append(clang_quote(tok))
+
+    except StopIteration:
+        return {"directory": directory, "command": " ".join(command), "file": os.path.normpath(source_file)}
+
+
+def read_directory(line):
+    tokens = tokenize_command(line)
+    if tokens[0] == "cd":
+        return tokens[1]
+    else:
+        return ""
+
+def convert(input_file, output_file, is_excluded=None):
+    json_input_mode = input_file.endswith('.json')
+
+    find_compileC = re.compile("CompileC").search
+
+    find_processPCH = re.compile("ProcessPCH").search
+
+    find_clang_command = re.compile("(" + "|".join(SUPPORTED_COMPILERS) + ") .* -c .* -o ").search
+
+    if is_excluded is None:
+        is_excluded = (lambda x: False)
+
+    with open(output_file, "w") as output:
+        with open(input_file, "r") as input:
+            if json_input_mode:
+                lines = itertools.chain(*(json.loads(line).get('command', '').encode("utf8").splitlines(True) for line in input))
+            else:
+                lines = input
+            try:
+                output.write("[")
+                cr = "\n"
+                while 1:
+                    log_line = lines.next()
+                    compilation_section_re = find_compileC(log_line)
+                    if compilation_section_re:
+                        directory = read_directory(lines.next())
+                        if is_excluded(directory):
+                            continue
+                        while 1:
+                            log_line = lines.next()
+                            if not find_clang_command(log_line):
+                                continue
+                            output_record = process_clang_command(log_line, directory)
+                            output.write(cr)
+                            output.write(json.dumps(output_record, indent=2))
+                            cr = ",\n"
+                            break
+                        continue
+                    compilation_section_re = find_processPCH(log_line)
+                    if compilation_section_re:
+                        directory = read_directory(lines.next())
+                        if is_excluded(directory):
+                            continue
+                        while 1:
+                            log_line = lines.next()
+                            if not find_clang_command(log_line):
+                                continue
+                            register_source_for_pth_file(log_line, directory)
+                            break
+                        continue
+            except StopIteration:
+                output.write("\n]\n");
+
+def main():
+    arg_parser = argparse.ArgumentParser(description='Converts xcodebuild logs or xctool-json-reporter logs to compile_commands.json')
+    arg_parser.add_argument("-e", "-exclude", dest="exclusion", help="Directory exclusion pattern (regular expression)")
+    arg_parser.add_argument("-o", "-output", dest="output_file", help="Output json file (default: ./%s)" % JSON_COMPILATION_DATABASE)
+    arg_parser.add_argument(metavar="FILE", nargs='?', dest="input_file", help="Input log file (default: ./%s)" % DEFAULT_INPUT_FILE)
+
+    args = arg_parser.parse_args()
+
+    if args.input_file:
+        input_file = args.input_file
+    else:
+        input_file = DEFAULT_INPUT_FILE
+
+    if args.output_file:
+        output_file = args.output_file
+    else:
+        output_file = JSON_COMPILATION_DATABASE
+
+    if not os.path.isfile(input_file):
+        print "Error: %s not found." % input_file
+        exit(1)
+
+    if args.exclusion:
+        is_excluded = re.compile(args.exclusion).match
+    else:
+        is_excluded = None
+
+    convert(input_file, output_file, is_excluded)
+
+
+if __name__ == '__main__':
+    main()

data/externals/sloccount/ada_count

@@ -0,0 +1,27 @@
+#!/bin/sh
+# 
+# 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.
+# 
+# 
+
+generic_count '--' "$@"
+

data/externals/sloccount/asm_count

@@ -0,0 +1,166 @@
+#!/usr/bin/perl -w
+# asm_count - count physical lines of code in Assembly programs.
+# Usage: asm_count [-f file] [list_of_files]
+#  file: file with a list of files to count (if "-", read list from stdin)
+#  list_of_files: list of files to count
+#  -f file or list_of_files can be used, or both
+# This is a trivial/naive program.
+
+# For each file, it looks at the contents to heuristically determine
+# if C comments are permitted and what the "comment" character is.
+# If /* and */ are in the file, then C comments are permitted.
+# The punctuation mark that starts the most lines must be the comment
+# character (but ignoring "/" if C comments are allowed, and
+# ignoring '#' if cpp commands appear to be used)
+
+# 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.
+
+
+
+$total_sloc = 0;
+
+# Do we have "-f" (read list of files from second argument)?
+if (($#ARGV >= 1) && ($ARGV[0] eq "-f")) {
+  # Yes, we have -f
+  if ($ARGV[1] eq "-") {
+    # The list of files is in STDIN
+    while (<STDIN>) {
+      chomp ($_);
+      &count_file ($_);
+    }
+  } else {
+    # The list of files is in the file $ARGV[1]
+    open (FILEWITHLIST, $ARGV[1]) || die "Error: Could not open $ARGV[1]\n";
+    while (<FILEWITHLIST>) {
+      chomp ($_);
+      &count_file ($_);
+    }
+    close FILEWITHLIST;
+  }
+  shift @ARGV; shift @ARGV;
+}
+# Process all (remaining) arguments as file names
+while ($file = shift @ARGV) {
+  &count_file ($file);
+}
+
+print "Total:\n";
+print "$total_sloc\n";
+
+sub count_file {
+  my ($file) = @_;
+  # First, use heuristics to determine the comment char and if it uses C comments
+  $found_c_start = 0;
+  $found_c_end = 0;
+  $cpp_suspicious = 0;
+  $cpp_likely = 0;
+  $cpp_used = 0;
+  %count = ();
+  if ($file eq "") {
+    *CURRENTFILE = *STDIN
+  } else {
+    open(CURRENTFILE, "<$file");
+  }
+  while (<CURRENTFILE>) {
+    if (m!\/\*!) { $found_c_start++;}
+    if (m!\*\/!) { $found_c_end++;}
+    if ( (m!^#\s*define\s!) || (m!^#\s*else!)) {$cpp_suspicious++;}
+    if ( (m!^#\s*ifdef\s!) || (m!^#\s*endif!) || (m!#\s*include!)) {$cpp_likely++;}
+    if (m/^\s*([;!\/#\@\|\*])/) { $count{$1}++; }  # Found a likely comment char.
+  }
+  # Done examing file, let's figure out the parameters.
+  if ($found_c_start && $found_c_end) {
+    $ccomments = 1;
+    $count{'/'} = 0;
+    # $count{'*'} = 0;  # Do this to ignore '*' if C comments are used.
+  } else {
+    $ccomments = 0;
+  }
+  if (($cpp_suspicious > 2) || ($cpp_likely >= 1)) {
+    $cpp_used = 1;
+    $count{'#'} = 0;
+  } else {
+    $cpp_used = 0;
+  }
+  $likeliest = ';';
+  $likeliest_count = 0;
+  foreach $i (keys(%count)) {
+    # print "DEBUG: key=$i count=$count{$i}\n";
+    if ($count{$i} > $likeliest_count) {
+      $likeliest = $i;
+      $likeliest_count = $count{$i};
+    }
+  }
+  # print "DEBUG: likeliest = $likeliest\n";
+  $commentchar=$likeliest;
+  close(CURRENTFILE);
+
+  # Now count SLOC.
+  $sloc = 0;
+  $isincomment = 0;
+  open(CURRENTFILE, "<$file");
+  while (<CURRENTFILE>) {
+    # We handle C comments first, so that if an EOL-comment
+    # occurs inside a C comment, it's ignored.
+    if ($ccomments) {
+      # Handle C /* */ comments; this will get fooled if they're in strings,
+      # but that would be rare in assembly.
+      while ( (m!\/\*!) || (m!\*\/!)) {  # While unprocessed C comment.
+	if ($isincomment) {
+	  s!.*?\*\/.*!!;
+	  $isincomment = 0;
+	} else {           # Not in C comment, but have end comment marker.
+	  if (! m/\/\*/) {  # Whups, there's no starting marker!
+	    print STDERR "Warning: file $file line $. has unmatched comment end\n";
+	    # Get us back to a plausible state:
+	    s/.*//; # Destroy everything
+	      $isincomment = 0;
+	  } else {
+	    if (! s!\/\*.*?\*\/!!) { # Try to delete whole comment.
+              # We couldn't delete whole comment.  Delete what's there.
+              s!\/\*.*!!;
+              $isincomment = 1;
+	    }
+	  }
+	}
+      }
+    }  # End of handling C comments.
+    # This requires $[ be unchanged.
+    $locate_comment = index($_, $commentchar);
+    if ($locate_comment >= 0) {  # We found a comment character, delete comment
+       $_ = substr($_, 0, $locate_comment);
+       # print "DEBUG New text: @",$_,"@\n";
+    }
+    # old: s/${commentchar}.*//;  # Delete leading comments.
+
+    # FOR DEBUG: print "Finally isincomment=$isincomment line=$_\n";
+    if ((! $isincomment) && (m/\S/)) {$sloc++;}
+  }
+
+  # End-of-file processing
+  print "$sloc (commentchar=$commentchar C-comments=$ccomments) $file\n";
+  $total_sloc += $sloc;
+  $sloc = 0;
+  if ($isincomment) {
+    print STDERR "Missing comment close in file $file\n";
+  }
+}

data/externals/sloccount/awk_count

@@ -0,0 +1,27 @@
+#!/bin/sh
+# 
+# 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.
+# 
+# 
+
+generic_count '#' $@
+