Note that unpack might be more suitable to extract the values than substr.

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

Hi, Sorry. Here's the code:

my $filename = "Words.txt";
open(my $fh, '<', $filename) or die "Could not open file '$filename' $
+!";

binmode $fh;

my $data = <$fh>;
$data =~ s/\x00/\ /gi;

close $fh;

my $length = length($data);

my $count = 0;

for(my $i=0;$i < $length/36;$i++){

my $name = substr($data,$i*36,28);
my $book = ord(substr($data,$i*36 + 28,1)) + 1;
my $v1 = ord(substr($data,$i*36 + 29,1)) + 1;
my $v2 = ord(substr($data,$i*36 + 30,1)) + 1;

print $name . " - " . "$book\:$v1\:$v2\n";
$count += 1;
}
[download]

Stops after 38 records - it should go up to some thousands... The lenght says its about only 1300 characters - it should be also some thousands... Regards, Kepler

> my $data = <$fh>;

Do you know what implements the diamond operator? readline! You're reading up to the first newline only, binmode doesn't change this. Use read instead.

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

What do you get if you try this on the file?

#!/usr/bin/perl

use strict;
use warnings;

my $fname = "Words.txt";
my $fsize = -s $fname;

open( my $fh, '<', $fname ) or die "$fname: $!\n";
binmode $fh;
$/ = undef;

my $data = <$fh>;
my $length = length( $data );
my $nnulls = tr/\x00/ /;

print "Read $length of $fsize bytes, changed $nnulls nulls to spaces\n
+";
[download]

That will just report the basic numbers to see whether you've read the entire file, and how many null bytes it contains.

As for the stuff you're doing with ord(substr(...)) + 1; ... that looks like the sort of thing that should be done when you still have null bytes in the file (i.e. without converting the nulls to spaces). And it looks like the sort of thing you should be doing with unpack, as others have mentioned.

If it's binary data, it might have a ^D, which indicates the end of a stream of data. That's on Linux .. and I think a ^Z is used for Windows. I'm not positive about either of those, but it's somewhere to start looking.

If this is a file of records, hopefully the records are of a fixed length. If not, that makes things a little more challenging.

Some code would be helpful -- there are many ways to solve this, but we can offer much more useful solutions if we know where you're starting from. PS And please use code tags around the code. :)

If using a console text input stream, a ^D on Unix or a ^Z on Windows will indeed result in an EOF for the user program.

With an HD file, there is no such a thing! Because all files are binary on the hard disk. The file system returns "end of file" to the function reading when all bytes (in the intrinsically binary file) on disk are consumed. The file system always calculates EOF based upon number of bytes in the file. There is no ^D or ^Z at the "end of the file". This is needed for a text input stream because there is no limit on the number of bytes (characters).

Using read and a big buffer like 50 MB could be ok on a modern computer. Reading in smaller chunks is fine, but more complicated.

If it's binary data, it might have a ^D, which indicates the end of a stream of data. That's on Linux .. and I think a ^Z is used for Windows.

Should be no problem with binmode.

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)

Right -- that was my point. If they're using readline, they're subject to the rules of reading text (break the chunks into lines, stop at the 'end of file'). If they're using read, then they'll just get chunks of the file up to the file size.

Alex / talexb / Toronto

Thanks PJ. We owe you so much. Groklaw -- RIP -- 2003 to 2013.

You've obviously got code .. why not share it with us? Just what is necessary to see how you are getting data from the file, and how you are trying to extract the fields from it.