File Coverage

blib/lib/Finnigan/GenericDataDescriptor.pm

Criterion	Covered	Total	%
statement	51	61	83.6
branch	25	30	83.3
condition			n/a
subroutine	10	11	90.9
pod	6	6	100.0
total	92	108	85.1

package Finnigan::GenericDataDescriptor;

use strict;
use warnings FATAL => qw( all );
our $VERSION = 0.0206;

use Finnigan;
use base 'Finnigan::Decoder';

use overload ('""' => 'stringify');

sub decode {
  my ($class, $stream) = @_;

  my $fields = [
                "type"   => ['V', 'UInt32'],
                "length" => ['V', 'UInt32'],
                "label"  => ['varstr', 'PascalStringWin32'],
               ];

  my $self = Finnigan::Decoder->read($stream, $fields);

  return bless $self, $class;
}

sub type {
  shift->{data}->{"type"}->{value};
}

sub length {
  shift->{data}->{"length"}->{value};
}

sub label {
  shift->{data}->{"label"}->{value};
}

sub stringify {
  my $self = shift;
  my $type = $self->type;
  my $length = $self->length;
  my $label = $self->label;
  return "$label [type $type, length $length]";
}

sub definition {
  my ($self, $ord) = @_;

  my $key = defined $ord ? "$ord|$self->{data}->{label}->{value}" : $self->{data}->{label}->{value};
  my $type = $self->type;

  # a gap in the listing or a section title
  if ( $type == 0 ) {
    return $key => undef;
  }

  # c char (a signed byte)
  if ( $type == 0x1 ) {
    return $key => ['c', 'Int8'];
  }

  # bool (true/false)
  if ( $type == 0x2 ) {
    return $key => ['C', 'UInt8 (true/false)'];
  }

  # yes/no
  if ( $type == 0x3 ) {
    return $key => ['C', 'UInt8 (yes/no)'];
  }

  # on/off
  if ( $type == 0x4 ) {
    return $key => ['C', 'UInt8 (on/off)'];
  }

  # c unsigned char
  if ( $type == 0x5 ) {
    return $key => ['C', 'UInt8'];
  }

  # c short
  if ( $type == 0x6 ) {
    return $key => ['s<', 'Int16'];
  }

  # c unsigned short
  if ( $type == 0x7 ) {
    return $key => ['v', 'UInt16'];
  }

  # c long
  if ( $type == 0x8 ) {
    return $key => ['l<', 'Int32'];
  }

  # c unsigned long
  if ( $type == 0x9 ) {
    return $key => ['V', 'UInt32'];
  }

  # c float
  if ( $type == 0xA ) {
    return $key => ['f<', 'Float32'];
  }

  # c double
  if ( $type == 0xB ) {
    return $key => ['d<', 'Float64'];
  }

  # asciiz string
  if ( $type == 0xC ) {
    my $l = $self->length;
    return $key => ['string', "ASCIIZ:$l"];
  }

  # wide string, zero-terminated
  if ( $type == 0xD ) {
    my $l = $self->length * 2;
    return $key => ['string', "UTF-16-LE:$l"];
  }

  die "unkown data type at $self->{addr}, " . $self;
}

1;
__END__