[GitHub/mt8127/android_kernel_alcatel_ttab.git] / scripts / get_maintainer.pl

#!/usr/bin/perl -w
# (c) 2007, Joe Perches <joe@perches.com>
#           created from checkpatch.pl
#
# Print selected MAINTAINERS information for
# the files modified in a patch or for a file
#
# usage: perl scripts/get_maintainers.pl [OPTIONS] <patch>
#        perl scripts/get_maintainers.pl [OPTIONS] -f <file>
#
# Licensed under the terms of the GNU GPL License version 2

use strict;

my $P = $0;
my $V = '0.15';

use Getopt::Long qw(:config no_auto_abbrev);

my $lk_path = "./";
my $email = 1;
my $email_usename = 1;
my $email_maintainer = 1;
my $email_list = 1;
my $email_subscriber_list = 0;
my $email_git = 1;
my $email_git_penguin_chiefs = 0;
my $email_git_min_signatures = 1;
my $email_git_max_maintainers = 5;
my $email_git_since = "1-year-ago";
my $output_multiline = 1;
my $output_separator = ", ";
my $scm = 0;
my $web = 0;
my $subsystem = 0;
my $status = 0;
my $from_filename = 0;
my $version = 0;
my $help = 0;

my $exit = 0;

my @penguin_chief = ();
push(@penguin_chief,"Linus Torvalds:torvalds\@linux-foundation.org");
#Andrew wants in on most everything - 2009/01/14
#push(@penguin_chief,"Andrew Morton:akpm\@linux-foundation.org");

my @penguin_chief_names = ();
foreach my $chief (@penguin_chief) {
    if ($chief =~ m/^(.*):(.*)/) {
	my $chief_name = $1;
	my $chief_addr = $2;
	push(@penguin_chief_names, $chief_name);
    }
}
my $penguin_chiefs = "\(" . join("|",@penguin_chief_names) . "\)";

if (!GetOptions(
		'email!' => \$email,
		'git!' => \$email_git,
		'git-chief-penguins!' => \$email_git_penguin_chiefs,
		'git-min-signatures=i' => \$email_git_min_signatures,
		'git-max-maintainers=i' => \$email_git_max_maintainers,
		'git-since=s' => \$email_git_since,
		'm!' => \$email_maintainer,
		'n!' => \$email_usename,
		'l!' => \$email_list,
		's!' => \$email_subscriber_list,
		'multiline!' => \$output_multiline,
		'separator=s' => \$output_separator,
		'subsystem!' => \$subsystem,
		'status!' => \$status,
		'scm!' => \$scm,
		'web!' => \$web,
		'f|file' => \$from_filename,
		'v|version' => \$version,
		'h|help' => \$help,
		)) {
    usage();
    die "$P: invalid argument\n";
}

if ($help != 0) {
    usage();
    exit 0;
}

if ($version != 0) {
    print("${P} ${V}\n");
    exit 0;
}

if ($#ARGV < 0) {
    usage();
    die "$P: argument missing: patchfile or -f file please\n";
}

my $selections = $email + $scm + $status + $subsystem + $web;
if ($selections == 0) {
    usage();
    die "$P:  Missing required option: email, scm, status, subsystem or web\n";
}

if ($email && ($email_maintainer + $email_list + $email_subscriber_list
	       + $email_git + $email_git_penguin_chiefs) == 0) {
    usage();
    die "$P: Please select at least 1 email option\n";
}

if (!top_of_kernel_tree($lk_path)) {
    die "$P: The current directory does not appear to be "
	. "a linux kernel source tree.\n";
}

## Read MAINTAINERS for type/value pairs

my @typevalue = ();
open(MAINT, "<${lk_path}MAINTAINERS") || die "$P: Can't open MAINTAINERS\n";
while (<MAINT>) {
    my $line = $_;

    if ($line =~ m/^(\C):\s*(.*)/) {
	my $type = $1;
	my $value = $2;

	##Filename pattern matching
	if ($type eq "F" || $type eq "X") {
	    $value =~ s@\.@\\\.@g;       ##Convert . to \.
	    $value =~ s/\*/\.\*/g;       ##Convert * to .*
	    $value =~ s/\?/\./g;         ##Convert ? to .
	}
	push(@typevalue, "$type:$value");
    } elsif (!/^(\s)*$/) {
	$line =~ s/\n$//g;
	push(@typevalue, $line);
    }
}
close(MAINT);

