dahdi-linux/menuselect/contrib/menuselect-dummy

#!/usr/bin/perl -w

# menuselect - a simple drop-in replacement of the batch-mode menuselect
# included with Asterisk.
#
# Copyright (C) 2008 by Tzafrir Cohen <tzafrir.cohen@xorcom.com>
#
# 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

# Installation: copy this script to menuselect/menuselect . Copy the
# included Makefile as menuselect/Makefile and run:
#
#   make -C makefile dummies
#
# It takes configuration from build_tools/conf . Sample config file:
#
#   By default all modules will be built (except those marked not be
#   used by default)
#
#   # exclude: Don't try to build the following modules. 
#   #exclude app_test
#
#   # You can have multiple items in each line, and multiple lines.
#   # Each item is a perl regular expression that must match the whole
#   # module name.
#   #exclude res_config_.*
#
#   # include: syntax is the same as exclude. Overrides exclude and
#   # modules that are marked as disabled by defualt:
#   #include res_config_sqlite3 app_skel
#
#   # If you want to make sure some modules will be conifgured to build,
#   # you can require them. If modules that match any of the 'require'
#   # pattern are not configured to build, menuselect will panic.
#   # Same pattern rules apply here. Why would you want that? I have no
#   # idea.
#   #require chan_h323 app_directory
#
#   # random - the value for this keyword is a number between 1 and 
#   # 100. The higher it is, more chances not to include each module.
#   # Writes the list of modules that got hit to
#   # build_tools/mods_removed_random .
#   # Note that unlike 'make randomconfig' and such the random
#   # configuration changes each time you run 'make', thus if a build
#   # failed you should first read build_tools/mods_removed_random
#   # before re-running make.
#   #random 10
#
#   # Anything after a '#' is ignored, and likewise empty lines.
#   # Naturally.

use strict;
use Getopt::Long;

# Holds global dependncy information. Keys are module names.
my %ModInfo = ();

# extract configuration from kernel modules:
my $AutoconfDepsFile = "build_tools/menuselect-deps";

my $AutoconfOptsFile = "makeopts";
my %ConfigureOpts = (); # 

# configuration file to read for some directives:
my $ConfFile = "build_tools/conf";

my $DumpFile = 'build_tools/dump_deps';

# Modules removed randomely:
my $RandomeModsFile = "build_tools/mods_removed_random";

my $MakedepsFile = "menuselect.makedeps";

my $MakeoptsFile = "menuselect.makeopts";

# If those modules are not present, the build will fail (PCRE patterns)
my @RequiredModules = ();

my @Subdirs = qw/addons apps bridges cdr cel channels codecs formats funcs main pbx res tests utils/;

my @XmlCategories = 'cflags';

# Modules should not bother building (PCRE patterns)
my @ExcludedModules = ();

# Do try building those. Overrides 'exclude' and 'defaultenable: no'
my @IncludedModules = ();

# A chance to rule-out a module randomely.
my $RandomKnockoutFactor = 0;

sub warning($) {
	my $msg = shift;
	print STDERR "$0: Warning: $msg\n";
}

# Convert XML syntax to mail-header-like syntax:
# <var>value</var> --> Var: value
sub extract_xml_key($) {
	my %attr = ();
	my $xml_line = shift;
	if ($xml_line !~ m{^\s*<([a-z_A-Z0-9]+)(\s+([^>]*))?>([^<]*)</\1>}) {
		warning "parsed empty value from XML line $xml_line";
		return ('', ''); # warn?
	}
	my ($var, $val) = ($1, $4);
	$var =~ s{^[a-z]}{\u$&};
	if (defined $3) {
		my $attr_text = $3;
		while ($attr_text =~ /^( *([^=]+)="([^"]+)")/) {
			my ($var, $val) = ($2, $3);
			$attr_text =~ s/^$1//;
			$attr{$var} = $val;
		}
	}
	return ($var, $val, %attr);
}

