If you have Perl version 5.10+, the  (?|pattern) construct (see Extended Patterns in perlre) supports a neat approach:

c:\@Work\Perl>perl -wMstrict -le
"use 5.010;
 ;;
 use Test::More 'no_plan';
 use Test::NoWarnings;
 ;;
 my $rx_rng = qr{ \A (?| (\d*) - (\d+) | (\d+) - (\d*)) \z }xms;
 ;;
 my $max = 10;
 ;;
 for my $ar_vector (
   [ '0-0', 0..0 ], [ '4-6', 4..6 ], [ '-2', 0..2 ], [ '3-', 3..$max ]
+,
   ) {
   my ($rs, @rng) = @$ar_vector;
   is_deeply [ range($rs, $max, $rx_rng) ], \@rng, qq{'$rs'};
   }
 ;;
 sub range {
   my ($rs, $r_max, $rx) = @_;
   ;;
   my ($lo, $hi) = $rs =~ $rx or die qq{not a range: '$rs'};
   $lo = 0      unless length $lo;
   $hi = $r_max unless length $hi;
   ;;
   die qq{range inverted: '$rs'}   if $lo > $hi;
   die qq{max out of range: '$rs'} if $hi > $r_max;
   ;;
   return $lo .. $hi;
   }
"
ok 1 - '0-0'
ok 2 - '4-6'
ok 3 - '-2'
ok 4 - '3-'
ok 5 - no warnings
1..5
[download]

I think this catches all the same things as your code though the error message maybe different or less detailed:

sub range_to_list {
    my( $max, $range ) = @_;
    my( $lo, $sep, $hi ) = $range =~ m[^(\d+)?(?:(-)(\d*))?$] or die "
+Invalid range:$range\n";
    $lo ||= 0; 
    $hi ||= $sep ? $max : $lo;
    $_ > $max and die "$_ out of range\n" for $lo, $hi;
    return $lo .. $hi;
}
[download]

Output from your tests:

C:\test>junk61
maxind=10

rstr:x:...exc:Invalid range:x

rstr:1-2-3:...exc:Invalid range:1-2-3

rstr:0:...ret:0:
rstr:10:...ret:10:
rstr:11:...exc:11 out of range

rstr:4:...ret:4:
rstr:4-6:...ret:4 5 6:
rstr:7-:...ret:7 8 9 10:
rstr:-2:...ret:0 1 2:
rstr:-10:...ret:0 1 2 3 4 5 6 7 8 9 10:
rstr:-11:...exc:11 out of range

rstr:-0:...ret:0 1 2 3 4 5 6 7 8 9 10:
rstr:10-:...ret:10:
rstr:11-:...exc:11 out of range

apples :one::two::three:
[download]

My proposal is to first normalize the input string to the form "start-end" using substitutions. This is simple if the string conforms to the specification. (I also assume that a pure "-" means a list from zero to the maximum.) Once this normalization is achieved, it is very simple to build the list:

use strict;
use warnings;

sub range_to_list {
  my ($max, $str) = @_;
  $str =~ s/^-/0-/;         # string starts with -
  $str =~ s/-$/-$max/;      # string ends with -
  $str =~ s/^(\d+)$/$1-$1/; # just a number
  return ($str =~ /^(\d+)-(\d+)$/)&&($1<=$max)&&($2<=$max) ? ($1..$2) 
+: ();
}

my @tests = qw( 4 4-6 5- -2 - a 11- 2-7w -11 );

for my $test (@tests) {
  my @list = range_to_list 10, $test;
  print "$test:\t@list\n";
}
[download]

How about this?

use strict;
use warnings;
use feature 'say';

@ARGV or die 'No range specified';
# Check if the range was specified correctly.
# This will filter out negative numbers as well.
$ARGV[0] =~ /\A(?:\d+)?-(?:\d+)?\Z/ or die 'Invalid range';

my @commands = qw(zero one two three four);

# In case one of the values was not specified it will become an empty 
+string
my ($start, $end) = split '-', $ARGV[0];
# Since an empty string evaluates to false we can assign default value
+s like this
$start = 0 unless $start;
$end = $#commands unless $end;
# Negative indices are filtered out by the first regex so we only need
+ to check if the index is not too big.
die "$start is out of range" unless $start < @commands;
die "$end is out of range" unless $end < @commands;

# The range is sure to be valid now so we can simply use .. to generat
+e a list
foreach my $index ($start .. $end) {
    say $commands[$index];
}
[download]

BTW: Your testcode can be simplified also:

my $maxind = 10;
print "maxind=$maxind\n";

for my $rstr ( qw[ x  1-2-3 0 10 11 4 4-6 7- -2 -10 -11 -0 10- 11- ] )
+ {
    my @ret = eval{ range_to_list( $maxind, $rstr ) };
    print "rstr:$rstr:", $@ ? "...exc:$@" : "...ret:@ret:";
}

my @apples = qw[ :zero: :one: :two: :three: :four: ];
print "apples ", @apples[range_to_list( $#apples, "1-3" )], "\n";
[download]