## use the filenames on the command line or find the filenames in the patchfiles

my @files = ();

foreach my $file (@ARGV) {
    next if ((-d $file));
    if (!(-f $file)) {
	die "$P: file '${file}' not found\n";
    }
    if ($from_filename) {
	push(@files, $file);
    } else {
	my $file_cnt = @files;
	open(PATCH, "<$file") or die "$P: Can't open ${file}\n";
	while (<PATCH>) {
	    if (m/^\+\+\+\s+(\S+)/) {
		my $filename = $1;
		$filename =~ s@^[^/]*/@@;
		$filename =~ s@\n@@;
		push(@files, $filename);
	    }
	}
	close(PATCH);
	if ($file_cnt == @files) {
	    die "$P: file '${file}' doesn't appear to be a patch.  "
		. "Add -f to options?\n";
	}
	@files = sort_and_uniq(@files);
    }
}

my @email_to = ();
my @scm = ();
my @web = ();
my @subsystem = ();
my @status = ();

# Find responsible parties

foreach my $file (@files) {

#Do not match excluded file patterns

    my $exclude = 0;
    foreach my $line (@typevalue) {
	if ($line =~ m/^(\C):(.*)/) {
	    my $type = $1;
	    my $value = $2;
	    if ($type eq 'X') {
		if (file_match_pattern($file, $value)) {
		    $exclude = 1;
		}
	    }
	}
    }

    if (!$exclude) {
	my $tvi = 0;
	foreach my $line (@typevalue) {
	    if ($line =~ m/^(\C):(.*)/) {
		my $type = $1;
		my $value = $2;
		if ($type eq 'F') {
		    if (file_match_pattern($file, $value)) {
			add_categories($tvi);
		    }
		}
	    }
	    $tvi++;
	}
    }

    if ($email && $email_git) {
	recent_git_signoffs($file);
    }

}

if ($email_git_penguin_chiefs) {
    foreach my $chief (@penguin_chief) {
	if ($chief =~ m/^(.*):(.*)/) {
	    my $chief_name = $1;
	    my $chief_addr = $2;
	    if ($email_usename) {
		push(@email_to, format_email($chief_name, $chief_addr));
	    } else {
		push(@email_to, $chief_addr);
	    }
	}
    }
}

if ($email) {
    my $address_cnt = @email_to;
    if ($address_cnt == 0 && $email_list) {
	push(@email_to, "linux-kernel\@vger.kernel.org");
    }

#Don't sort email address list, but do remove duplicates
    @email_to = uniq(@email_to);
    output(@email_to);
}

if ($scm) {
    @scm = sort_and_uniq(@scm);
    output(@scm);
}

if ($status) {
    @status = sort_and_uniq(@status);
    output(@status);
}

if ($subsystem) {
    @subsystem = sort_and_uniq(@subsystem);
    output(@subsystem);
}

if ($web) {
    @web = sort_and_uniq(@web);
    output(@web);
}

exit($exit);

sub file_match_pattern {
    my ($file, $pattern) = @_;
    if (substr($pattern, -1) eq "/") {
	if ($file =~ m@^$pattern@) {
	    return 1;
	}
    } else {
	if ($file =~ m@^$pattern@) {
	    my $s1 = ($file =~ tr@/@@);
	    my $s2 = ($pattern =~ tr@/@@);
	    if ($s1 == $s2) {
		return 1;
	    }
	}
    }
    return 0;
}

