I think the first thing to concern yourself with is style, assuming that the code above is not the result of errors introduced during cut and pasting. There's no indenting, which is very helpful in trying to identify loops. Other points where I see that it could be improved is adding more carriage returns to help separate a conditional/flow control statement from the actions that are taken; for example, you have:

if($lowrange < 0) { $lowrange = 0; print "\nYour number must be positi
+ve. I have set it to 0 for you."; }
[download]

if ($lowrange < 0) { 
    $lowrange = 0; 
    print "\nYour number must be positive. I have set it to 0 for you.
+"; 
}
[download]

{ 
    $lowrange = 0; 
    print "\nYour number must be positive. I have set it to 0 for you.
+"; 
} if ($lowrange < 0);
[download]

I'd also try to be consistent when you add your \n's for printing; either do them all at the end or all at the beginning; the mix is somewhat distracting.

From a logic standpoint, you may want to round to the nearest int; if I enter "2.5" as the lower bound, the program won't find any primes, for example.

In the search-for-primes loop, you can use the last keyword instead of setting $i to an incrediable high value as to leave the loop early.

-----------------------------------------------------
Dr. Michael K. Neylon - mneylon-pm@masemware.com || "You've left the lens cap of your mind on again, Pinky" - The Brain
It's not what you know, but knowing how to find it if you don't know that's important

Good advice, Masem. But your if statement example doesn't work ...

do { # not without the do
    $lowrange = 0; 
    print "\nYour number must be positive. I have set it to 0 for you.
+"; 
} if ($lowrange < 0);
[download]

this form of if (or unless, foreach, while, until) only works on simple statements, not on blocks.

-- Hofmator

open PRIMES, $primefile;
while(<PRIMES>) {
push (@parray, $_);
}
close PRIMES;

# could be 
open PRIMES, $primefile;
@parray = <PRIMES>;
close PRIMES;
[download]

if($lowrange % 2 == 0) { $lowrange++; }

# could be 

$lowrange++ unless ($lowrange % 2);
[download]

Also another note on prints: When you have something like

print "\nTotal amount of primes: $counter \n";
print "Your results have been saved, starting with
".$path.$beginloc.$last."\n\n";
[download]

print "\nTotal amount of primes: $counter \n",
      "Your results have been saved, starting with
".$path.$beginloc.$last."\n\n";
[download]

print "Your results have been saved, starting with
".$path.$beginloc.$last."\n\n";

# becomes
print "Your results have been saved, starting with ${path}${beginloc}$
+{last}\n\n";
[download]

Just a few notes for ya.

1. Got rid of the primes file. Unless you're planning on working with substantially more than 10,000 primes, this way is just as fast, or faster. (You're not loading primes you won't need...)
2. Unless you have a reason for only putting 10,000 primes in a file, I'd put everything in the same file. It makes working with them later a little easier.

#!/usr/local/bin/perl -w

use strict;

######################################################################
+##########

my $resultFile = "results.txt";

my $lowrange = 0;
my $hirange = 0;

######################################################################
+##########

print "Welcome to the prime number program.\n";
print "This program will tell you every prime number within a certain 
+range.\n";

print "Please enter the lower range now: ";
chomp($lowrange = <STDIN>);

die "\nThe low must be a positive integer\n"
        if ($lowrange && $lowrange =~ /\D/);

print "\nHow high should the program search for primes? ";
chomp($hirange = <STDIN>);

die "\nThe high must be a positive integer\n"
        if ($hirange && $hirange =~ /\D/);
die "\nThe high must be greater than or equal to the low\n"
        if ($hirange < $lowrange);

print "Now listing the range of all primes between $lowrange and $hira
+nge. \n";
print "Please wait.\n";

$lowrange++ if ($lowrange % 2 == 0);

open RESULTS, ">$resultFile"
        || die "Cannot open $resultFile for writing\n";

my $counter = 0;

if ($lowrange <= 3) {
        if ($lowrange <= 2) {
                print RESULTS "2\n";
                $counter++;
        }

        print RESULTS "3\n";
        $lowrange = 5;
        $counter++;
}

CANDIDATE:
for (my $candidate = $lowrange; $candidate <= $hirange; $candidate += 
+2) {

        for my $divisor (3 .. int(sqrt($candidate))) {
                next CANDIDATE
                        unless $candidate % $divisor;
        }


        $counter++;
        print RESULTS "$candidate\n";
}

close RESULTS;

print "\nTotal amount of primes: $counter \n";
print "Your results have been saved to $resultFile\n";

__END__
[download]

------
We are the carpenters and bricklayers of the Information Age.

Vote paco for President!

!/usr/local/bin/perl -w
use strict;

#These variables are user-configurable.
my $countermax = 10000;          #The max number of primes per file. (
+To regulate file size)
my $primefile = "Primes.seed";    #The location of the seed file. This
+ is needed.
my $path = "./";     #The first part of the path to dump the files in.
+ This must be pre-existing.
my $last = ".txt";                #The extension to append to the file
+names. Your choice.
my $beginloc = 0;           #The number to start counting at when maki
+ng filenames.

#End users should not edit below this line
my $outputloc = $beginloc;

#First this looks for a pre-existing primes file
#which has all the primes less than 10000 in it. 
#It needs this file. Assume it is present or
#suggest a better way or something...
open PRIMES, $primefile || die $!;
my @parray = <PRIMES>;
close PRIMES;

open RESULTS, ">".$path.$outputloc.$last || die $!;

print <<TXT;
Welcome to the prime number program.
This program will tell you every prime number within a certain range.
Please enter the lower range now:
TXT

#get from arg or stdin
my $lowrange = int($ARGV[0]||<STDIN>);
chomp $lowrange;

#Simple idiot-proofing. I didn't bother to check to make
#sure it's actually an integer. What's a good way to 
#do this?
if($lowrange < 0) { 
   $lowrange = 0; 
   print "\nYour number must be positive. I have set it to 0 for you."
+;
}

print "\nHow high should the program search for primes? ";

#get from arg or stdin
my $hirange = int($ARGV[1]||<STDIN>);
chomp $hirange;

if($hirange <= $lowrange) { 
  $hirange = $lowrange + 100;
  print <<TXT;

Your second number must be at least equal to the first.
I have arbitratily set it to be 100 greater.
TXT
}


print "Now computing the range of all primes between $lowrange and $hi
+range. \nPlease wait.\n";

#No need to check even numbers, right?
$lowrange++ unless $lowrange % 2;

my $counter=0;
#Of course, since 1 isn't a prime, we have to account
#for that.
if($lowrange == 1) {
   print RESULTS "2\n";
   $lowrange = 3;
   $counter++;
}

for(my $current = $lowrange; $current <= $hirange; $current += 2) {
  for(my $i = 0; $parray[$i] <= sqrt($current); $i++) {
    if($current % $parray[$i] == 0) { 
      $counter++;
      print RESULTS "$current\n";
      if($counter%$countermax == 0) {
        close RESULTS;
        $outputloc++;
        print "\nFile full. Currently ".($current *100/$hirange)."\% d
+one.";

        open RESULTS, ">".$path.$outputloc.$last || die $!;
      }
      last;
     }
  }
}

print <<TXT;

Total amount of primes: $counter
Your results have been saved, starting with $path$beginloc$last

TXT
[download]

Update: The link appears to be down at the moment, but I'm pretty sure its correct...
For the impatient, here is a link to the article in google's cache (thanks rob_au)

-Blake

The one I wrote a while ago for ppt is about a third faster. :-)