grep for the configuration file and if you find it, splice it out of @ARGV. Then process the configuration file followed by the command line processing.

If you can live with a modification of your command-line argument rules, you can make this all pretty simple.

Rule 2b: The configuration file overrides command-line options occuring before it is specified, is overridden by those occuring after.

With that, you only need to process the config file as soon as it is specified. To get the behavior you wanted, your user would just have to name the config file first.

That works nicely unless you have a default config file. You can't process it as the zeroth argument, because it shouldn't be read at all if a config file option is given on the command line. And it can't be processed conditionally after the command-line args because then it would override the command line.

I have run into this several times too, but I don't remember what I ended up with. Probably something different and slightly wrong each time. I guess you could do something like:

  my %opts = ( 'config' => 'default.config',
               'other1' => 'default1',
               'other2' => 'default2' );
  %opts = (%opts, process_command_line());
  %opts = (read_config_file($opts{config}), %opts);
[download]

which might be better spelled

  my %defaults = ( 'other1' => 'default1',
                   'other2' => 'default2' );
  my %from_cmdline = process_command_line();
  my $config = $from_cmdline{config} || "default.config";
  my %from_config = read_config_file($config);
  my %opts = (%defaults, %from_config, %from_cmdline);
[download]

I wouldn't use either, because I always use Getopt::Long. So perhaps:

  my %defaults = ( param1 => 'default1',
                   param2 => 'default2' );
  my $config = 'default.config';
  GetOptions("config|c=s" => \$config,
             "param1=s" => \$opt{param1},
             "param2=s" => \$opt{param2});
  %defaults = (%defaults, read_config_file($config));
  while (my ($param, $value) = each %defaults) {
    $opt{$param} = $value unless defined $opt{$param};
  }
[download]

which doesn't feel very satisfying. Maybe it would be better to use Zaxo's rule 2b and fold them together?

  my %opts = ( param1 => 'default1',
               param2 => 'default2' );
  my $use_default_config = 1;
  GetOptions("config|c=s" => sub {
                 my ($param, $value) = @_;
                 $use_default_config = 0;
                 read_config_file(\%opt, $value);
             },
             "param1=s" => \$opt{param1},
             "param2=s" => \$opt{param2});
  read_config_file(\%opt, 'default.config') if $use_default_config;
[download]

Feels about right.

Update: I just read through the POD for AppConfig. I agree; it sounds really nice! But it looks like it doesn't expose enough to implement what you want. Seems like a good opportunity to submit a patch.

It was quite challenging to figure it all out, and I haven't had to pay attention to it for several months, so I can't recite how it goes off the top of my head. But you're welcome to poke around in the source and see if it gives you some leads.

use vars qw/ $opt_help $opt_one $opt_two $opt_config /;

sub parseCommandLine();
parseCommandLine();

......
......
sub parseCommandLine() {
  &getOptions( 'help|h', 'config|c=s',  'one', 'two=s' ) or $opt_help 
+= 1;
  
  if( defined( $opt_help ) ) { 
    &printUsage();
    exit(0);
  }
  
  if( defined( $opt_config ) ) {
    &parse_config( $opt_config );
  }
  
  if( defined( $opt_one )) {
    # do extra setup required for option 1
  } else {
    $opt_one = 'default_opt_one';
  } 
  
  unless( defined( $opt_two ) ) {
    $opt_two = 'default_opt_two';
  }
  # Do stuff needed for option 2.
}

sub parse_config(  ) {
  my $config_file = shift();
  # read file
  # use file to set $opt_one, $opt_two
}
[download]