• The mapping of IP addresses to Computer names is in a relatively small file named 'ip.dat'.
• You don't want to overwrite your data file.
• You trust Ovid's untested code :)

use strict;
use warnings;

my $ips      = 'ip.dat';
my $in_data  = 'DJB.dat';
my $out_data = 'DJB_new.dat';
my %ip_map;

# you should ask for a shared lock in case someone updates this
open IPS, "< $ips" or die "Couldn't open $ips for reading: $!";

while ( <IPS> ) {
    my ( $ip, $name ) = split /:/, $_, 2;
    warn "$ip is already mapped to $ip_map{$ip }" if exists $ip_map{ $
+ip };
    chomp $name;
    $ip_map{ $ip } = $name;
}

close IPS;

open IN_DATA, "< $in_data"   or die "Couldn't open $in_data for readin
+g: $!";
open OUT_DATA, "> $out_data" or die "Couldn't open $out_data for writi
+ng: $!";

while ( <IN_DATA> ) {
    my $replace;
    my $ip = '';
    ( $replace, $ip ) = ( /^\+([^:]+):([\d.]+)/ );
    if ( exists $ip_map{ $ip } ) {
        s/$replace/$ip_map{ $ip }/;
    }
    print OUT_DATA $_;
}

close OUT_DATA;
close IN_DATA;
[download]

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

Should run fast! (Tested also ;-)

use strict;
die "Syntax: $0 <names> < djb-file > output-file" unless @ARGV == 1;
my %name_to_ip;
open(IN, "<".shift) or die;
while (<IN>)
{
    chomp;
    my ($ip, $name) = split /:/;
    $name_to_ip{$ip} = $name;
}
close IN or die;

while (<>)
{
    chomp;
    my ($name, $ip) = split /:/;
    print $name_to_ip{$ip} || $name, ":", $ip, "\n";
}
[download]

For whatever reason, the line:

 
open(IN, "<".shift) or die;
[download]

doesn't work for me in ActiveState Perl 5.6 /NT workstation when I call the above program as

perl tempo.pl ip.dat djb.dat
[download]

However, the program works great when I replace that line with:

open(IN, "<ip.dat") or die;
[download]

and call it as:

perl tempo.pl djb.dat
[download]

open (INFILE,"<infile.txt");
open (OUTFILE, ">outfile.txt);

while (<INFILE>) {
 # $_ will hold one line of your file, and the loop will (slowly) go t
+hrough your entire file
 
 #Mangle $_ here e.g.
 s/^\+host-1-3-1-10:/$ipnum/;

 #print it into the other file
 print OUTFILE $_;
}
[download]

Or variations on the above, to suit.

Update: I forgot about the ip bit. Depending on how many there are you could push them into a hash or use some database solution, as tilly didn't quite mention in the chatbox.

____________________
Jeremy
I didn't believe in evil until I dated it.

If the substitution table is too large to load into a hash in its entirety, you could load in a portion of it, process the second file, and load in additional portions until it was completed. This way, you would have to make n passes of the secondary file, where the substitution file is loaded into n pieces.

This is, of course, assuming that you can't fit the substitution file entirely into RAM in a hash, and that using a tied hash is out of the question because of speed concerns. However, 130K lookups in a tied hash cannot take that long, so it might be a vialbe solution. If you were processing a file with 130M lines, then you are going to have to think of something else.

A curious observation, though, is that in your example the "output" file is the same as the input file, just reorganized. I'm sure this is because of simplification on your part.

Can you answer these? It would help me possibly provide a suitable suggstion.