sub usage {
    print <<EOT;
usage: $P [options] patchfile
       $P [options] -f file
version: $V

MAINTAINER field selection options:
  --email => print email address(es) if any
    --git => include recent git \*-by: signers
    --git-chief-penguins => include ${penguin_chiefs}
    --git-min-signatures => number of signatures required (default: 1)
    --git-max-maintainers => maximum maintainers to add (default: 5)
    --git-since => git history to use (default: 1-year-ago)
    --m => include maintainer(s) if any
    --n => include name 'Full Name <addr\@domain.tld>'
    --l => include list(s) if any
    --s => include subscriber only list(s) if any
  --scm => print SCM tree(s) if any
  --status => print status if any
  --subsystem => print subsystem name if any
  --web => print website(s) if any

Output type options:
  --separator [, ] => separator for multiple entries on 1 line
  --multiline => print 1 entry per line

Default options:
  [--email --git --m --l --multiline]

Other options:
  --version -> show version
  --help => show this help information

EOT
}

sub top_of_kernel_tree {
	my ($lk_path) = @_;

	if ($lk_path ne "" && substr($lk_path,length($lk_path)-1,1) ne "/") {
	    $lk_path .= "/";
	}
	if (   (-f "${lk_path}COPYING")
	    && (-f "${lk_path}CREDITS")
	    && (-f "${lk_path}Kbuild")
	    && (-f "${lk_path}MAINTAINERS")
	    && (-f "${lk_path}Makefile")
	    && (-f "${lk_path}README")
	    && (-d "${lk_path}Documentation")
	    && (-d "${lk_path}arch")
	    && (-d "${lk_path}include")
	    && (-d "${lk_path}drivers")
	    && (-d "${lk_path}fs")
	    && (-d "${lk_path}init")
	    && (-d "${lk_path}ipc")
	    && (-d "${lk_path}kernel")
	    && (-d "${lk_path}lib")
	    && (-d "${lk_path}scripts")) {
		return 1;
	}
	return 0;
}

sub format_email {
    my ($name, $email) = @_;

    $name =~ s/^\s+|\s+$//g;
    $email =~ s/^\s+|\s+$//g;

    my $formatted_email = "";

    if ($name =~ /[^a-z0-9 \.\-]/i) {    ##has "must quote" chars
	$name =~ s/(?<!\\)"/\\"/g;       ##escape quotes
	$formatted_email = "\"${name}\"\ \<${email}\>";
    } else {
	$formatted_email = "${name} \<${email}\>";
    }
    return $formatted_email;
}

sub add_categories {
    my ($index) = @_;

    $index = $index - 1;
    while ($index >= 0) {
	my $tv = $typevalue[$index];
	if ($tv =~ m/^(\C):(.*)/) {
	    my $ptype = $1;
	    my $pvalue = $2;
	    if ($ptype eq "L") {
		my $subscr = $pvalue;
		if ($subscr =~ m/\s*\(subscribers-only\)/) {
		    if ($email_subscriber_list) {
			$subscr =~ s/\s*\(subscribers-only\)//g;
			push(@email_to, $subscr);
		    }
		} else {
		    if ($email_list) {
			push(@email_to, $pvalue);
		    }
		}
	    } elsif ($ptype eq "M") {
		if ($email_maintainer) {
		    if ($index >= 0) {
			my $tv = $typevalue[$index - 1];
			if ($tv =~ m/^(\C):(.*)/) {
			    if ($1 eq "P" && $email_usename) {
				push(@email_to, format_email($2, $pvalue));
			    } else {
				push(@email_to, $pvalue);
			    }
			}
		    } else {
			push(@email_to, $pvalue);
		    }
		}
	    } elsif ($ptype eq "T") {
		push(@scm, $pvalue);
	    } elsif ($ptype eq "W") {
		push(@web, $pvalue);
	    } elsif ($ptype eq "S") {
		push(@status, $pvalue);
	    }

	    $index--;
	} else {
	    push(@subsystem,$tv);
	    $index = -1;
	}
    }
}

sub which {
    my ($bin) = @_;

    foreach my $path (split /:/, $ENV{PATH}) {
	if (-e "$path/$bin") {
	    return "$path/$bin";
	}
    }

    return "";
}

