I don't think print is the appropriate debugging tool here...

$ hexdump -C foo.txt 
00000000  46 6f 6f 0d 42 61 72 0d  51 75 7a 0d              |Foo.Bar.Q
+uz.|
0000000c

$ cat read.pl 
#!/usr/bin/env perl
use warnings;
use strict;
use Data::Dumper;
$Data::Dumper::Useqq=1;

open my $fh, '<', 'foo.txt' or die $!;
print Dumper([PerlIO::get_layers($fh)]) unless $] lt '5.008';
while (<$fh>) {
    print Dumper($_);
}
close $fh;
[download]

Output on Win 7 Strawberry Perl 5.10, 5.14, 5.20, and 5.26:

$VAR1 = [
          "unix",
          "crlf"
        ];
$VAR1 = "Foo\rBar\rQuz\r";
[download]

And on Linux, the output is as follows:

# 5.6.2:
$VAR1 = "Foo\rBar\rQuz\r";

# 5.8.1 and 5.8.9:
$VAR1 = [
          "stdio"
        ];
$VAR1 = "Foo\rBar\rQuz\r";

# 5.10.1 thru 5.26:
$VAR1 = [
          "unix",
          "perlio"
        ];
$VAR1 = "Foo\rBar\rQuz\r";
[download]

So none of the tested versions handle a CR line ending. See also open: the default layers are :raw on Unix and :crlf on Windows. For details see also PerlIO and open (the pragma). (Update: and LanX provided another excellent link with Newlines in perlport)

If the file is plain ASCII, this works across all of the above configurations:

use warnings;
use strict;

open my $fh, '<', 'foo.txt' or die $!;
binmode $fh;
$/="\x0D";
while (<$fh>) {
    chomp;
    ...
}
close $fh;
[download]

I remember previous versions of Perl working fine when reading <CR> terminated lines.

I think that the while statement correctly splits the lines, but it is just the printing which goes over the same line again and again due to the carriage return without any line feed. Try this:

while (my $line = <$in>) { $line =~ s/[\r\n]+$//; print "$line\n";}
[download]

update

see also $/ and perlport#Newlines

I've got a bit of an issue because in my fiddling with this thing, I over-wrote the file. I can get it back and try chomp(), but my regex should be even better? Here is more of the actual code... #lines were used in my testing...

while (my $line = <IN>)
{
#  print "line=$line\n";
   next if $line =~/^\s*\w+:/;  # The Run_Time: line
   next if $line =~/^\s*$/;     # A blank line
   $line =~ s/\s*$//;           # No trailing spaces or line ending
   $line =~ s/^\s*//;           # No leading space
   next if $line =~ /^Call/;    # Skip the CSV header line
   
   
   my($call,$bracket) = (split /\|/,$line)[0,-1];
#   print "$call, $bracket\n";   #### nothing printed here either
   # more processing ... not shown..
}
[download]

Setting $/ explicitly to the Mac line ending should be easier.*

Both readline and chomp will respect it

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Wikisyntax for the Monastery}

update

*) see also haukex's code at the end of Re: Reading text file with <CR> line endings

Hello Marshall,

This should do the work for you:

#!/usr/bin/perl
use strict;
use warnings;
use feature 'say';

sub myChmop {
    my ($str) = @_;
    chomp $str;
    return $str;
}

sub myCrRemove {
    my ($str) = @_;
    $str =~ s/\r|\n//g;
    return $str;
}

my $str = "abcd\r\n";
my $chompReturn = myChmop($str);
say "[$chompReturn]";

my $crRemoveReturn = myCrRemove($str);
say "[$crRemoveReturn]";

__END__

$ perl test.pl
]abcd
[abcd]
[download]

Also read this "similar question" Carrige Return and Line Feed in Perl..

Hope this helps, BR.

This untested fragment should work:

#!/usr/bin/env perl 

use warnings;
use strict;
use open IO => ':bytes';
use autodie;

open my $fh, '<', 'foo.txt';

$/ = "\x0D";

while (<$fh>) {
    chomp;
    ...;
}

close $fh;

__END__
[download]

I don't remember this IO layer stuff very well. Best regards, Karl

Yes, that approach would work. When I considered that idea, I was thinking of opening the file in bin mode. Read a block of data. Use substr index to find first <CR> and then run substr index to find first <LF>, from those index numbers I could figure out what kind of file it was. I'd probably close file and report back the line ending value from a "discover_line_ending sub". And have main program re-open the file in text mode with correct input line separator. BTW, substrindex is a very fast critter because it is "stupid" - searching to the end of the input block with no search value found is "fast".

Another idea I considered was to slurp in the whole file as binary - the max size of this file is small enough to do that. Then use split to do my own line division. The input line separator cannot be a regex, but split can use a regex.

As I mention in my now updated question post, I found out where this "weird duck" file came from. There is no need for me to solve this tricky problem at this time. Users do the darndest things! The "hey, don't do that!" answer appears to meet all of my requirements and user is fine with that "solution". Not every complicated problem requires an actual implementation. At some point in the future, I may have to actually implement a solution for this problem and what I've learned in this thread will be helpful. I think there are also fine points in this thread that could be useful for other problems. In my opinion, you can never "know too much" about Perl.

substr doesn't search at all. I suppose you meant index?