The first two parts are fine. You grab your search an replacement patterns and chomp of the newlines (you don't need the parens with chomp BTW).

Next it gets a bit confused. The <> construct is essentially the same as <STDIN> (see ChemBoy's post below). Within the while loop each input from STDIN is aliased to the magical $_ perl special variable. Here is some working code:

print "\nSearch Pattern: ";
chomp(my $pattern = <>);
$pattern = uc quotemeta $pattern;

print "\nReplacement Pattern: ";
chomp(my $replacement = <>);

print "\nInput: ";
while (<>) {
   chomp;
   last unless $_;
   s/$pattern/$replacement/ig;
   print;
   print "\nInput: ";
}
[download]

The input sections are almost the same but I demonstrate a good use for parens with chomp to do in one line what was two before. I have also declared $pattern and $replacement as lexically scoped variables with my - this is a good idea otherwise all your variables will be globals. The $pattern = uc quotemeta $pattern does two things. The uc() function converts $pattern to UPPER CASE as desired and the quotemeta() escapes (with a \) all the meta charcters that can break your regex because the take on a non literal meaning in a regex.

We then demand some input from STDIN in an infinite while loop. As I noted this is assigned to the magical $_ var. This var is the default target of many perl functions. You see that I do a chomp, substitution and print without specifying what to do them on! They all target $_ - you either love this behaviour or hate it. I have added a last unless $_ so if we enter a null string we break out of this infinite loop. In perl 0, undefined and the null string '' are all false - everything else is true. With the substitution regex the /ig at the end are modifiers. the /i means ignore case (which we need to as we uppercased our $pattern) and the /g stands for global as in replace all occurences.

Hope this helps. Have fun and welcome.

cheers

tachyon

s&&rsenoyhcatreve&&&s&n\w+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

A minor but (IMO) important quibble: <STDIN> and <> are not identical constructs. If you use the script without command-line arguments, they are, but if a file is specified in @ARGV, reading from the magic filehandle (<>) will read from that file, while reading from STDIN (<STDIN>) will read from the standard input, aka the terminal.

Example code:

#!/usr/bin/perl
use strict;

my $color;
print  "What is your favorite color? ";
chomp ($color = <STDIN>);
print <>;
print  "Just to check, your favorite color is $color, right? ";
$_ = <STDIN>;
if ( /^y/i ) { print "Phew!\n" }
else         { print "I don't believe you!\n"}
[download]

If run thus


perl myscript.pl random_file.txt
[download]

this should give us

What is your favorite color? Blue
[ contents of random_file.txt ]
Just to check, your favorite color is Blue, right?Yes!
Phew!

This is occasionally very useful behavior--I wouldn't be at all surprised if it was pretty much what you need, Satira.

And of course, in real quibble land, tachyon didn't mean an infinite loop, he meant a loop until the filehandle reaches EOF. :-) If you're looping on <>, this will take care of itself unless you do something foolish; if you're looping on STDIN, you can break out by giving the locally appropriate EOF character (control-D on most Unices and MacPerl, control-Z on Windows I think...).




---

If God had meant us to fly, he would *never* have give us the railroads.
    --Michael Flanders

Thanks for that ChemBoy - I was unaware of the <> and @ARGV behaviour. File another pearl. Sure it's not technically an infinite loop as you point out but having a way to break out of it is a good idea. Much better than control ?D ?Z ?X ?C or even the ever faithful Ctl-Alt-Del ;-)

print "Your call is important to us please hold...\n";
for (;;) {
    while (1) {
        print "I committed a technical inexactitude\n" until 0;
    }
}
print "Did you wait long!\n";
[download]

tachyon

s&&rsenoyhcatreve&&&s&n\w+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

User Input: She sells Seashells by the seashore.
Search Pattern: sea
Replacement Pattern: bay
Final Output: She sells bayshells by the bayshore.

But what I want it to do is keep the capitalization.
Final Output: She sells Bayshells by the bayshore.
[download]

main();

sub main {


print "Text to be analyzed.\n";
print "Type a blank line when finished.\n\n";

while (<>) {
        /^$/&& last;
        $input.=$_}

        chomp($input);

        replace ();

        $input = "";

        again ();
}

sub replace {

        print "\nSearched for: ";
        $pattern = <>;
        chomp($pattern);

        print "\nReplace with: ";
        $replacement = <>;
        chomp($replacement);

        $input =~ s/$pattern/$replacement/ig;
}
[download]