sub recent_git_signoffs {
    my ($file) = @_;

    my $sign_offs = "";
    my $cmd = "";
    my $output = "";
    my $count = 0;
    my @lines = ();

    if (which("git") eq "") {
	die("$P: git not found.  Add --nogit to options?\n");
    }

    $cmd = "git log --since=${email_git_since} -- ${file}";
    $cmd .= " | grep -Pi \"^[-_ 	a-z]+by:.*\\\@\"";
    if (!$email_git_penguin_chiefs) {
	$cmd .= " | grep -Pv \"${penguin_chiefs}\"";
    }
    $cmd .= " | cut -f2- -d\":\"";
    $cmd .= " | sed -e \"s/^\\s+//g\"";
    $cmd .= " | sort | uniq -c | sort -rn";

    $output = `${cmd}`;
    $output =~ s/^\s*//gm;

    @lines = split("\n", $output);
    foreach my $line (@lines) {
	if ($line =~ m/([0-9]+)\s+(.*)/) {
	    my $sign_offs = $1;
	    $line = $2;
	    $count++;
	    if ($sign_offs < $email_git_min_signatures ||
	        $count > $email_git_max_maintainers) {
		last;
	    }
	} else {
	    die("$P: Unexpected git output: ${line}\n");
	}
	if ($line =~ m/(.+)<(.+)>/) {
	    my $git_name = $1;
	    my $git_addr = $2;
	    $git_name =~ tr/^\"//;
	    $git_name =~ tr/^\\s*//;
	    $git_name =~ tr/\"$//;
	    $git_name =~ tr/\\s*$//;
	    if ($email_usename) {
		push(@email_to, format_email($git_name, $git_addr));
	    } else {
		push(@email_to, $git_addr);
	    }
	} elsif ($line =~ m/<(.+)>/) {
	    my $git_addr = $1;
	    push(@email_to, $git_addr);
	} else {
	    push(@email_to, $line);
	}
    }
    return $output;
}

sub uniq {
    my @parms = @_;

    my %saw;
    @parms = grep(!$saw{$_}++, @parms);
    return @parms;
}

sub sort_and_uniq {
    my @parms = @_;

    my %saw;
    @parms = sort @parms;
    @parms = grep(!$saw{$_}++, @parms);
    return @parms;
}

sub output {
    my @parms = @_;

    if ($output_multiline) {
	foreach my $line (@parms) {
	    print("${line}\n");
	}
    } else {
	print(join($output_separator, @parms));
	print("\n");
    }
}
Commit	Line	Data
cb7301c7 JP	1	#!/usr/bin/perl -w
	2	# (c) 2007, Joe Perches <joe@perches.com>
	3	# created from checkpatch.pl
	4	#
	5	# Print selected MAINTAINERS information for
	6	# the files modified in a patch or for a file
	7	#
	8	# usage: perl scripts/get_maintainers.pl [OPTIONS] <patch>
	9	# perl scripts/get_maintainers.pl [OPTIONS] -f <file>
	10	#
	11	# Licensed under the terms of the GNU GPL License version 2
	12
	13	use strict;
	14
	15	my $P = $0;
4a7fdb5f	16	my $V = '0.15';
cb7301c7 JP	17
	18	use Getopt::Long qw(:config no_auto_abbrev);
	19
	20	my $lk_path = "./";
	21	my $email = 1;
	22	my $email_usename = 1;
	23	my $email_maintainer = 1;
	24	my $email_list = 1;
	25	my $email_subscriber_list = 0;
	26	my $email_git = 1;
	27	my $email_git_penguin_chiefs = 0;
	28	my $email_git_min_signatures = 1;
	29	my $email_git_max_maintainers = 5;
	30	my $email_git_since = "1-year-ago";
	31	my $output_multiline = 1;
	32	my $output_separator = ", ";
	33	my $scm = 0;
	34	my $web = 0;
	35	my $subsystem = 0;
	36	my $status = 0;
