--- /dev/null
+#!/usr/bin/perl
+# Name : euse
+# Purpose : Command line USE flag editor
+# Author : Arun Bhanu
+# Version : 0.1.0
+# Copyright : GNU GPL v2
+
+use warnings;
+use strict;
+
+use Getopt::Long;
+use File::Copy;
+use Env qw(USE);
+
+# Define constants
+use constant FLAG_TYPE=>['G', 'L'];
+use constant FLAG_MASK=>['+', '-', 'M'];
+use constant FLAG_SITE=>['E', 'C', 'A', 'D', ' '];
+use constant SITE_DESC=>['environment', 'make.conf', 'auto', 'make.defaults'];
+
+# parse_wo_args & parse_with_args populate command line arguments into
+# these. The argument and variable names has to match because we make use
+# of symbolic references. Yeah, I know these are not good names.
+our $h = 0; # -h|help, boolean
+our $v = 0; # -v|version, boolean
+our $c = 0; # -c|conf, boolean
+our $d = 0; # -d|defaults, boolean
+our $e = 0; # -e|env, boolean
+our @i = (); # -i|info, info accepts many optional values.
+our @p = (); # -p|package argument, package accepts many values.
+our @E = (); # -E|enable, enable use flags in make.conf
+our @D = (); # -D|disable, disable use flags in make.conf. Not a physical
+ # delete, but just minus sign in front of the given use flag.
+
+# arguments that does not take values.
+our $Args_Wo_Param = "hvcde";
+our $Non_Arg = " ";
+our $Curr_Arg; # Argument being parsed.
+our %Unknown_Args; # All unknown arguments are populate here.
+
+our %Uf_warnings;
+
+our $Version = "0.1.0";
+
+# Paths to all the reqd files
+our $FMake_conf = "/etc/make.conf";
+our $FMake_defaults = "/etc/make.profile/make.defaults";
+our $FUse_desc = "/etc/make.profile/../use.desc";
+our $FUse_local = "/etc/make.profile/../use.local.desc";
+our $FUse_mask = "/etc/make.profile/use.mask";
+
+# For my local testing
+#our $FMake_conf = "make.conf"; #/etc/make.conf
+#our $FMake_defaults = "make.defaults"; #/etc/make.profile/make.defaults
+#our $FUse_desc = "use.desc"; #$PORTDIR/profiles/use.desc
+#our $FUse_local = "use.local.desc";#$PORTDIR/profiles/use.local.desc
+#our $FUse_mask = "use.mask";#/etc/make.profile/use.mask
+
+#BEGIN Main
+MAIN: {
+ Getopt::Long::Configure("no_ignore_case");
+ # help, version does not accept arguments
+ # info accepts optional agruments.
+ # package requires arguments.
+ GetOptions(
+ "h|help" => \&parse_wo_args, # Show usage info.
+
+ "v|version" => \&parse_wo_args, # Show version info.
+
+ "i|info:s" => \&parse_with_args, # Show use flags info.
+ # Show all use flags if none
+ # specified. (Optional values)
+
+ #"p|package:s" => \&parse_with_args, # Show use flag info for all
+ # given packages (Mandatory values)
+
+ "E|enable:s" => \&parse_with_args, # enable use flag from make.conf
+ # e.g. mozilla
+
+ "D|disable:s" => \&parse_with_args, # disable use flag from make.conf
+ # e.g. -mozilla.
+
+ "c|conf" => \&parse_wo_args, # print the contents of make.conf
+ # use flag setting
+
+ "d|defaults" => \&parse_wo_args, # print the contents of
+ # make.defaults use flag setting
+
+ "e|env" => \&parse_wo_args, # print the contents of
+ # environment use flag setting
+
+ "<>" => \&handle_unknown # all unknown arguments.
+ ) or usage();
+
+
+ # If no options are entered show usage.
+ if ((my $opts = $h +
+ $v +
+ ($c or $d or $e) +
+ defined(@i) +
+ defined(@p) +
+ (defined(@E) or defined(@D))) < 1) {
+ usage();
+ }
+
+ # If any arguments are provided for options which are boolean show usage.
+ if (%Unknown_Args) {
+ print ("Unknown arguments: \n");
+ foreach (sort keys %Unknown_Args) {
+ print "\t$_ => " . join (" ", @{$Unknown_Args{$_}}) . "\n";
+ }
+ usage();
+ }
+
+ # Only one of -h, -v, -i, -p, -c/-d/-e or -E/-D allowed
+ if ((my $opts = $h +
+ $v +
+ ($c or $d or $e) +
+ defined(@i) +
+ defined(@p) +
+ (defined(@E) or defined(@D))) > 1) {
+ usage("Only one of -h, -v, -i, -p or -E/-D allowed");
+ }
+
+ # Mandatory argument field check if arguments have been entered
+ my @reqd_args = ();
+ if (defined(@E)) {
+ if ($E[0] eq '') {
+ push @reqd_args, "-E";
+ }
+ }
+ if (defined(@D)) {
+ if ($D[0] eq '') {
+ push @reqd_args, "-D";
+ }
+ }
+ if ($#reqd_args >= 0) {
+ print join(", ", @reqd_args), " require argument(s). \n";
+ usage();
+ }
+
+ # If -h,--help is entered show usage.
+ if ($h) {
+ #check_permissions("rw"); #just for testing purposes
+ usage();
+ }
+
+ # If -v,--version is entered show version.
+ if ($v) {
+ version();
+ }
+
+ if ($c || $d || $e) {
+ #Check the permissions for all the reqd files and sets their path
+ #If not enough permission don't proceed.
+ check_permissions("r");
+ if ($d) {
+ my $defaults_uf_list_ref = parse_make($FMake_defaults);
+ print "USE setting in make.defaults: \n";
+ print (join (" ", @$defaults_uf_list_ref) . "\n\n");
+ }
+
+ if ($c) {
+ my $conf_uf_list_ref = parse_make($FMake_conf);
+ print "USE setting in make.conf: \n";
+ print (join (" ", @$conf_uf_list_ref) . "\n\n");
+ }
+
+ if ($e) {
+ my $env_uf_list_ref = parse_env($USE);
+ print "USE setting in environment: \n";
+ print (join (" ", @$env_uf_list_ref) . "\n\n");
+ }
+ exit(0);
+ }
+
+ check_permissions("r");
+
+ # Read /usr/portage/profiles/use.desc
+ my %use_flags;
+ parse_use($FUse_desc, \%use_flags);
+
+ # Read /usr/portage/profiles/use.local.desc
+ parse_use_local($FUse_local, \%use_flags);
+
+ # Read /etc/make.profile/use.mask, if exists.
+ parse_use_mask($FUse_mask, \%use_flags) if (-e $FUse_mask);
+
+ # If a -* is found in env, make.conf & make.defaults is skipped.
+ # If a -* is found in make.conf, make.defaults is skipped.
+ # If a -* is found in all the elements in front of -* is skipped.
+ # In each of the case all the elements in front of -* is also skipped.
+ # Read ENV{USE}
+ my (@env_uf_list, @conf_uf_list, @defaults_uf_list) = ();
+ my $env_uf_list_ref = \@env_uf_list;
+ my $conf_uf_list_ref = \@conf_uf_list;
+ my $defaults_uf_list_ref = \@defaults_uf_list;
+
+ $env_uf_list_ref = parse_env($USE) if (defined($USE));
+ unless (is_all_disabled($env_uf_list_ref)) {
+ # Read /etc/make.conf
+ $conf_uf_list_ref = parse_make($FMake_conf);
+
+ unless (is_all_disabled($conf_uf_list_ref)) {
+ # Read /etc/make.profile/make.defaults
+ $defaults_uf_list_ref = parse_make($FMake_defaults);
+ }
+ }
+
+ # is this the correct way of check the length of an array reference??
+ parse_use_flag($defaults_uf_list_ref, \%use_flags, 3)
+ unless ($#{@$defaults_uf_list_ref} < 0);
+ parse_use_flag($conf_uf_list_ref, \%use_flags, 1)
+ unless ($#{@$conf_uf_list_ref} < 0);
+ parse_use_flag($env_uf_list_ref, \%use_flags, 0)
+ unless ($#{@$env_uf_list_ref} < 0);
+
+
+ # If -i, --info is entered print all USE flags if no arguments given or
+ # print the description for the given USE flags.
+ if (defined(@i)) {
+
+ #if -i mozilla mozilla is entered the extra mozilla is removed.
+ remove_duplicates(\@i);
+
+ my @use_flag_list = ();
+ my $max_len = 0;
+ my $curr_key_len = 0;
+
+ # Retrieve the objects to be send to the formatting function as an
+ # array.
+ if ($i[0] eq '') {
+ #Display all USE flags
+ foreach (sort keys %use_flags) {
+ $curr_key_len = length($_);
+ $max_len = $curr_key_len if $curr_key_len > $max_len;
+ push @use_flag_list, $use_flags{$_};
+ }
+ }
+ else {
+ #Display USE flags for given arguments
+ foreach (sort @i) {
+ if (exists($use_flags{$_})) {
+ $curr_key_len = length($_);
+ $max_len = $curr_key_len if $curr_key_len > $max_len;
+ push @use_flag_list, $use_flags{$_} ;
+ }
+ else {
+ # Invalid use flag
+ add_warning($_, "Querying an invalid use flag.");
+ }
+ }
+ }
+
+ format_output(\@use_flag_list, \$max_len);
+ format_warning();
+ exit(0);
+ }
+
+ # Enable USE flags and disable USE flags
+ if (defined(@E) || defined(@D)) {
+
+ check_permissions("rw");
+
+ # Enable the last occurence of the USE flag. Check if already exists
+ # in make.conf. If exist and enabled leave it alone. If exists and
+ # disabled enable it. If not found, put an entry at the end. Why end?
+ # -* may be in effect somewhere in the USE flag. So adding in at the
+ # end will make sure it gets enabled. euse -E "*" or euse -E all will
+ # look for a -* in make.conf. If found removes it.
+ if (defined(@E)) {
+ remove_duplicates(\@E);
+ rearrange_args(\@E);
+ enable_use_flag($conf_uf_list_ref, \%use_flags);
+ }
+
+ # Disable the last occurence of the USE flag.
+ # euse -D "*" will put a -* at the end of USE flag setting in make.conf.
+ if (defined(@D)) {
+ remove_duplicates(\@D);
+ rearrange_args(\@D);
+ disable_use_flag($conf_uf_list_ref, \%use_flags);
+ }
+ format_warning();
+ exit(0);
+ }
+ exit(0);
+}
+#END Main
+
+# Show usage. Accepts optional argument. If given prints them as warning msg.
+sub usage {
+ warn "@_\n" if @_;
+ die <<EOF;
+'*' leading an option indicates not-yet-implemented
+Usage:
+ -h, --help - print this message
+ -v, --version - print version information
+ -i, --info - print USE flag information for the the given USE flags.
+ Optional argument.
+ -c, --conf - print USE flag setting in make.conf
+ -d, --defaults - print USE flag setting in make.defaults
+ -e, --env - print USE flag setting in environment variable USE
+ *-p, --package - requires a package name to be given for which you
+ want to see USE flags.
+ -E, --enable - enable use flag to make.conf e.g. -E mozilla puts mozilla
+ in make.conf. Mandatory argument.
+ -D, --disable - disable use flag from make.conf e.g. -D mozilla
+ puts -mozilla in make.conf. Mandatory argument.
+
+Please see the README file for more details.
+
+EOF
+
+}
+
+# Show version
+sub version
+{
+ die <<EOF;
+EUSE version $Version
+Copyright (C) 2003 - Arun Bhanu
+This program may be freely distributed under the terms of the GNU GPL v2.
+
+EOF
+
+}
+
+# check permissions for all reqd files
+sub check_permissions
+{
+ my ($r, $w) = split(//, shift());
+
+ #make.conf requires rw permissions. all the other files require read
+ #permission
+ my $errors = "";
+
+ # for make.conf
+ if ((defined($r) && $r eq "r") && (defined($w) && $w eq "w")) {
+ #print "rw defined \n";
+ unless (-e $FMake_conf && -r _ && -w _) {
+ $errors .= "requires read,write permissions for $FMake_conf. \n";
+ }
+ }
+ elsif (defined($r) && $r eq "r") {
+ #print "r defined \n";
+ unless (-e $FMake_conf && -r _) {
+ $errors .= "requires read,write permissions for $FMake_conf. \n";
+ }
+ }
+
+ # for all the other files
+ if (defined($r) && $r eq "r") {
+ #print "r defined \n";
+ unless (-e $FMake_defaults && -r _) {
+ $errors .= "requires read permissions for $FMake_defaults. \n";
+ }
+ unless (-e $FUse_desc && -r _) {
+ $errors .= "requires read permissions for $FUse_desc. \n";
+ }
+
+ unless (-e $FUse_local && -r _) {
+ $errors .= "requires read permissions for $FUse_local. \n";
+ }
+
+ if (-e $FUse_mask) {
+ unless (-r $FUse_mask) {
+ $errors .= "requires read permissions for $FUse_mask. \n";
+ }
+ }
+ }
+
+ die "EUSE exiting with following errors: \n$errors" unless ($errors eq "");
+}
+
+# clean up reqd
+sub handle_unknown
+{
+ no strict 'refs';
+ if (defined $Curr_Arg) {
+ my $option = $Curr_Arg;
+ if ($option =~ /[$Args_Wo_Param]/) {
+ #print "param not required \n";
+ #print "Option: $option " . join (",", @_) . "\n";
+ push @{$Unknown_Args{$option}}, @_;
+ }
+ else {
+ #print "param is okay \n";
+ push @$option, @_;
+ }
+ }
+ else {
+ #print "curr flag not defined \n";
+ push @{$Unknown_Args{$Non_Arg}}, @_;
+ }
+}
+
+sub parse_with_args
+{
+ no strict 'refs';
+ my ($option, $value) = @_;
+ #print "parse with handle: " . $option . " " . $value . "\n";
+
+ push @$option, $value; #do not allow comma separated.
+ $Curr_Arg = $option;
+
+}
+
+sub parse_wo_args
+{
+ no strict 'refs';
+ my ($option, $value) = @_;
+ #print "parse wo handle: " . $option . " " . $value . "\n";
+ $$option = $value;
+ $Curr_Arg = $option;
+}
+
+# Generic subroutine to read a file.
+# Returns an array of lines in array context or returns the whole file in a
+# single scalar in scalar context.
+sub read_file {
+ my $file_name = shift();
+ if (open FILE, $file_name) {
+ local $/ = undef unless wantarray;
+ return <FILE>;
+ }
+ else {
+ die "Couldn't read file $file_name. $! \n";
+ }
+ #return; # returns undef in scalar context, () in list context
+}
+
+sub parse_use
+{
+ my $file_name = shift();
+ my $use_flags_ref = shift();
+ my @lines = read_file($file_name);
+ chomp @lines;
+ foreach (@lines) {
+ if (/^\s*([-a-z0-9_+]+)\s+-\s*(.*)$/i) {
+ $use_flags_ref->{$1} = create_use_flag($1, $2, FLAG_TYPE->[0]);
+ }
+ }
+}
+
+sub parse_use_local
+{
+ my $file_name = shift();
+ my $use_flags_ref = shift();
+ my @lines = read_file($file_name);
+ chomp @lines;
+ foreach (@lines) {
+ if (m{^\s*([-a-z0-9_/+]*):([-a-z0-9_/+]*)\s*-\s*(.*)$}i)
+ {
+ my $pkg_name = $1;
+ my $use_flag = $2;
+ my $use_desc = $3;
+ $use_flags_ref->{$use_flag} =
+ create_use_flag($use_flag, $use_desc, FLAG_TYPE->[1],
+ FLAG_MASK->[1], $pkg_name);
+ }
+ }
+}
+
+sub parse_use_mask
+{
+
+ my $file_name = shift();
+ my $use_flags_ref = shift();
+ my @lines = read_file($file_name);
+ chomp @lines;
+ my @use_mask;
+ foreach (@lines) {
+ if (m/^\s*([-a-z0-9_+]+)\s*$/i)
+ {
+ my $use_flag = $1;
+ if (exists $use_flags_ref->{$use_flag}) {
+ $use_flags_ref->{$use_flag}->[3] = FLAG_MASK->[2];
+ }
+ else {
+ add_warning($use_flag, "Found in use.mask, but is not a valid use flag.");
+ }
+ }
+ }
+
+
+ #return \@use_mask;
+}
+
+sub add_warning
+{
+ my $use_flag = shift();
+ my $msg = shift();
+ if (exists $Uf_warnings{$use_flag}) {
+ push @{$Uf_warnings{$use_flag}}, $msg;
+
+ }
+ else {
+ my @warn_list = ($msg);
+ $Uf_warnings{$use_flag} = \@warn_list;
+ }
+}
+
+sub parse_make
+{
+ my $file_name = shift();
+ my $lines = read_file($file_name);
+ my @site_uf_list;
+ if ($lines =~ m/^\s*USE[\s\n]*=[\s\n]*"([^"]*)"/ms)
+ {
+ my $use_var = $1;
+ $use_var =~ s/[\r\n]/ /g;
+ @site_uf_list = split(' ', $use_var);
+ }
+ #print ("Make: \n" . join (" ", @site_uf_list) . "\n");
+ return \@site_uf_list;
+}
+
+sub parse_env
+{
+ my $env = shift();
+ $env = "" unless (defined($env));
+ #print "USE: $env \n";
+ my @site_uf_list = split(' ', $env);
+ #print ("Env: " . join (" ", @site_uf_list) . "\n");
+ return \@site_uf_list;
+}
+
+sub parse_use_flag
+{
+ my $site_uf_list_ref = shift();
+ my $use_flags_ref = shift();
+ my $site_index = shift();
+
+ #print "Flag site: $site_index -> " . FLAG_SITE->[$site_index] . "\n";
+ #print "Flag desc: $site_index -> " . SITE_DESC->[$site_index] . "\n";
+ my ($isenabled, $use_wo_sign, $use_with_sign);
+ # recurse from back to front. if -* is found the rest of the elements in
+ # front is ignored.
+ for (my $i = $#{@$site_uf_list_ref}; $i >= 0; $i--) {
+ my $curr_flag = $site_uf_list_ref->[$i];
+ #print "curr flag: $curr_flag \n";
+ last if ($curr_flag =~ m/^-\*$/);
+ $isenabled = 1; # sign = 1 is enabled, sign = 0 is disabled.
+ $use_wo_sign = $use_with_sign = $curr_flag;
+ if ($use_with_sign =~ /^-(.*)/) {
+ $use_wo_sign = $1;
+ $isenabled = 0;
+ }
+
+ if (exists $use_flags_ref->{$use_wo_sign}) {
+ $use_flags_ref->{$use_wo_sign}->[5] = FLAG_SITE->[$site_index];
+ if ($use_flags_ref->{$use_wo_sign}->[3] eq FLAG_MASK->[2]) {
+ add_warning($use_wo_sign, "$use_with_sign found in " .
+ SITE_DESC->[$site_index] . " is masked. You shouldn't be " .
+ "setting this use flag.");
+ }
+ #if ($use_flags_ref->{$use_wo_sign}->[3] eq FLAG_MASK->[3] ) {
+ # add_warning($use_wo_sign, "$use_with_sign found in " .
+ # SITE_DESC->[$site_index] . " is an internal flag. You " .
+ # "shouldn't be setting this use flag.");
+ #}
+ if ($isenabled) {
+ $use_flags_ref->{$use_wo_sign}->[3] = FLAG_MASK->[0];
+ }
+ else {
+ $use_flags_ref->{$use_wo_sign}->[3] = FLAG_MASK->[1];
+ }
+
+ }
+ else {
+ add_warning($use_wo_sign, "$use_with_sign found in " .
+ SITE_DESC->[$site_index] . " not a valid use flag.");
+ }
+ }
+}
+
+# checks if -* is found in any given site - environment, make.conf,
+# make.defaults
+# Return 1 if -* is found, return 0 otherwise.
+sub is_all_disabled
+{
+ my $site_uf_list_ref = shift();
+ #print (join (" ", @$site_uf_list_ref) . "\n");
+ foreach (@$site_uf_list_ref) {
+ return 1 if (m/^-\*$/);
+ }
+ return 0;
+}
+
+sub enable_use_flag
+{
+ my $conf_uf_list_ref = shift();
+ my $use_flags_ref = shift();
+ # if -* is found in env, should we enable the flag in environment instead
+ # of make.conf
+ #print "Enabling in make.conf... \n";
+ my @add_flags;
+ my @del_flags;
+ my $enable_all = 0;
+ #my $disable_start = 0;
+ my $disable_found = 0;
+ EFLAG: foreach my $eflag (@E) {
+ if ($eflag eq "*" or $eflag eq "all") {
+ #print "$eflag need to del -* use flag.. \n";
+ $enable_all = 1;
+ $eflag = "*";
+ push @del_flags, $eflag;
+ foreach my $cflag (@$conf_uf_list_ref) {
+ if ($cflag eq "-*") {
+ $disable_found = 1;
+ last;
+ }
+ }
+ next EFLAG;
+ }
+ if (exists $use_flags_ref->{$eflag}) {
+ if ($use_flags_ref->{$eflag}->[3] eq FLAG_MASK->[2]) {
+ add_warning($eflag, "$eflag is masked. Enabling a masked " .
+ "flag.");
+ next EFLAG;
+ }
+ my $count = 0;
+ for (my $i = $#{@$conf_uf_list_ref}; $i >= 0; $i--) {
+ my $curr_flag = $conf_uf_list_ref->[$i];
+ #print "curr flag: $curr_flag eflag: $eflag \n";
+
+ if ($curr_flag eq $eflag) {
+ #print "flag exists.. \n";
+ next EFLAG;
+ }
+
+ my $eflag_sign = "-".$eflag;
+ if ($curr_flag eq $eflag_sign) {
+ #print "need to del use flag.. \n";
+ push @del_flags, $eflag;
+ next EFLAG;
+ }
+
+ if ($curr_flag eq "-*") {
+ $count++;
+ if ($enable_all) {
+ if ($disable_found && ($count == 1)) {
+ next;
+ }
+ else {
+ push @add_flags, $eflag;
+ next EFLAG;
+ }
+ }
+ else {
+ push @add_flags, $eflag;
+ next EFLAG;
+ }
+
+ }
+ }
+ #print "$eflag - need to enable this flag...\n";
+ push @add_flags, $eflag;
+ }
+ else {
+ add_warning($eflag, "Enabling invalid use flag.");
+ }
+ }
+
+ # should I use timestamp instead of .old suffix?
+ if (@add_flags || @del_flags) {
+
+ my $make_conf = read_file($FMake_conf);
+ #my $timestamp = get_timestamp();
+ #copy ($FMake_conf, "$FMake_conf.$timestamp");
+ copy ($FMake_conf, "$FMake_conf.bkeuse");
+ if (@add_flags) {
+ #print "these are flags to add...\n";
+ my $eflags = join (" ", @add_flags);
+ #print ($eflags . "\n");
+ $make_conf =~
+ s/(^\s*USE[\s\n]*=[\s\n]*")([^"]*)(")/$1$2 $eflags$3/ms;
+
+ # If there is no USE flag setting in make.conf include it and
+ # add the flags.
+ unless (defined($1)) {
+ #print "There are flags to add but no USE setting \n";
+ $make_conf =~ s/(^\s*#\s*Host)/USE="$eflags"\n$1/ms;
+ }
+ }
+
+ my $use_setting = "";
+ if (@del_flags) {
+ #print "these are flags to del...\n";
+ my $dflags = join (" ", @del_flags);
+ #print ($dflags . "\n");
+
+ if ($make_conf =~ /^\s*USE[\s\n]*=[\s\n]*"([^"]*)"/ms) {
+ $use_setting = $1;
+ }
+ foreach my $dflag (@del_flags) {
+ if ($dflag eq "*") {
+ $use_setting =~ s/^(.*)-\*(.*)$/$1$2/ms;
+ }
+ else {
+ # \Q, \E prevents flags like libg++ to bonk
+ $use_setting =~ s/^(.*)(-\Q$dflag\E)(.*)$/$1$dflag$3/ms;
+ }
+ }
+ $make_conf =~
+ s/(^\s*USE[\s\n]*=[\s\n]*")([^"]*)(")/$1$use_setting$3/ms;
+ }
+ open(OUTFILE, ">$FMake_conf") or
+ die("couldn't open make.conf");
+ print OUTFILE $make_conf;
+ close OUTFILE;
+ }
+ print "USE setting in make.conf after enabling: \n";
+ my $make_conf = read_file($FMake_conf);
+ my $use_setting = "";
+ $make_conf =~ /^\s*USE[\s\n]*=[\s\n]*"([^"]*)"/ms;
+ if (defined($1)) {
+ $use_setting = $1;
+ }
+ #print "$use_setting \n";
+ print (join(" ", split(' ', $use_setting)));
+ print "\n";
+}
+
+sub disable_use_flag
+{
+ my $conf_uf_list_ref = shift();
+ my $use_flags_ref = shift();
+ my @add_flags;
+ my @del_flags;
+ my $disable_all = 0;
+ #my $disable_start = 0;
+ my $disable_found = 0;
+
+ foreach my $cflag (@$conf_uf_list_ref) {
+ if ($cflag eq "-*") {
+ $disable_found = 1;
+ last;
+ }
+ }
+
+ DFLAG: foreach my $dflag (@D) {
+
+ if ($dflag eq "*" or $dflag eq "all") {
+ #print "$dflag need $disable_found to add -* use flag.. \n";
+ $disable_all = 1;
+ $dflag = "-*";
+ push @del_flags, $dflag if ($disable_found);
+ next DFLAG;
+ }
+
+ if (exists $use_flags_ref->{$dflag}) {
+ if ($use_flags_ref->{$dflag}->[3] eq FLAG_MASK->[2]) {
+ add_warning($dflag, "$dflag is masked. Disabling a masked " .
+ "flag.");
+ next DFLAG;
+ }
+
+ for (my $i = $#{@$conf_uf_list_ref}; $i >= 0; $i--) {
+ my $curr_flag = $conf_uf_list_ref->[$i];
+ #print "curr flag: $curr_flag dflag: $dflag \n";
+
+ if ($disable_all) {
+ if ($disable_found) {
+ push @del_flags, "-".$dflag;
+ next DFLAG;
+ }
+ else {
+ my $dflag_sign = "-".$dflag;
+ if ($curr_flag eq $dflag_sign) {
+ #print "flag exists.. \n";
+ next DFLAG;
+ }
+ if ($curr_flag eq $dflag) {
+ push @add_flags, $dflag;
+ next DFLAG;
+ }
+ }
+ }
+ else {
+ my $dflag_sign = "-".$dflag;
+ if ($curr_flag eq $dflag_sign) {
+ #print "flag exists.. \n";
+ next DFLAG;
+ }
+ if ($curr_flag eq $dflag) {
+ push @add_flags, $dflag;
+ next DFLAG;
+ }
+
+ if ($disable_found) {
+ if ($curr_flag eq "-*") {
+ push @del_flags, "-".$dflag;
+ next DFLAG;
+ }
+ }
+ }
+ }
+ unless ($disable_found) {
+ #print "$dflag - need to disable this flag...\n";
+ push @del_flags, "-".$dflag;
+ }
+ }
+ else {
+ add_warning($dflag, "Disabling invalid use flag.");
+ }
+ }
+
+ my $make_conf = read_file($FMake_conf);
+ copy ($FMake_conf, "$FMake_conf.bkeuse");
+ if ($disable_all && !$disable_found) {
+ $make_conf =~
+ s/(^\s*USE[\s\n]*=[\s\n]*")([^"]*)(")/$1-* $2$3/ms;
+ }
+
+ if (@add_flags || @del_flags) {
+ #my $timestamp = get_timestamp();
+ #copy ($FMake_conf, "$FMake_conf.$timestamp");
+
+ if (@del_flags) {
+ print "these are flags to disable...\n";
+ my $dflags = join (" ", @del_flags);
+ #print ($dflags . "\n");
+ $make_conf =~
+ s/(^\s*USE[\s\n]*=[\s\n]*")([^"]*)(")/$1$2 $dflags$3/ms;
+
+ # If there is no USE flag setting in make.conf include it and
+ # disable the flags.
+ unless (defined($1)) {
+ print "There are flags to del but no USE setting \n";
+ $make_conf =~ s/(^\s*#\s*Host)/USE="$dflags"\n$1/ms;
+ }
+ }
+
+ my $use_setting = "";
+ if (@add_flags) {
+ #print "these are flags to enable...\n";
+ my $eflags = join (" ", @add_flags);
+ #print ($eflags . "\n");
+ if ($make_conf =~ /^\s*USE[\s\n]*=[\s\n]*"([^"]*)"/ms) {
+ $use_setting = $1;
+ }
+ foreach my $eflag (@add_flags) {
+ # should only enable the last one occurence
+ # Is there are better regex for this to avoid backtracking?
+ # \Q, \E prevents flags like libg++ to bonk
+ $use_setting =~ s/(.*)\Q$eflag\E(.*)/$1-$eflag$2/s;
+ }
+ $make_conf =~
+ s/(^\s*USE[\s\n]*=[\s\n]*")([^"]*)(")/$1$use_setting$3/ms;
+
+ }
+
+ }
+
+ open(OUTFILE, ">$FMake_conf") or
+ die("couldn't open make.conf");
+ print OUTFILE $make_conf;
+ close OUTFILE;
+
+ print "USE setting in make.conf after disabling: \n";
+ $make_conf = read_file($FMake_conf);
+ my $use_setting = "";
+ $make_conf =~ /^\s*USE[\s\n]*=[\s\n]*"([^"]*)"/ms;
+ if (defined($1)) {
+ $use_setting = $1;
+ }
+ #print "$use_setting \n";
+ print (join(" ", split(' ', $use_setting)));
+ print "\n";
+}
+
+# is there a better way of rearranging? This works, but any better solutions?
+sub rearrange_args
+{
+ my $arg_array_ref = shift();
+ my @new_arg_array = ();
+ foreach my $arg (@$arg_array_ref) {
+ if ($arg eq "*" or $arg eq "all") {
+ unshift @new_arg_array, $arg;
+ }
+ else {
+ push @new_arg_array, $arg;
+ }
+ }
+ @$arg_array_ref = @new_arg_array;
+}
+
+# removes duplicate elements of an array
+sub remove_duplicates
+{
+ my $arg_array_ref = shift();
+ my %arg_hash;
+ my @unique_args = grep { !$arg_hash{$_} ++ } @$arg_array_ref;
+ @$arg_array_ref = @unique_args;
+}
+
+sub get_timestamp
+{
+ my ($sec, $min, $hour, $day, $mon, $year) = (localtime)[0..5];
+ $mon += 1;
+ $year += 1900;
+ # need to format hour, min, second, day, mon to 2 digits.
+ my $timestamp = sprintf ('%4u%02u%02u%02u%02u%02u',
+ $year, $mon, $day, $hour, $min, $sec);
+ print "$timestamp\n";
+ return $timestamp;
+}
+
+
+
+
+#array[name, desc, type, mask, pkg, site]
+# name - name of the use flag (Required)
+# desc - description for the use flag (Required)
+# type - where the use flag is found. Acceptable values (global,local). Global
+# means use.desc and local means use.local.desc (Required)
+# mask - whether the use flag is enabled, disabled or masked. Acceptable values
+# (enabled,disabled,masked,internal) (Optional)
+# pkg - for local use flags, package which it belongs to. For global use flags
+# - it is empty.
+# site - if the use flag is enabled where is it enabled. Acceptable values
+# (E,C,A,D,-) (Optional)
+# E - environment
+# C - make.conf
+# A - auto
+# D - make.defaults
+# - - not enabled
+sub create_use_flag(\$\$\$;\$\$\$)
+{
+ my ($name, $desc, $type) = ($_[0], $_[1], $_[2]);
+ my $mask = (defined($_[3]) ? $_[3] : FLAG_MASK->[1]);
+ my $pkg = (defined($_[4]) ? $_[4] : "");
+ my $site = (defined($_[5]) ? $_[5] : FLAG_SITE->[4]);
+ my @use_flag = ($name, $desc, $type, $mask, $pkg, $site);
+ #print (join (" ", @use_flag) . "\n");
+ return \@use_flag;
+}
+
+# to format all the warning messages
+sub format_warning
+{
+ if (%Uf_warnings) {
+ print "EUSE WARNINGS!! \n";
+ my $max_len = 0;
+ my $curr_key_len = 0;
+ foreach (sort keys %Uf_warnings) {
+ $curr_key_len = length($_);
+ $max_len = $curr_key_len if $curr_key_len > $max_len;
+ }
+
+ my ($use_flag_name, $warning_msg);
+
+ my $warn_format = "format WARNINGS_FORMAT= \n" .
+'@' . ('<'x($max_len-1)) . ' => ' . '^' . ('<'x(80-$max_len-4-1)) . "\n" .
+'$use_flag_name, $warning_msg' ."\n" .
+(' 'x($max_len+4)) . '^' . ('<'x(80-$max_len-4-1-2)) . '~~' . "\n" .
+'$warning_msg' . "\n" .
+".\n";
+ eval $warn_format;
+ #print $warn_format;
+
+ my $warn_bot_format = "format WARNINGS_BOT_FORMAT= \n" .
+(' 'x($max_len)) . ' => ' . '^' . ('<'x(80-$max_len-4-1)) . "\n" .
+'$warning_msg' . "\n" .
+(' 'x($max_len+4)) . '^' . ('<'x(80-$max_len-4-1-2)) . '~~' . "\n" .
+'$warning_msg' . "\n" .
+".\n";
+
+ eval $warn_bot_format;
+ #print $warn_bot_format;
+
+ foreach (sort keys %Uf_warnings) {
+ $use_flag_name = $_;
+ my $count = 0;
+ foreach (@{$Uf_warnings{$_}}) {
+ $~ = ($count++ == 0) ?
+ 'WARNINGS_FORMAT' : 'WARNINGS_BOT_FORMAT';
+ $warning_msg = $_;
+ write;
+ }
+ }
+ }
+}
+
+# formatted output for euse -i
+sub format_output
+{
+ my @use_flag_list = @{shift()};
+ my $max_len = ${shift()};
+ #print "Use flag list: $#use_flag_list \n";
+ #print "Key Length: $max_len \n";
+ if ($#use_flag_list < 0) {
+ print ("No matching use flags to display!! \n");
+ return;
+ }
+ my @use_flag;
+ my ($use_flag_name, $use_flag_desc, $use_flag_type, $use_flag_mask,
+ $use_flag_site);
+
+ # No of columns = 80
+ # -1 to compensate for < or @ char in format
+ # -2 to compensate for ~~ in format
+ # No of other chars excluding use flag name = 14
+ my $use_flag_format = "format USE_FLAG_FORMAT= \n" .
+'@' . ('<'x($max_len-1)) . ' [@]' . ' [@] [@] ' . '^' . ('<'x(80-$max_len-13-1)) . "\n" .
+'$use_flag_name, $use_flag_mask, $use_flag_site, $use_flag_type, $use_flag_desc' ."\n" .
+(' 'x($max_len+13)) . '^' . ('<'x(80-$max_len-13-1-2)) . '~~' . "\n" .
+'$use_flag_desc' . "\n" .
+".\n";
+
+ eval $use_flag_format;
+ #print $use_flag_format;
+
+
+ $~ = 'USE_FLAG_FORMAT';
+ foreach (@use_flag_list) {
+ @use_flag = @{$_};
+ $use_flag_name = $use_flag[0];
+ $use_flag_desc = ($use_flag[4] eq "" ?
+ $use_flag[1] : "[" . $use_flag[4] . "] : " . $use_flag[1]);
+ $use_flag_type = $use_flag[2];
+ $use_flag_mask = $use_flag[3];
+ $use_flag_site = $use_flag[5];
+ write;
+ }
+
+}
+
+# TODO:
+# 1. -p feature
+# 2. pipe the output to less to implement paging.
+# 3. flag to disable all warnings.
+# 4. filters - all global, local, enabled through make.conf,
+# make.defaults, env. All enabled flags, all disabled flags.
+# 5. combine -d, -c, -e with -i to give detailed output.
+#
projects / gentoolkit.git / commitdiff