There would be a lot less code to do the same thing if you start with a string that has all characters available for use in passwords, then remove classes of characters according to the given options:

my $pswd_chars = join( '', map {chr} ( 0x21 .. 0x7e ));
$pswd_chars =~ s/\d+//   if ( $numbers );
$pswd_chars =~ s/[A-Z]+// if ( $uppercase );
$pswd_chars =~ s/[a-z]+// if ( $lowercase );
$pswd_chars =~ s/[_\W]+//g if ( $symbols );
if ( length( $pswd_chars ) == 0 ) {
    push @errmsg, "\n *** You eliminated all possible characters.";
}
[download]

Also, if someone wants to use this to create passwords to be handed out to clients (i.e. via email or web transactions), another useful option would be to eliminate confusable characters:

$pswd_chars =~ tr/1Il0O//d  if ( $confusable );
[download]

sub GenPass {
    my ( $pswd_chars, $pswd_len ) = @_;

    my $limit = length( $pswd_chars );

    my $pswd = '';
    for ( 0..$pswd_len-1 ) {
        $pswd .= substr( $pswd_chars, rand( $limit ), 1 );
    }
    return $pswd;
}
[download]

Update: However, unless I misread this, your randomization does NOT account for the differing quantities of available/extant "numbers (10)," "symbols (depends on character set)," "UC_letters (ditto)," and "lc_letters (ditto again)." If I'm correct, that may induce a pattern of output that would be detectable over a relatively small sample, and thus might reduce the work involved in breaking the p/w generated. OTOH, that might actually make breaking the p/w harder. Comments, anyone?   </update>

Also, the comment at line 81 doesn't seem quite right, in the overall context since to achieve exclusions, such as -N, the invocation must have multiple arguments -- one for length, and one for the exclusion.

One other trivial and highly personal observation (YMMV), I find the use multiple dashes as leading- and trailing-sub/function/etc delimiters (eg, lines like 9, 18, 21 & 33) "intrusive" (for lack of a better word) and somewhat un-lazy. FW(little)IW, a pair of newlines generally achieves - for me - the kind of clarity you're seeking (for which, another ++).

Heredocs are a nice way to tidy up help messages and such. Consider:

sub DisplayUsage {
    print <<"    USAGE";
    Usage: genpass [-OPTIONS] LENGTH
    Generate secure passwords LENGTH characters long.
    
        -s, --symbols\t\tExclude symbol characters.
        -n, --numbers\t\tExclude number characters.
        -u, --uppercase\t\tExclude uppercase characters.
        -l, --lowercase\t\tExclude lowercase characters.
        
        -q(X)\t\t\tCreate X number of passwords.
        
        --help\t\t\tDisplay this usage screen.
        
    Report bugs, comments, and questions to jbrown_home\@yahoo.ca
    
    USAGE
}
[download]

Note also that the prototype has been omitted from the sub. Apart from exceptional cases, prototypes are not useful and tend to lead to subtle and hard to find bugs.

Note too that the white space is an important part of the here document tag. There is a nasty and subtle trap here - the white space must match exactly for the end of the document to be recognised.

I'd be inclined to rewrite the password generation sub a little: ;)

sub GenPass {
    my ($pwdlen, %flags) = @_;
    my $password="";
    my $num;
    
    while (length ($password) < $pwdlen) {
        $num = GetRandNum ();

        if (($num >= 33 && $num <= 47) || ($num >= 58 && $num <= 64) |
+|
            ($num >= 91 && $num <= 95) || ($num >= 123 && $num <= 126)
           ) {
            next if $flags{symbols} eq '0';
        }
        
        if (($num >= 48 && $num <= 57)) {
            next if $flags{numbers} eq '0';
        }
        
        if (($num >= 65 && $num <= 90)) {
            next if $flags{uppercase} eq '0';
        }
        
        if (($num >= 97 && $num <= 122)) {
            next if $flags{lowercase} eq '0';
        }
   
        redo; # Invalid character, try again
        
    } continue {
        $password .= chr($num);
    }

    return "$password\n";
}
[download]

Main points are:

• Don't prototype the sub
• Don't use global variables (note the %flags hash in particular)
• Don't comment the obvious. A well named variable like $password doesn't need a comment to tell the reader that it contains the password.
• Look for ways to reduce nesting. In this case continue does the trick.
• Define variables as locally as possible so that their scope is more obvious.
• Avoid duplicating information (in this case note that $count is not required)

#!/usr/bin/perl
use strict;
use warnings;
use Getopt::Long;
Getopt::Long::Configure ("bundling");

## PARSE AND SET COMMAND-LINE OPTIONS
## -----------------------------------------------------
my %flags=('symbols', 0, 'numbers', 0, 'uppercase', 0, 'lowercase', 0,
+ 'confusable', 0, 'help', 0, 'qty', 1);

