$pad = ' ' x 80;  ## make the length the same as your max expected

$c = "test test test";
$fmt = "A4 x1 A4 x1 A4 x1 A4";
@c = unpack($fmt, "$c$pad");
print join ("*",@c), "\n";

$d = "test test test ";
$fmt = "A4 x1 A4 x1 A4 x1 A4";
@d = unpack($fmt, "$d$pad");
print join ("*",@d), "\n";
[download]

--Jim

Update: BTW, I would avoid using $a as a variable since it (and $b) has an evil association with sort. Check the link for details.

Thanks Jim. That'd definitely kill the 'x' issue, and I'll probably put that there. However, if I'm going to handle this, I'd rather trap short entries and yell at the customer. Currently, I yell at them for a variety of reasons via email within the script. I'd like to junk any file that has short records like this, and notify the client. I guess I'm looking for the prettiest way that someone can think of, and wondering if there's something out there that quickly calculates the expected length given a pack/unpack style format string.

As for the $a/$b - thanks for kicking me =) I know this, and generally do not use such nefarious variables. They show up only when I'm hitting the interpreter directly on my stinky Win32 box in order to test some snippet (like this one). =)

$c = "test test test";

$c = correct_length($c);

$fmt = "A4 x1 A4 x1 A4 x1 A4";
@c = unpack($fmt, "$c");
print join ("*",@c), "\n";

$d = "test test test ";
$d = correct_length($d);
$fmt = "A4 x1 A4 x1 A4 x1 A4";
@d = unpack($fmt, "$d");
print join ("*",@d), "\n";

sub correct_length {
    my ($string) = shift;
    $string .= ' ' unless length($string) >= 15;
    return($string);
}
[download]

my %formats = (
   "item_name"  => 15, # where 15 is the length
   "item_name2" => 20,
   # etc.
);

# code removed for demonstration

$c = correct_length($c,'item_name');

sub correct_length {
    my ($string,$item) = @_;
    $string .= ' ' unless length($string) >= $formats{$item};
    return($string);
}
[download]

Thanks for the ideas =)
Perhaps I should be a little more detailed though as to why I would rather not hard-code the format lengths.
I'm taking a slew of files in from an FTP site, and their file names are the only indication of their formatting.
Let's assume the file "2001-123456789-W2.txt"

unless($file =~ /^(\d{4})-\d{9}-([^\.]+)/){
    log_data("$file does not conform to file naming standards");
    next;
}
$lower_format = lc("$1$2");
[download]

This allows me to throw the file contents into a hash, keyed to "2001w2". Later on, I'm going to take the array of records matched to each hash key, and break them up based on their format. I'm disgustingly doing this via an eval, in a function which was passed the hash-key as $format:

eval "\$current_format = \$fmt_$format";
@line = unpack($current_format, $data);
[download]

Earlier in the script, I've defined $fmt_2001w2 as a format string. There are numerous format strings of various shapes and sizes here.

I could take the expected string sizes from our specs, and hardcode the values in here, checking the format and then the string lengths as I go along. But when the customer decides that we need to add this and move that, I have to (a) adjust the $fmt_2001w2 variable, and (b) change this hard-coded length value.

I am lazy, and wish to do this in one place, not two. I don't want to miss one ;)

Yes, padding the end of the line will work. Yes, hard-coding the lengths of the formats will work. Thanks both of you for helping =) Now though, it's no longer about making this work (or more specifically, not letting this die), and it's about how I can accomplish the objective goal of making sure that such a thing doesn't happen in a general sense - and if it involves calculating the length from the format string, what might be the quickest or keenest way to do so =)

-=rev=-

If your format string doesn't have terribly fancy template characters (i.e. doesn't have things like "w"), and yours which are all "a" and "x" fit the bill, you can do

$expected_length = length(pack($fmt))
[download]

This returns 14 for the format string of "a4 x1 a4 x1 a4".
Hope this helps...

-JAS