# Get information embedded in source files from a subdirectory.
# First parameter is the subdirectory and further ones are the actual
# source files.
sub get_subdir_module_info {
	my $subdir = shift;
	my @files = @_;

	my $dir = uc($subdir);

	foreach my $src (@files) {
		open SRC,$src or die "Can't read from source file $src: $!\n";
		$src =~ m|.*/([^/]*)\.c|;
		my $mod_name = $1;
		my %data = (
			Type=>'module', 
			Module=>$mod_name, 
			Dir=> $dir, 
			Avail=>1
		);

		while (<SRC>) {
			next unless (m|^/\*\*\* MODULEINFO| .. m|^ *[*]+/|);
			next unless (m|^[A-Z]| || m|^\s*<|);

			# At this point we can assume we're in the module 
			# info section.
			chomp;
			my ($var, $val, %attr) = extract_xml_key($_);
			foreach (keys %attr) {
				push @{$data{$_}},($attr{$_});
			}
			if ($var =~ /^(Depend|Use)$/i) {
				# use uppercase for dependency names;
				$val = uc($val); 
			}
			if ( ! exists $data{$var} ) {
				$data{$var} = [$val];
			} else {
				push @{$data{$var}},($val);
			}
		}
		close SRC;

		$ModInfo{uc($mod_name)} = \%data;
	}
}