4a7fdb5f	37	my $from_filename = 0;
cb7301c7 JP	38	my $version = 0;
	39	my $help = 0;
	40
	41	my $exit = 0;
	42
	43	my @penguin_chief = ();
	44	push(@penguin_chief,"Linus Torvalds:torvalds\@linux-foundation.org");
	45	#Andrew wants in on most everything - 2009/01/14
	46	#push(@penguin_chief,"Andrew Morton:akpm\@linux-foundation.org");
	47
	48	my @penguin_chief_names = ();
	49	foreach my $chief (@penguin_chief) {
	50	if ($chief =~ m/^(.):(.)/) {
	51	my $chief_name = $1;
	52	my $chief_addr = $2;
	53	push(@penguin_chief_names, $chief_name);
	54	}
	55	}
	56	my $penguin_chiefs = "\(" . join("\|",@penguin_chief_names) . "\)";
	57
	58	if (!GetOptions(
	59	'email!' => \$email,
	60	'git!' => \$email_git,
	61	'git-chief-penguins!' => \$email_git_penguin_chiefs,
	62	'git-min-signatures=i' => \$email_git_min_signatures,
	63	'git-max-maintainers=i' => \$email_git_max_maintainers,
	64	'git-since=s' => \$email_git_since,
	65	'm!' => \$email_maintainer,
	66	'n!' => \$email_usename,
	67	'l!' => \$email_list,
	68	's!' => \$email_subscriber_list,
	69	'multiline!' => \$output_multiline,
	70	'separator=s' => \$output_separator,
	71	'subsystem!' => \$subsystem,
	72	'status!' => \$status,
	73	'scm!' => \$scm,
	74	'web!' => \$web,
4a7fdb5f	75	'f\|file' => \$from_filename,
cb7301c7 JP	76	'v\|version' => \$version,
	77	'h\|help' => \$help,
	78	)) {
	79	usage();
	80	die "$P: invalid argument\n";
	81	}
	82
	83	if ($help != 0) {
	84	usage();
	85	exit 0;
	86	}
	87
	88	if ($version != 0) {
	89	print("${P} ${V}\n");
	90	exit 0;
	91	}
	92
cb7301c7 JP	93	if ($#ARGV < 0) {
	94	usage();
	95	die "$P: argument missing: patchfile or -f file please\n";
	96	}
	97
	98	my $selections = $email + $scm + $status + $subsystem + $web;
	99	if ($selections == 0) {
	100	usage();
	101	die "$P: Missing required option: email, scm, status, subsystem or web\n";
	102	}
	103
	104	if ($email && ($email_maintainer + $email_list + $email_subscriber_list
	105	+ $email_git + $email_git_penguin_chiefs) == 0) {
	106	usage();
	107	die "$P: Please select at least 1 email option\n";
	108	}
	109
	110	if (!top_of_kernel_tree($lk_path)) {
	111	die "$P: The current directory does not appear to be "
	112	. "a linux kernel source tree.\n";
	113	}
	114
	115	## Read MAINTAINERS for type/value pairs
	116
	117	my @typevalue = ();
	118	open(MAINT, "<${lk_path}MAINTAINERS") \|\| die "$P: Can't open MAINTAINERS\n";
	119	while (<MAINT>) {
	120	my $line = $_;
	121
	122	if ($line =~ m/^(\C):\s(.)/) {
	123	my $type = $1;
	124	my $value = $2;
	125
	126	##Filename pattern matching
	127	if ($type eq "F" \|\| $type eq "X") {
	128	$value =~ s@\.@\\\.@g; ##Convert . to \.
	129	$value =~ s/\/\.\/g; ##Convert * to .*
	130	$value =~ s/\?/\./g; ##Convert ? to .
	131	}
	132	push(@typevalue, "$type:$value");
	133	} elsif (!/^(\s)*$/) {
	134	$line =~ s/\n$//g;
	135	push(@typevalue, $line);
	136	}
	137	}
	138	close(MAINT);
	139
4a7fdb5f	140	## use the filenames on the command line or find the filenames in the patchfiles
cb7301c7 JP	141
	142	my @files = ();
	143
