<?xml version="1.0" encoding="iso-8859-1"?>
[download]

Or you could read the whole file in memory and do regular expressions.

Judging from what you've given us, there is no "best" way. There's just TIMTOWTDI.

Hope this helps.

Liz

This script will do what you want, provided that your file is not too big for your memory.

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

my $start_flag = '<REANALYZED>';
my $stop_flag = '</REANALYZED>';
my $replacement = <<'REPL';
    "z:\path\newfilename1.ext" GL
    "z:\path\newfilename2.ext" GL
    "z:\path\newfilename3.ext" GL
    "z:\path\newfilename4.ext" GL
    "z:\path\newfilename5.ext" GL
    "z:\path\newfilename6.ext" GL
REPL

open ORIGINAL, "< original.txt"
    or die "can't open original file\n";
my $original;
{
local $/;
$original = <ORIGINAL>;
}
close ORIGINAL;

$original =~ s/
    $start_flag
    .*?
    (\s*)
    $stop_flag
    \n
    /$start_flag\n$replacement$1$stop_flag/gsx;

open COPY, "> copy.txt"
    or die "can't write to copy\n";
print COPY $original;
close COPY;
[download]

HTH

What about a one-liner?

If you have your replacement strings in "repl.txt", this will do the trick.

perl -0pe 'BEGIN{open R,"repl.txt";$repl=<R>;close R}s/(<REANALYZED>).
+*?(<\/REANALYZED>)/$1$repl$2/s' original.txt
[download]

while($line=<>)
{
  chomp $line;
  if($line=~m/<REANALYZED>/)
  {
    print "$line\n";
    system("cat new_content_for_reanalyzed_tag_file");
    do
    {
      $line=<>;
      chomp $line;
    } until($line=~m/<\/REANALYZED>/);
    print "$line\n";
  }
  elsif($line=~m/<ANOTHERTAG>/)
  {
    print "$line\n";
    system("cat another_file_for_this_tag");
    .
    .
    .
    etc.
  }
  else
  {
    print "$line\n";
}
[download]

Must i use regex or is there a module to do this kind of operations?

Well, there is never a must to use a regexp. However, the question is a regexp a good way to tackle this problem cannot be answered. You don't define how your "tags" look like, you just give an example. Your example suggests that tags appear on lines of their own, are all written in full caps, don't have attributes, don't nest themselves, and are always of the open/close form (no standalone tags). Depending on the definition of how tags look like and how they can appear, regexes may or may not be the way to go.

Abigail

The tags are precisely like that. They appear on lines of their own,are all written in full caps, don't have attributes, don't nest themselves, and are always of the open/close form.

And i canīt include a line saying that is xml because this file is going to be read by an application that analyze the file and get the various information of it.

So, the tags are always like that. They open and they close..no tags inside and always in separated lines.

Thanks for your help.

Nuno

And i canīt include a line saying that is xml...

Actually, if the strange line ending characters "ķ" are an artefact of you grabbing and posting the actual content of the file from e.g. Word, then you don't have to include the <?xml line. If there is no indicating of version or encoding, any XML processor will assume version "1.0" and encoding "utf-8". If the characters in your file are all US-ASCII characters (which in this example they are), you are fine.

Liz

Thank you all for your precious help once again.

Iīve made the following code that works

use strict;
use warnings;

my $path='D:\npodev\forms\src';
my @intervalos= ("[a-e]", "[f-h]", "[i-m]", "[n]", "[o-s]", "[t-z]");
my $esquema="RMS_MC";
my $start_flag = '<REANALYZED>';
my $stop_flag = '</REANALYZED>';

sub procura_ficheiros{
  my ($path,$intervalo)=@_;
  opendir(DIR, $path) ||die "$!";
  my @files=grep{/^$intervalo.*\.[f|m]/i} readdir(DIR);
  closedir (DIR);
  my $aux=0;
  foreach my $pos (@files){
    $files[$aux]="\t\"".$path."\\".$files[$aux]."\""."   $esquema\n";
    $aux++;
  }
return @files;
}

foreach my $intervalo (@intervalos){
    my @ola=procura_ficheiros($path,$intervalo);
    my $replacement = join "", @ola;
    open ORIGINAL, "< teste.txt"
    or die "can't open original file\n";
    my $original;
    {
      local $/;
      $original = <ORIGINAL>;
    }
    close ORIGINAL;

    $original =~ s/
        $start_flag
        .*?
        (\s*)
        $stop_flag
        \n
        /$start_flag\n$replacement$1$stop_flag/gsx;

    open COPY, "> copy.txt"
    or die "can't write to copy\n";
    print COPY $original;
    close COPY;
    system "hello.bat";
}
[download]

Thank you..

If it ain't broke, there's no need to fix it. Right. Nevertheless, these lines jumped out at me:

my $aux=0;
foreach my $pos (@files){
  $files[$aux]="\t\"".$path."\\".$files[$aux]."\""."   $esquema\n";
  $aux++;
}
[download]

1. Variable interpolation

First, take the line:

$files[$aux]="\t\"".$path."\\".$files[$aux]."\""."   $esquema\n";

This reminds me of something else I saw recently, which (simplified) read something like this:

my $line = $first . " " . $second . " ". $third;

As if Perl didn't allow variable interpolation! Your line can be simplified to:

$files[$aux]="\t\"$path\\$files[$aux]\"   $esquema\n";

Further, by using qq(), you would no longer have to escape the double quotes:

$files[$aux] = qq '\t"$path\\$files[$aux]"   $esquema\n';

which I for one find a bit easier on the eye.

2. for/foreach loops

But now to come to your foreach loop (inner bit modified as above):

my $aux=0;
foreach my $pos (@files){
  $files[$aux] = qq '\t"$path\\$files[$aux]"   $esquema\n';
  $aux++;
}
[download]

I'm far from being a Perl guru, but I think I may safely say that this is ugly :) You can do this far more efficiently in Perl:

foreach my $pos ( 0 .. $#files ) {
  $files[$pos] = qq '\t"$path\\$files[$pos]"   $esquema\n';
}
[download]

<parenthesis>Occasionally, you might also come across some rather quaint variations of the above, along the lines of:

foreach ( my $pos = 0; $pos < @files; $pos++ ) { ... }

but it's best to forget these unless you want to increment your counter ($pos) by anything other than 1.</parenthesis>

However, you would still not be using the full power of Perl. To quote Marc Jason Dominus: "Any time you have a C-like for loop that loops over the indices of an array, you're probably making a mistake." A more perlish way to do what you want would be:

foreach my $file ( @files ) {
   $file = qq '\t"$path\\$file"   $esquema\n';
}
[download]

In fact, you can use Perl's built-in $_ variable to shorten that even further:

for ( @files ) {    # 'for' and 'foreach' are equivalent
   $_ = qq '\t"$path\\$_"   $esquema\n';
}
[download]

From which, to end this far longer than intially intended post, it is only a short step to using map:

@files = map { qq '\t"$path\\$_"   $esquema\n' } @files;

HTH

dave