GetOptions( 's|S|symbols' => \$flags{symbols},
        'n|N|numbers' => \$flags{numbers},
        'u|U|uppercase' => \$flags{uppercase},
        'l|L|lowercase' => \$flags{lowercase},
        'c|C|confusable' => \$flags{confusable},
        'q|Q:i' => \$flags{qty},
        'help' => \$flags{help}, );

# Set password characters, excluding those flagged on the command-line
my $pwdchars = join( '', map {chr} ( 0x21 .. 0x7e ));
    $pwdchars =~ s/\d+//    if ( $flags{numbers} );
    $pwdchars =~ s/[A-Z]+// if ( $flags{uppercase} );
    $pwdchars =~ s/[a-z]+// if ( $flags{lowercase} );
    $pwdchars =~ s/[_\W]+//g if ( $flags{symbols} );
    $pwdchars =~ tr/1Il0O//d  if ( $flags{confusable} );

# If user triggered the --help option flag, display and exit
if ($flags{help}) {            
    &DisplayUsage();    
    exit();
}

## START VALIDATE INPUT
## -----------------------------------------------------
my $kill=0;        # flag to stop the script if input is invalid (or -
+-help is used)
my @errmsg;        # error message descriptions

# If -q option was used to set a quantity of passwords, make sure it c
+ontains at
# least a value of 1 so that a password can be generated
if ($flags{qty} == 0 || $flags{qty} < 0) {
    $flags{qty}=1;
}

# Check that user hasn't excluded all character-types, warn user, kill
+ script
if ( length($pwdchars) == 0) {
    push @errmsg, "** 0x1: At least 1 character-type must be included"
+;    
    $kill=1;
}

# Check that user has passed only 1 argument (LENGTH) other than optio
+ns flags, warn user, kill script
if ($#ARGV > 0 || $#ARGV < 0) {
    push @errmsg, "** 0x2: Incorrect number of arguments passed";
    $kill=1;
}

# Check for only numeric input in LENGTH argument, warn user, kill scr
+ipt
if ($ARGV[0] !~ /^[0-9]+$/) {
        push @errmsg, "** 0x3: Invalid input. LENGTH argument must be 
+a numeric value";
        $kill=1;
}

# If any of the above validation tests triggered the $kill flag...
if ($kill == 1) {                     
    print "\n** GENPASS ERROR ----------------------------------------
+-----------------";
    print "\n** ".@errmsg." Error(s) found";      # display number of 
+errors    
    foreach my $err (@errmsg) {             # display error messages
        print "\n".$err;
    }
    print "\n**\n** Type genpass --help for command usage\n";
    print "** --------------------------------------------------------
+---------------\n\n";
    exit();                         # exit script
}
## END VALIDATE INPUT

## START MAIN SCRIPT
## -----------------------------------------------------
# From 1 to qty

for ( 1..$flags{qty} ) {
    print &GenPass( $ARGV[0] )."\n";
}
exit();

## END MAIN SCRIPT

## FUNCTION DEFINITIONS
## -----------------------------------------------------
sub GenPass() {
    my ($pwdlen) = @_;
    my $limit = length( $pwdchars );
    my $pwd = '';
    
    for ( 0..$pwdlen-1 ) {
            $pwd .= substr( $pwdchars, rand( $limit ), 1 );
    }

    return $pwd;
}

# use Here-Documents to display usage text
sub DisplayUsage {
    print <<"    USAGE";

    Usage: genpass [-OPTIONS] LENGTH
    Generate secure passwords LENGTH characters long.
    
        -s, --symbols\t\tExclude symbols.
        -n, --numbers\t\tExclude numbers.
        -u, --uppercase\t\tExclude uppercase letters.
        -l, --lowercase\t\tExclude lowercase letters.

    -c, --confusable\tExclude confusable characters like: l,I,1,0,O
        
        -q(X)\t\t\tCreate X number of passwords.
        
        --help\t\t\tDisplay this usage screen.
        
    Report bugs, comments, and questions to jbrown_home\@yahoo.ca
    
    USAGE
}

__END__
[download]

Sorry, I wasn't logged in when I posted that last...That was me, munkyeetr.

A few more comments mixing in random order matters of personal style and more substantial things:

Read more... (11 kB)

Putting all of the above (and a few minor cosmetic touches) together:

Read more... (3 kB)

Some tests:

Read more... (735 Bytes)

One thing that I may look into is incorporating a switch to handle (or offer) different character sets.

That, IMO, would be asking for a lot of trouble that you really don't need, in order to supply a "feature" that virtually all sensible users really don't want.

Frankly, the world is just not ready yet for passwords containing non-ASCII characters. Not only do we lack stable/consistent conventions for their keyboard entry, but their encoding and transmission are still mired in an embarrassingly wide range of "alternative methods" and obscure constraints. Forget about it.