4a7fdb5f JP	144	foreach my $file (@ARGV) {
	145	next if ((-d $file));
	146	if (!(-f $file)) {
	147	die "$P: file '${file}' not found\n";
cb7301c7	148	}
4a7fdb5f JP	149	if ($from_filename) {
	150	push(@files, $file);
	151	} else {
	152	my $file_cnt = @files;
	153	open(PATCH, "<$file") or die "$P: Can't open ${file}\n";
	154	while (<PATCH>) {
	155	if (m/^\+\+\+\s+(\S+)/) {
	156	my $filename = $1;
	157	$filename =~ s@^[^/]*/@@;
	158	$filename =~ s@\n@@;
	159	push(@files, $filename);
	160	}
cb7301c7	161	}
4a7fdb5f JP	162	close(PATCH);
	163	if ($file_cnt == @files) {
	164	die "$P: file '${file}' doesn't appear to be a patch. "
	165	. "Add -f to options?\n";
	166	}
	167	@files = sort_and_uniq(@files);
cb7301c7	168	}
cb7301c7 JP	169	}
	170
	171	my @email_to = ();
	172	my @scm = ();
	173	my @web = ();
	174	my @subsystem = ();
	175	my @status = ();
	176
	177	# Find responsible parties
	178
	179	foreach my $file (@files) {
	180
	181	#Do not match excluded file patterns
	182
	183	my $exclude = 0;
	184	foreach my $line (@typevalue) {
	185	if ($line =~ m/^(\C):(.*)/) {
	186	my $type = $1;
	187	my $value = $2;
	188	if ($type eq 'X') {
	189	if (file_match_pattern($file, $value)) {
	190	$exclude = 1;
	191	}
	192	}
	193	}
	194	}
	195
	196	if (!$exclude) {
	197	my $tvi = 0;
	198	foreach my $line (@typevalue) {
	199	if ($line =~ m/^(\C):(.*)/) {
	200	my $type = $1;
	201	my $value = $2;
	202	if ($type eq 'F') {
	203	if (file_match_pattern($file, $value)) {
	204	add_categories($tvi);
	205	}
	206	}
	207	}
	208	$tvi++;
	209	}
	210	}
	211
4a7fdb5f	212	if ($email && $email_git) {
cb7301c7 JP	213	recent_git_signoffs($file);
	214	}
	215
	216	}
	217
	218	if ($email_git_penguin_chiefs) {
	219	foreach my $chief (@penguin_chief) {
	220	if ($chief =~ m/^(.):(.)/) {
	221	my $chief_name = $1;
	222	my $chief_addr = $2;
	223	if ($email_usename) {
	224	push(@email_to, format_email($chief_name, $chief_addr));
	225	} else {
	226	push(@email_to, $chief_addr);
	227	}
	228	}
	229	}
	230	}
	231
	232	if ($email) {
	233	my $address_cnt = @email_to;
	234	if ($address_cnt == 0 && $email_list) {
	235	push(@email_to, "linux-kernel\@vger.kernel.org");
	236	}
	237
	238	#Don't sort email address list, but do remove duplicates
	239	@email_to = uniq(@email_to);
	240	output(@email_to);
	241	}
	242
	243	if ($scm) {
4a7fdb5f	244	@scm = sort_and_uniq(@scm);
cb7301c7 JP	245	output(@scm);
	246	}
	247
	248	if ($status) {
4a7fdb5f	249	@status = sort_and_uniq(@status);
cb7301c7 JP	250	output(@status);
	251	}
	252
	253	if ($subsystem) {
4a7fdb5f	254	@subsystem = sort_and_uniq(@subsystem);
cb7301c7 JP	255	output(@subsystem);
	256	}
	257
	258	if ($web) {
4a7fdb5f	259	@web = sort_and_uniq(@web);
cb7301c7 JP	260	output(@web);
	261	}
	262
	263	exit($exit);
	264
	265	sub file_match_pattern {
	266	my ($file, $pattern) = @_;
	267	if (substr($pattern, -1) eq "/") {
	268	if ($file =~ m@^$pattern@) {
	269	return 1;
	270	}
	271	} else {
	272	if ($file =~ m@^$pattern@) {
	273	my $s1 = ($file =~ tr@/@@);
	274	my $s2 = ($pattern =~ tr@/@@);
	275	if ($s1 == $s2) {
	276	return 1;
	277	}
	278	}
	279	}
	280	return 0;
	281	}
	282
	283	sub usage {
	284	print <<EOT;
	285	usage: $P [options] patchfile
	286	$P [options] -f file
	287	version: $V
	288
	289	MAINTAINER field selection options:
	290	--email => print email address(es) if any
	291	--git => include recent git \*-by: signers
	292	--git-chief-penguins => include ${penguin_chiefs}
	293	--git-min-signatures => number of signatures required (default: 1)
	294	--git-max-maintainers => maximum maintainers to add (default: 5)
	295	--git-since => git history to use (default: 1-year-ago)
	296	--m => include maintainer(s) if any
	297	--n => include name 'Full Name <addr\@domain.tld>'
	298	--l => include list(s) if any
	299	--s => include subscriber only list(s) if any
	300	--scm => print SCM tree(s) if any
	301	--status => print status if any
	302	--subsystem => print subsystem name if any
	303	--web => print website(s) if any
	304
	305	Output type options:
	306	--separator [, ] => separator for multiple entries on 1 line
	307	--multiline => print 1 entry per line
	308
	309	Default options:
	310	[--email --git --m --l --multiline]
	311
	312	Other options:
	313	--version -> show version
	314	--help => show this help information
	315
	316	EOT
	317	}
	318
	319	sub top_of_kernel_tree {
	320	my ($lk_path) = @_;
	321
	322	if ($lk_path ne "" && substr($lk_path,length($lk_path)-1,1) ne "/") {
	323	$lk_path .= "/";
324	}
325	if ( (-f "${lk_path}COPYING")
326	&& (-f "${lk_path}CREDITS")
327	&& (-f "${lk_path}Kbuild")
328	&& (-f "${lk_path}MAINTAINERS")
329	&& (-f "${lk_path}Makefile")
330	&& (-f "${lk_path}README")
331	&& (-d "${lk_path}Documentation")
332	&& (-d "${lk_path}arch")
333	&& (-d "${lk_path}include")
334	&& (-d "${lk_path}drivers")
335	&& (-d "${lk_path}fs")
336	&& (-d "${lk_path}init")
337	&& (-d "${lk_path}ipc")
338	&& (-d "${lk_path}kernel")
339	&& (-d "${lk_path}lib")
340	&& (-d "${lk_path}scripts")) {
341	return 1;
342	}
343	return 0;
344	}
345
346	sub format_email {
347	my ($name, $email) = @_;
348
349	$name =~ s/^\s+\|\s+$//g;
350	$email =~ s/^\s+\|\s+$//g;
351
352	my $formatted_email = "";
353
354	if ($name =~ /[^a-z0-9 \.\-]/i) { ##has "must quote" chars
355	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
356	$formatted_email = "\"${name}\"\ \<${email}\>";
357	} else {
358	$formatted_email = "${name} \<${email}\>";
359	}
360	return $formatted_email;
361	}
362
363	sub add_categories {
364	my ($index) = @_;
365
366	$index = $index - 1;
367	while ($index >= 0) {
368	my $tv = $typevalue[$index];
369	if ($tv =~ m/^(\C):(.*)/) {
370	my $ptype = $1;
371	my $pvalue = $2;
372	if ($ptype eq "L") {
373	my $subscr = $pvalue;
374	if ($subscr =~ m/\s*\(subscribers-only\)/) {
375	if ($email_subscriber_list) {
376	$subscr =~ s/\s*\(subscribers-only\)//g;
377	push(@email_to, $subscr);
378	}
379	} else {
380	if ($email_list) {
381	push(@email_to, $pvalue);
382	}
383	}
384	} elsif ($ptype eq "M") {
385	if ($email_maintainer) {
386	if ($index >= 0) {
387	my $tv = $typevalue[$index - 1];
388	if ($tv =~ m/^(\C):(.*)/) {
389	if ($1 eq "P" && $email_usename) {
390	push(@email_to, format_email($2, $pvalue));
391	} else {
392	push(@email_to, $pvalue);
393	}
394	}
395	} else {
396	push(@email_to, $pvalue);
397	}
398	}
399	} elsif ($ptype eq "T") {
400	push(@scm, $pvalue);
401	} elsif ($ptype eq "W") {
402	push(@web, $pvalue);
403	} elsif ($ptype eq "S") {
404	push(@status, $pvalue);
405	}
406
407	$index--;
408	} else {
409	push(@subsystem,$tv);
410	$index = -1;
411	}
412	}
413	}
414
415	sub which {
416	my ($bin) = @_;
417
418	foreach my $path (split /:/, $ENV{PATH}) {
419	if (-e "$path/$bin") {
420	return "$path/$bin";
421	}
422	}
423
424	return "";
425	}
426
427	sub recent_git_signoffs {
428	my ($file) = @_;
429
430	my $sign_offs = "";
431	my $cmd = "";
432	my $output = "";
433	my $count = 0;
434	my @lines = ();
435
436	if (which("git") eq "") {
437	die("$P: git not found. Add --nogit to options?\n");
438	}
439
440	$cmd = "git log --since=${email_git_since} -- ${file}";
4a7fdb5f	441	$cmd .= " \| grep -Pi \"^[-_ a-z]+by:.*\\\@\"";
cb7301c7	442	if (!$email_git_penguin_chiefs) {
4a7fdb5f	443	$cmd .= " \| grep -Pv \"${penguin_chiefs}\"";
cb7301c7	444	}
4a7fdb5f JP	445	$cmd .= " \| cut -f2- -d\":\"";
4a7fdb5f JP	446	$cmd .= " \| sed -e \"s/^\\s+//g\"";
cb7301c7 JP	447	$cmd .= " \| sort \| uniq -c \| sort -rn";
	448
	449	$output = `${cmd}`;
	450	$output =~ s/^\s*//gm;
	451
	452	@lines = split("\n", $output);
	453	foreach my $line (@lines) {
4a7fdb5f	454	if ($line =~ m/([0-9]+)\s+(.*)/) {
cb7301c7	455	my $sign_offs = $1;
4a7fdb5f	456	$line = $2;
cb7301c7 JP	457	$count++;
	458	if ($sign_offs < $email_git_min_signatures \|\|
	459	$count > $email_git_max_maintainers) {
	460	last;
	461	}
	462	} else {
	463	die("$P: Unexpected git output: ${line}\n");
	464	}
4a7fdb5f	465	if ($line =~ m/(.+)<(.+)>/) {
cb7301c7 JP	466	my $git_name = $1;
	467	my $git_addr = $2;
	468	$git_name =~ tr/^\"//;
4a7fdb5f	469	$git_name =~ tr/^\\s*//;
cb7301c7	470	$git_name =~ tr/\"$//;
4a7fdb5f	471	$git_name =~ tr/\\s*$//;
cb7301c7 JP	472	if ($email_usename) {
	473	push(@email_to, format_email($git_name, $git_addr));
	474	} else {
	475	push(@email_to, $git_addr);
	476	}
4a7fdb5f	477	} elsif ($line =~ m/<(.+)>/) {
cb7301c7 JP	478	my $git_addr = $1;
	479	push(@email_to, $git_addr);
	480	} else {
	481	push(@email_to, $line);
	482	}
	483	}
	484	return $output;
	485	}
	486
	487	sub uniq {
	488	my @parms = @_;
	489
	490	my %saw;
	491	@parms = grep(!$saw{$_}++, @parms);
	492	return @parms;
	493	}
	494
	495	sub sort_and_uniq {
	496	my @parms = @_;
	497
	498	my %saw;
	499	@parms = sort @parms;
	500	@parms = grep(!$saw{$_}++, @parms);
	501	return @parms;
	502	}
	503
	504	sub output {
	505	my @parms = @_;
	506
	507	if ($output_multiline) {
	508	foreach my $line (@parms) {
	509	print("${line}\n");
	510	}
	511	} else {
	512	print(join($output_separator, @parms));
	513	print("\n");
	514	}
	515	}