So if you need efficiency, you probably need to roll yor own or use someone else's. Everyone is saying to use while, but nobody gave you sample code. Let me rectify that with a simple script that should run fairly efficiently:

#! /usr/bin/perl -w
use strict;
use HTML::Entities qw(encode_entities);

my @stack;
while (<>) {
  while (/\G([^{}]+)|\G([{}])/g) {
    if (length($1)) {
      print encode_entities($1);
    }
    elsif ("{" eq $2) {
      my $pos = pos($_);
      if (/\G(\w+)/g) {
        print "<$1>";
        push @stack, $1;
      }
      else {
        die "Unnamed opening brace at character $pos, line $.";
      }
    }
    elsif (@stack) {
      my $tag = pop(@stack);
      print "</$tag>";
    }
    else {
      my $pos = pos($_);
      die "Unmatched closing brace at character $pos, line $.";
    }
  }
}
if (@stack) {
  die "Unclosed tags at end of file: '@stack'";
}
[download]

Also, post your OS details and Perl version number. —John

Hi John, I am running 2000 NT on my personal machine, though the script performs with similar results on Unix variants. I'm running 5.005_02 Perl. As soon as I start to execute the script, my CPU pegs to 100%, memory hits about 50% and stays there. At any given point, Perl will be using 85-99% of my CPU and it stays pegged after the script stalls. I would expect (although I could be wrong) that a genuine memory leak would show steadily larger increments of memory usage, but in this case everything pretty much stays the same from start to abortive finish. What tools would you recomment for benching code?

http://www.sysinternals.com.

Get the (freshly updated) tools to view handles, and see if there is a handle leak. Also "process explorer" will give more details than just looking at the totals in Task Manager.

Reduce the available memory and run again. Does the problem spot pull back as well? Is it the same spot on Unix as well? If always the same spot, it sounds like something in the logic itself, not memory.

—John

open INFILE, "<$infile";
while ($line_in_file = <INFILE>) {
    do processing here...
    }
close INFILE;
[download]

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

#input
print "Name of file to be inputted? :";
$infile=<>;
print "What should the output file be named? The file will be automati
+cally created. :";
$outfile=<>;
chomp $infile;
chomp $outfile; ##<<<<<<<<<You forgot this one
open INFILE, "<$infile";

#output
open FILEOUT, ">$outfile";
my @stack;
while(<INFILE>) {
  my @op = ();
  my $len = length($_);
  my $minsta = 0;
  my $minsto = 0;
  my $lastpos = 0;
  while(true) {
    $minsta = index $_,'{',$minsta;
    $minsto = index $_,'}',$minsto;
    last if ($len == $lastpos || ($minsta == -1 && $minsto == -1));
    if ($minsta < $minsto) {
      my $nextsp = index $_,' ',$minsta;
      $nextsp = length($_) if ($nextsp == -1);
      my $stack = substr $_,$minsta+1,$nextsp-$minsta;
      push @op, (substr $_,$lastpos,$minsta-$lastpos), '<',$stack,'>';
      push @stack, $stack; 
      $lastpos = $minsta+1;
     } else {
       my $stack = pop @stack;
       die "Not balanced" unless (defined $stack);
       push @op, (substr $_,$lastpos,$minsto-$lastpos), '</',$stack,'>
+';
      $lastpos = $minsto+1;
     }
   }
   print OUTFILE join "",@op,(substr $_,$lastpos,$len-$lastpos);
}
close INFILE;
close FILEOUT;
die "Not balanced" if (@stack);
print "\nYour result is stored in file $outfile\nGoodbye.\n";
[download]

open INFILE, "<$infile";
$text=<INFILE>;
close INFILE;
[download]

Thats one hefty scalar to have to sort through, especially after it is expanded into xml. You are probably eating most of your system memory by doing this. Perhaps it would be faster to put your data into an array instead:

open INFILE, "<$infile";
@text=<INFILE>;
close INFILE;
[download]

and then print to the output file in your while loop.

Arrays use (slightly) more memory than scalars. If you've diagnosed his trouble correctly, the cure is (slightly) worse than the disease. Of course, the extra several bytes per array element (one SV per line, as opposed to one SV total) can start to add up if there are several lines.

If it's possible to process on a line by line or chunk by chunk basis, with a limited state machine or a stack of some sort, a while read is the better approach. (I suspect that's what you meant.)

$text=<INFILE>;
[download]

while ($line_in_file = <INFILE>)
[download]