# extract embedded information in all the source tree.
sub extract_subdirs {
	for my $subdir(@_) {
		get_subdir_module_info($subdir, <$subdir/*.c> , <$subdir/*.cc>);
	}
}

# parse a partial XML document that is included as an input 
# for menuselect in a few places. Naturally a full-fledged XML parsing
# will not be done here. A line-based parsing that happens to work will
# have to do.
sub parse_menuselect_xml_file($) {
	my $file_name = shift;
	open XML,$file_name or 
		die "Failed opening XML file $file_name: $!.\n";
	
	my $header = <XML>;
	$header =~ /^\s*<category\s+name="MENUSELECT_([^"]+)"\s/;
	my $category = $1;
	my $member;

	while(<XML>){
		next unless (m{^\s*<(/?[a-z]+)[>\s]});
		my $tag = $1;

		if ($tag eq 'member') {
			if (! m{^\s*<member\s+name="([^"]+)" displayname="([^"]+)"\s*>}){
				warning "Bad XML member line: $_ ($file_name:$.)\n";
				next;
			}
			my ($name, $display_name) = ($1, $2);

			$member = {
				Type => 'XML',
				Dir => $category,
				Module => $1,
				DisplayName => $2,
				Defaultenabled => ['no'],
				Avail => 1, 

			};
		} elsif ($tag eq '/member') {
			$ModInfo{$member->{Module}} = $member;
		} elsif ($tag eq '/category') {
			last;
		} else {
			if (! m/^\s*<([a-z]+)>([^<]+)</) {
				warning "(1) Unknown XML line $_ ($file_name:$.)\n";
				next
			}
			my ($key, $val) = extract_xml_key($_);
			if ($key eq '') {
				warning "Unknown XML line $_ ($file_name:$.)\n";
				next
			}
			if (! exists $member->{$key}) {
				$member->{$key} = [];
			}
			
			# Make sure dependencies are upper-case.
			# FIXME: this is not the proper place for such a fix
			$val = uc($val) if ($key =~ /Depend|Use/);

			# Using "unshift' rather than 'push'.
			# For a singleton value this makes the action an 
			# override, as only the first value counts.
			# For a list value, however, it means a reversed
			# order.
			unshift @{$member->{$key}}, ($val);
		}
	}

	
	close XML;
}

# Dump our data structure to a file.
sub dump_deps($) {
	my $file = shift;
	open OUTPUT,">$file" or 
	die "cannot open category file $file for writing: $!\n";

	foreach my $mod_name (sort keys %ModInfo) { 
	print OUTPUT "Key: $mod_name\n";
		my $data = $ModInfo{$mod_name};
		foreach my $var (sort keys %{$data} ) {
			my $val = $$data{$var};
			if (ref($val) eq 'ARRAY') {
				print OUTPUT $var.": ". (join ", ", @$val)."\n";
			} else {
				print OUTPUT "$var: $val\n";
			}
		}
		print OUTPUT "\n";
	}
	close OUTPUT;
}

# Get the available libraries that autoconf generated.
sub get_autoconf_deps() {
	open DEPS, $AutoconfDepsFile or
		die "Failed to open $AutoconfDepsFile. Aborting: $!\n";

	my @deps_list = (<DEPS>);
	foreach (@deps_list){
		chomp;
		my ($lib, $avail_val) = split(/=/);
		my ($avail, $avail_old) = split(/:/, $avail_val);
		my $disabled = 0;
		if ($avail == -1) { 
			$disabled = 1;
			$avail = 0;
		}
		$ModInfo{$lib} = {
			Type=>'lib', Avail=>$avail, Disabled => $disabled
		};
		if (defined $avail_old) {
			$ModInfo{$lib}{AvailOld} = $avail_old;
		}
		# FIXME: 
		if (($avail ne "0") && ($avail ne "1")) {
			warning "Library $lib has invalid availability ".
				"value <$avail> (check $AutoconfDepsFile).\n";
		}
	}
	close DEPS;
}

# Get the available libraries that autoconf generated.
sub get_autoconf_opts() {
	open OPTS, $AutoconfOptsFile or
		die "Failed to open $AutoconfOptsFile. Aborting: $!\n";

	while (<OPTS>) {
		chomp;
		next if /^(#|$)/;
		my ($var, $val) = split /\s*=\s*/, $_, 2;
		$ConfigureOpts{$var} = $val;
	}
	close OPTS;
	if (not exists $ConfigureOpts{AST_DEVMODE}) {
		$ConfigureOpts{AST_DEVMODE} = 'no';
	}
}

# Read our specific config file.
#
# Its format:
#
#   keyword  values
#
# values are always a spaces-separated list.
sub read_conf() {
	open CONF,$ConfFile or return;

	while (<CONF>) {
		# remove comments and empty lines:
		chomp;
		s/#.*$//;
		next if /^\s*$/;

		my ($keyword, @value) = split;

		if ($keyword eq 'exclude') {
			push @ExcludedModules, @value;
		} elsif ($keyword eq 'include') {
			push @IncludedModules, @value;
		} elsif ($keyword eq 'require') {
			push @RequiredModules, @value;
		} elsif ($keyword eq 'random') {
			$RandomKnockoutFactor = $value[0] / 100;
		} else {
			warning "unknown keyword $keyword in line $. of $ConfFile.";
		}
	}
}

# generate menuselect.makedeps.
# In this file menuselect writes dependecies of each module. CFLAGS will
# then automatically include for each module the _INCLUDE and LDFLAGS
# will include the _LIBS from all the depedencies of the module.
sub gen_makedeps() {
	open MAKEDEPSS, ">$MakedepsFile" or
		die "Failed to open deps file $MakedepsFile for writing. Aborting: $!\n";

	for my $mod_name (sort keys %ModInfo) {
		next unless ($ModInfo{$mod_name}{Type} eq 'module');

		my $mod = $ModInfo{$mod_name};
		my @deps = ();

		# if we have Depend or Use, put their values into 
		# @deps . If we have none, move on.
		push @deps, @{$mod->{Depend}} if (exists $mod->{Depend});
		push @deps, @{$mod->{Use}}    if (exists $mod->{Use});
		next unless @deps; 

		# TODO: don't print dependencies that are not external libs. 
		# Not done yet until I figure out if this is safe.
		my $dep = join(' ', @deps);
		print MAKEDEPSS "MENUSELECT_DEPENDS_".$mod->{Module}."=$dep\n";
	}

	close MAKEDEPSS;
}

# Set modules from patterns specified by 'exclude' in the configuration file
# to exclude modules from building (mark them as unavailable).
sub apply_excluded_patterns() {
	foreach my $pattern (@ExcludedModules) {
		my @excluded = grep {/^$pattern$/i} (keys %ModInfo);
		foreach (@excluded) {
			$ModInfo{$_}{Avail} = 0;
		}
	}
}

# Set modules from patterns specified by 'include' in the configuration
# file to exclude from building (mark them as available).
sub apply_included_patterns() {
	foreach my $pattern (@IncludedModules) {
		my @included = grep {/^$pattern$/i} (keys %ModInfo);
		foreach (@included) {
			$ModInfo{$_}{Avail} = 1;
		}
	}
}

# If user set the "random" config to anything > 0, drop some random
# modules. May help expose wrong dependencies.
sub apply_random_drop() {
	return if ($RandomKnockoutFactor <= 0);

	open MODS_LIST, ">$RandomeModsFile" or
		die "Failed to open modules list file $RandomeModsFile for writing. Aborting: $!\n";
	for my $mod (keys %ModInfo) {
		next unless ($ModInfo{$mod}{Type} eq 'module');
		next unless (rand() < $RandomKnockoutFactor);
		$ModInfo{$mod}{Avail} = 0;
		$ModInfo{$mod}{RandomKill} = 1;
		print MODS_LIST $ModInfo{$mod}{Module}."\n";
	}

	close MODS_LIST;
	

}

sub check_required_patterns() {
	my @failed = ();
	foreach my $pattern (@RequiredModules) {
		my @required = grep {/^$pattern$/i} (keys %ModInfo);
		foreach my $mod (@required) {
			if ((! exists $ModInfo{$mod}{Checked}) ||
				(! $ModInfo{$mod}{Checked}) )
			{
				push @failed, $mod;
			}
		}
	}
	return unless (@failed);

	my $failed_str = join ' ',@failed;
	die("Missing dependencies for the following modules: $failed_str\n");
}

# Disable building for modules that were marked in the embedded module 
# information as disabled for building by default.
sub apply_default_enabled() {
	foreach my $mod (keys %ModInfo) {
		if ((exists $ModInfo{$mod}{Defaultenabled}) &&
				$ModInfo{$mod}{Defaultenabled}[0] eq 'no')
		{
			$ModInfo{$mod}{Avail} = 0;
		}
	}
}

# We found a dependency we don't know about. Warn the user, and add
# information about it:
sub handle_unknown_dep($$) {
	my ($dep_mod, $mod) = @_;

	my $mod_info = {
		Type => 'Unknown',
		Avail => 0,
		Checked => 0,
	};
	$ModInfo{$dep_mod} = $mod_info;

	warning "Unknown dependency module $dep_mod (for e.g. $mod)\n";
}

# recursively check dependency for a module.
#
# We run a scan for modules. Modules marked as 'Checked' are ones we
# have already fully verified to have proper dependencies.
#
# We can only use a module or library marked as Avail => 1 (library
# available or module not excluded).
sub check_module($);
sub check_module($) {
	my $mod = shift;

	# we checked it:
	if (exists $ModInfo{$mod}{Checked}) {
		return $ModInfo{$mod}{Checked};
	}
	# A library has no dependencies of its own.
	if ($ModInfo{$mod}{Type} eq 'lib') {
		return ($ModInfo{$mod}{Avail} || 0);
	}
	# An excluded module.
	if ($ModInfo{$mod}{Avail} == 0) {
		return 0;
	}
	if (! exists $ModInfo{$mod}{Depend}) {
		$ModInfo{$mod}{Checked} = 1;
		return 1;
	}

	my $deps_checked = 1; # may be reset below on failures:

	if (exists $ModInfo{$mod}{Tested}) {
		# this probably means a circular dependency of some sort.
		warning "Got to module $mod that is already tested.";
	}
	$ModInfo{$mod}{Tested} = 1;

	foreach my $dep_mod (@{$ModInfo{$mod}{Depend}} ) {
		if (!exists ${ModInfo}{$dep_mod}) {
			handle_unknown_dep($dep_mod, $mod);
			return 0;
		}
		$deps_checked &= check_module($dep_mod);
		last if(!$deps_checked) # no point testing further if we failed.
	}

	$ModInfo{$mod}{Checked} = $deps_checked;
	return $deps_checked;
}

# The main dependency resolver function.
sub resolve_deps() {
	apply_default_enabled();
	apply_excluded_patterns();
	apply_included_patterns();

	foreach my $mod (keys %ModInfo) {
		check_module($mod);
	}
}

# generate menuselect.makeopts. 
# The values in this file obey to different semantics:
# 1. For modules, a module will be built unles listed here
# 2. For XML values (sounds, CFLAGS) it will be enabled if listed here
sub gen_makeopts() {
	open MAKEDEPS, ">$MakeoptsFile" or
		die "Failed to open opts file $MakeoptsFile for writing. Aborting: $!\n";

	my %Subdirs;
	foreach my $mod (sort keys %ModInfo) {
		next unless ($ModInfo{$mod}{Type} =~ /^(module|XML)$/);
		if ($ModInfo{$mod}{Type} eq 'XML') {
			next unless ($ModInfo{$mod}{Checked});
		} else {
			next if ($ModInfo{$mod}{Checked});
		}
		my $dir = $ModInfo{$mod}{Dir};
		if (! exists $Subdirs{$dir}) {
			$Subdirs{$dir} = [];
		}
		push @{$Subdirs{$dir}},( $ModInfo{$mod}{Module} );
	}
	foreach my $dir (sort keys %Subdirs) {
		my $deps = join(' ', @{$Subdirs{$dir}});
		print MAKEDEPS "MENUSELECT_$dir=$deps\n";
	}

	close MAKEDEPS;
}

# Main function for --check-deps
sub check_dependencies() {
	read_conf();

	extract_subdirs(@Subdirs);

	get_autoconf_opts();

	parse_menuselect_xml_file('build_tools/cflags.xml');
	if ($ConfigureOpts{AST_DEVMODE} eq 'yes') {
		parse_menuselect_xml_file('build_tools/cflags-devmode.xml');
	} 
	parse_menuselect_xml_file('sounds/sounds.xml');

	apply_random_drop();

	get_autoconf_deps();

	#dump_deps('build_tools/dump_deps_before_resolve');
	resolve_deps();

	# Handy debugging:
	dump_deps($DumpFile);

	check_required_patterns();

	gen_makedeps();

	gen_makeopts();
}

# 
# The main program start here
#

sub read_dump() {
	my %items = ();
	my $saved_rs = $/;
	$/ = "\n\n";
	open DUMP_FILE,$DumpFile or die "Can't read from dump file $DumpFile\n";
	while (<DUMP_FILE>) {
		my %item = ();
		my @item_lines = split /\n\r?/;
		foreach (@item_lines) {
			my ($var, $value) = split /: /, $_, 2;
			$item{$var} = $value;
		}
		# FIXME: dependencies are a list. This should not be a 
		# special case.
		if (exists $item{Depend}) {
			$item{Depend} = [split /\s*,\s*/,$item{Depend}];
		}
		$items{$item{Key}} = \%item;
	}
	close DUMP_FILE;
	$/ = $saved_rs;
	return \%items;
}

# Explain why a module (read from the dump file) was not enabled.
# (We assume here that $item->{Avail} is 0)
sub fail_reason($) {
	my $item = shift;
	if ($item->{Type} eq 'lib') {
		return " Not found: system library";
	} elsif ($item->{Type} eq 'XML') {
		if ($item->{Defaultenabled} !~ /^y/) {
			return "Not enabled";
		} else {
			return "Missing dependencies";
		}
	} elsif ($item->{Type} eq 'module') {
		if (exists ($item->{Defaultenabled}) && 
			$item->{Defaultenabled} =~ /^n/) {
			return "Disabled";
		} else {
			return "Missing dependencies";
		}
	}
}

sub item_used($) {
	my $item = shift;
	my $type = $item->{Type};

	return $item->{Avail} if ($type eq 'lib');
	return $item->{Checked};
}

sub print_module_status {
	my $flag_verbose = shift;
	my $items = read_dump();
	my %items_matched = ();

	foreach my $pattern (@_) {
		foreach (keys %$items) {
			if (/$pattern/i) {
				$items_matched{$_} = 1;
			}
		}
	}

	my @items_list = sort keys %items_matched;

	foreach my $item_name (@items_list) {
		my $item = $items->{$item_name};
		if ($flag_verbose) {
			printf "%s %-8s %-30s\n",
				(item_used($item)? 'Y':'n'),
				$item->{Type},
				$item->{Key};
			if (!$item->{Avail}) {
				my $reason = fail_reason($item);
				print " $reason\n";
			}
			foreach (@{$item->{Depend}}) {
				my $depmod = $items->{$_};
					printf(" * %-12s ",$_);
					print (item_used($depmod)? '': "un");
					print "available\n";
			}
		} else {
			printf "%s %-8s %-30s",
				(item_used($item)? 'Y':'n'),
				$item->{Type},
				$item->{Key};
			foreach (@{$item->{Depend}}) {
				my $depmod = $items->{$_};
				if (item_used($depmod)) {
					print "$_ ";
				} else {
					printf "[%s] ", $_;
				}
			}
			print "\n";
		}
	}
}

sub usage() {
	print "$0: menuselect reimplementation\n";
	print "\n";
	print "Usage:\n";
	print "$0  # menuselect processing\n";
	print "$0 -m|--modinfo|--moduls-info PATTERN # Status of modules\n";
	print "$0 -v|--verbose                       # verbose (modinfo)\n";
	print "$0 -c|--check-deps                    # Check for dependencies\n";
	print "\n";
	print "PATTERN is a partial perl regex. Use '-m .' to list all.\n";
}

my @module_status = ();

my $flag_verbose = 0;

my $action = '';

my $rc = GetOptions(
	'modinfo|modules-info|m=s' => \@module_status,
	'verbose|v' => \$flag_verbose,
	'check-deps|c:s' => sub { $action = 'check_dependencies'},
	'help|h' => sub { usage(); exit 0 },
);
if (!$rc) {
	usage();
	exit $rc;
}

if (@module_status) {
	$action = 'module_status';
}

if ($action eq 'module_status') {
	print_module_status($flag_verbose, @module_status);
	exit 0;
} elsif ( $action eq 'check_dependencies') {
	check_dependencies();
} else {
	usage(); exit(1);
}