home *** CD-ROM | disk | FTP | other *** search
/ PC Professionell 2004 December / PCpro_2004_12.ISO / files / webserver / tsw / TSW_3.4.0.exe / Apache2 / perl / Struct.pm < prev    next >
Encoding:
Perl POD Document  |  2003-03-07  |  15.0 KB  |  529 lines
  1. package Win32::API::Struct;
  2.  
  3. # See the bottom of this file for the POD documentation.  Search for the
  4. # string '=head'.
  5.  
  6. #######################################################################
  7. #
  8. # Win32::API::Struct - Perl Win32 API struct Facility
  9. # 
  10. # Version: 0.40 
  11. # Date: 07 Mar 2003
  12. # Author: Aldo Calpini <dada@perl.it>
  13. # $Id: Struct.pm,v 1.0 2001/10/30 13:57:31 dada Exp $
  14. #######################################################################
  15.  
  16. $VERSION = "0.40";
  17.  
  18. use Win32::API::Type;
  19.  
  20. use Carp;
  21.  
  22. require Exporter;       # to export the constants to the main:: space
  23. require DynaLoader;     # to dynuhlode the module.
  24. @ISA = qw( Exporter DynaLoader );
  25.  
  26. my %Known = ();
  27.  
  28. sub DEBUG { 
  29.     if ($Win32::API::DEBUG) { 
  30.         printf @_ if @_ or return 1; 
  31.     } else {
  32.         return 0;
  33.     }
  34. }
  35.  
  36. sub typedef {
  37.     my $class = shift;
  38.     my $struct = shift;
  39.     my($type, $name);
  40.     my $self = {
  41.         align     => undef,
  42.         typedef => [],
  43.     };
  44.     while(defined($type = shift)) {
  45.         $name = shift;
  46.         $name =~ s/;$//;
  47.         push( @{ $self->{typedef} }, [ recognize($type, $name) ] );
  48.     }
  49.  
  50.     $Known{$struct} = $self;
  51.     return 1;
  52. }
  53.  
  54.  
  55. sub recognize {
  56.     my($type, $name) = @_;
  57.     my($size, $packing);
  58.     if(exists $Known{$type}) {
  59.         $packing = ">";
  60.         return $name, $packing, $type;
  61.     } else {
  62.         $packing = Win32::API::Type::packing($type);
  63.         return undef unless defined $packing;           
  64.         if($name =~ s/\[(.*)\]$//) {
  65.             $size = $1;     
  66.             $packing = $packing."*".$size;  
  67.         }
  68.         DEBUG "(PM)Struct::recognize got '$name', '$type' -> '$packing'\n";
  69.         return $name, $packing, $type;
  70.     }   
  71. }
  72.  
  73. sub new {
  74.     my $class = shift;
  75.     my($type, $name);
  76.     my $self = {
  77.         typedef => [],
  78.     };
  79.     if($#_ == 0) {
  80.         if(exists $Known{$_[0]}) {
  81.             DEBUG "(PM)Struct::new: got '$_[0]'\n";
  82.             $self->{typedef} = $Known{$_[0]}->{typedef};
  83.             foreach my $member (@{ $self->{typedef} }) {
  84.                 ($name, $packing, $type) = @$member;
  85.                 if($packing eq '>') {
  86.                     $self->{$name} = Win32::API::Struct->new($type);
  87.                 }
  88.             }
  89.             $self->{__typedef__} = $_[0];
  90.         } else {
  91.             carp "Unknown Win32::API::Struct '$_[0]'";
  92.             return undef;
  93.         }
  94.     } else {
  95.         while(defined($type = shift)) {
  96.             $name = shift;
  97.             # print "new: found member $name ($type)\n";
  98.             if(not exists $Win32::API::Type::Known{$type}) {
  99.                 warn "Unknown Win32::API::Struct type '$type'";
  100.                 return undef;
  101.             } else {
  102.                 push( @{ $self->{typedef} }, [ $name, $Win32::API::Type::Known{$type}, $type ] );
  103.             }
  104.         }
  105.     }
  106.     return bless $self;
  107. }
  108.  
  109. sub members {
  110.     my $self = shift;
  111.     return map {$_->[0]} @{ $self->{typedef} };
  112. }
  113.  
  114. sub sizeof {
  115.     my $self = shift;
  116.     my $size = 0;
  117.     my $align = 0;
  118.     my $first = undef;
  119.     foreach my $member (@{ $self->{typedef} }) {
  120.         my($name, $packing, $type) = @$member;
  121.         
  122.         if(ref( $self->{$name} ) eq "Win32::API::Struct") {
  123.             $size += $self->{$name}->sizeof();
  124.             # $align = $self->{$name}->sizeof() if $self->{$name}->sizeof() > $align;
  125.         } else {        
  126.             if($packing =~ /\w\*(\d+)/) {           
  127.                 $size += Win32::API::Type::sizeof($type) * $1;
  128.                 $first = Win32::API::Type::sizeof($type) * $1 unless defined $first;
  129.                 DEBUG "(PM)Struct::sizeof: sizeof with member($name) now = ". $size. "\n";
  130.             } else {            
  131.                 $size += Win32::API::Type::sizeof($type);
  132.                 $first = Win32::API::Type::sizeof($type) unless defined $first;
  133.                 $align = Win32::API::Type::sizeof($type)
  134.                     if Win32::API::Type::sizeof($type) > $align;                
  135.                 DEBUG "(PM)Struct::sizeof: sizeof with member($name) now = ". $size. "\n";
  136.             }
  137.         }
  138.     }
  139.     DEBUG "(PM)Struct::sizeof first=$first align=$align\n";
  140.     #DEBUG "(PM)Struct::sizeof returning %d\n", $first + (scalar(@{ $self->{typedef} })-1) * $align;    
  141.     #return $first + (scalar(@{ $self->{typedef} })-1) * $align;    
  142.     DEBUG "(PM)Struct::sizeof returning %d\n", scalar(@{ $self->{typedef} }) * $align;    
  143.     if(defined $align and $align > 0) {
  144.         return scalar(@{ $self->{typedef} }) * $align;
  145.     } else {
  146.         return $size;
  147.     }
  148.     return $size;
  149. }
  150.  
  151. sub align {
  152.     my $self = shift;
  153.     my $align = shift;
  154.     
  155.     if(not defined $align) {
  156.         return $self->{align} unless $self->{align} eq 'auto';
  157.         $align = 0;
  158.         foreach my $member (@{ $self->{typedef} }) {
  159.             my($name, $packing, $type) = @$member;
  160.  
  161.             if(ref( $self->{$name} ) eq "Win32::API::Struct") {
  162.                  #### ????
  163.             } else {        
  164.                 if($packing =~ /\w\*(\d+)/) {           
  165.                     #### ????
  166.                 } else {            
  167.                     $align = Win32::API::Type::sizeof($type)
  168.                         if Win32::API::Type::sizeof($type) > $align;                
  169.                 }
  170.             }
  171.         }
  172.         return $align;    
  173.     } else {
  174.         $self->{align} = $align;    
  175.     
  176.     }
  177. }
  178.  
  179. sub getPack {
  180.     my $self = shift;
  181.     my $packing = "";
  182.     my($type, $name);
  183.     my @items = ();
  184.     my @recipients = ();    
  185.     
  186.     my $align = $self->align();
  187.     
  188.     foreach my $member (@{ $self->{typedef} }) {
  189.         ($name, $type, $orig) = @$member;
  190.         if($type eq '>') {
  191.             my($subpacking, $subitems, $subrecipients) = $self->{$name}->getPack();
  192.             
  193.             DEBUG "(PM)Struct::getPack($self->{__typedef__}) ++ $subpacking\n";
  194.             
  195.             $packing .= $subpacking;
  196.             push(@items, @$subitems);
  197.             push(@recipients, @$subrecipients);
  198.         } else {
  199.             if($type =~ /\w\*(\d+)/) {
  200.                 my $size = $1;
  201.                 $type = "a$size";
  202.             }
  203.             
  204.             DEBUG "(PM)Struct::getPack($self->{__typedef__}) ++ $type\n"; 
  205.             
  206.             if($type eq 'p') {
  207.                 $type = "L";
  208.                 push(@items, Win32::API::PointerTo($self->{$name}));
  209.             } else {
  210.                 push(@items, $self->{$name});
  211.             }
  212.             $packing .= $type;
  213.             
  214.             if($Win32::API::Type::PackSize{$type} < $align) {
  215.                 $packing .= ("x" x ($align - $Win32::API::Type::PackSize{$type}));
  216.             }
  217.             
  218.             push(@recipients, $self);
  219.         }
  220.     }
  221.     DEBUG "(PM)Struct::getPack: $self->{__typedef__}(buffer) = pack($packing, @items)\n";
  222.     return($packing, [@items], [@recipients]);
  223. }
  224.     
  225.  
  226. sub Pack {
  227.     my $self = shift;
  228.     my($packing, $items, $recipients) = $self->getPack();
  229.     DEBUG "(PM)Struct::Pack: $self->{__typedef__}(buffer) = pack($packing, @$items)\n";
  230.     $self->{buffer} = pack($packing, @$items);
  231.     if(DEBUG) {
  232.         for my $i (0..$self->sizeof-1) {
  233.             printf "    %3d: 0x%02x\n", $i, ord(substr($self->{buffer}, $i, 1));
  234.         }
  235.     }
  236.     $self->{buffer_recipients} = $recipients
  237. }
  238.  
  239. sub getUnpack {
  240.     my $self = shift;
  241.     my $packing = "";
  242.     my($type, $name);
  243.     my @items = ();
  244.     my $align = $self->align();
  245.     foreach my $member (@{ $self->{typedef} }) {
  246.         ($name, $type, $orig) = @$member;
  247.         if($type eq '>') {
  248.             my($subpacking, @subitems) = $self->{$name}->getUnpack();
  249.             
  250.             DEBUG "(PM)Struct::getUnpack($self->{__typedef__}) ++ $subpacking\n";
  251.             $packing .= $subpacking;
  252.             
  253.             
  254.             push(@items, @subitems);
  255.         } else {
  256.             if($type =~ /\w\*(\d+)/) {
  257.                 my $size = $1;
  258.                 $type = "Z$size";
  259.             }
  260.           
  261.               #if($type eq 'p') {
  262.             #    $packing .= 'Z*';
  263.             #    DEBUG "(PM)Struct::getUnpack($self->{__typedef__}) ++ Z*\n";
  264.             #} else {
  265.                 $packing .= $type;
  266.                 DEBUG "(PM)Struct::getUnpack($self->{__typedef__}) ++ $type\n";
  267.             #}
  268.             if($type ne 'p' and $type !~ /^Z(\d+)/ and $Win32::API::Type::PackSize{$type} < $align) {
  269.                 DEBUG "(PM)Struct::getUnpack %s(%d) < %d\n",
  270.                     $type, $Win32::API::Type::PackSize{$type}, $align
  271.                 ;
  272.                 $packing .= ("x" x ($align - $Win32::API::Type::PackSize{$type}));
  273.             }
  274.  
  275.             push(@items, $name);
  276.         }
  277.     }
  278.     DEBUG "(PM)Struct::getUnpack($self->{__typedef__}): unpack($packing, @items)\n";
  279.     return($packing, @items);
  280. }
  281.  
  282. sub Unpack {
  283.     my $self = shift;
  284.     my($packing, @items) = $self->getUnpack();
  285.     my @itemvalue = unpack($packing, $self->{buffer});
  286.     DEBUG "(PM)Struct::Unpack: unpack($packing, buffer) = @itemvalue\n";
  287.     foreach my $i (0..$#items) {
  288.         my $recipient = $self->{buffer_recipients}->[$i];
  289.         DEBUG "(PM)Struct::Unpack: %s(%s) = '%s' (0x%08x)\n",
  290.             $recipient->{__typedef__},
  291.             $items[$i],
  292.             $itemvalue[$i],
  293.             $itemvalue[$i],
  294.         ;       
  295.         $recipient->{$items[$i]} = $itemvalue[$i];
  296.         DEBUG "(PM)Struct::Unpack: self.$items[$i] = $self->{$items[$i]}\n";        
  297.     }
  298. }
  299.  
  300. sub FromMemory {
  301.     my($self, $addr) = @_;
  302.     DEBUG "(PM)Struct::FromMemory: doing Pack\n";
  303.     $self->Pack();
  304.     DEBUG "(PM)Struct::FromMemory: doing GetMemory( 0x%08x, %d )\n", $addr, $self->sizeof;
  305.     $self->{buffer} = Win32::API::ReadMemory( $addr, $self->sizeof );
  306.     $self->Unpack();
  307.     DEBUG "(PM)Struct::FromMemory: doing Unpack\n";
  308.     DEBUG "(PM)Struct::FromMemory: structure is now:\n";
  309.     $self->Dump() if DEBUG;
  310.     DEBUG "\n";
  311. }
  312.  
  313. sub Dump {
  314.     my $self = shift;
  315.     my $prefix = shift;
  316.     foreach my $member (@{ $self->{typedef} }) {
  317.         ($name, $packing, $type) = @$member;
  318.         if( ref($self->{$name}) ) {
  319.             $self->{$name}->Dump($name);
  320.         } else {        
  321.             printf "%-20s %-20s %-20s\n", $prefix, $name, $self->{$name};
  322.         }
  323.     }
  324. }   
  325.  
  326.  
  327. sub is_known {
  328.     my $name = shift;
  329.     if(exists $Known{ $name }) {
  330.         return 1;
  331.     } else {
  332.         if($name =~ s/^LP//) {
  333.             return exists $Known{ $name };
  334.         }
  335.         return 0;
  336.     }
  337. }
  338.  
  339. sub TIEHASH {
  340.     return Win32::API::Struct::new(@_);
  341. }
  342.  
  343. sub EXISTS {
  344.  
  345. }
  346.  
  347. sub FETCH {
  348.     my $self = shift;
  349.     my $key = shift;
  350.     
  351.     if($key eq 'sizeof') {
  352.         return $self->sizeof;
  353.     }
  354.     my @members = map { $_->[0] } @{ $self->{typedef} };
  355.     if(grep(/^\Q$key\E$/, @members)) {
  356.         return $self->{$key};
  357.     } else {
  358.         warn "'$key' is not a member of Win32::API::Struct $self->{__typedef__}";
  359.     }   
  360. }
  361.  
  362. sub STORE {
  363.     my $self = shift;
  364.     my($key, $val) = @_;
  365.     my @members = map { $_->[0] } @{ $self->{typedef} };
  366.     if(grep(/^\Q$key\E$/, @members)) {
  367.         $self->{$key} = $val;
  368.     } else {
  369.         warn "'$key' is not a member of Win32::API::Struct $self->{__typedef__}";
  370.     }
  371. }
  372.  
  373. sub FIRSTKEY {
  374.     my $self = shift;
  375.     my @members = map { $_->[0] } @{ $self->{typedef} };
  376.     return $members[0]; 
  377. }
  378.  
  379. sub NEXTKEY {
  380.     my $self = shift;
  381.     my $key = shift;
  382.     my @members = map { $_->[0] } @{ $self->{typedef} };
  383.     for my $i (0..$#members-1) {    
  384.         return $members[$i+1] if $members[$i] eq $key;
  385.     }
  386.     return undef;
  387. }
  388.  
  389. 1;
  390.  
  391. #######################################################################
  392. # DOCUMENTATION
  393. #
  394.  
  395. =head1 NAME
  396.  
  397. Win32::API::Struct - C struct support package for Win32::API
  398.  
  399. =head1 SYNOPSIS
  400.  
  401.   use Win32::API;
  402.   
  403.   Win32::API::Struct->typedef( 'POINT', qw(
  404.     LONG x; 
  405.     LONG y; 
  406.   ));
  407.   
  408.   my $Point = Win32::API::Struct->new( 'POINT' ); 
  409.   $Point->{x} = 1024;
  410.   $Point->{y} = 768;
  411.  
  412.   #### alternatively
  413.   
  414.   tie %Point, 'Win32::API::Struct', 'POINT';
  415.   $Point{x} = 1024;
  416.   $Point{y} = 768;
  417.  
  418.  
  419. =head1 ABSTRACT
  420.  
  421. This module enables you to define C structs for use with
  422. Win32::API. 
  423.  
  424. See L<Win32::API> for more info about its usage.
  425.  
  426. =head1 DESCRIPTION
  427.  
  428. This module is automatically imported by Win32::API, so you don't 
  429. need to 'use' it explicitly. The main methods are C<typedef> and
  430. C<new>, which are documented below.
  431.  
  432. =over 4
  433.  
  434. =item C<typedef NAME, TYPE, MEMBER, TYPE, MEMBER, ...>
  435.  
  436. This method defines a structure named C<NAME>. The definition consists
  437. of types and member names, just like in C. In fact, most of the
  438. times you can cut the C definition for a structure and paste it
  439. verbatim to your script, enclosing it in a C<qw()> block. The 
  440. function takes care of removing the semicolon after the member
  441. name.
  442.  
  443. The synopsis example could be written like this:
  444.  
  445.   Win32::API::Struct->typedef('POINT', 'LONG', 'x', 'LONG', 'y');
  446.  
  447. But it could also be written like this (note the indirect object
  448. syntax), which is pretty cool:
  449.  
  450.   typedef Win32::API::Struct POINT => qw{
  451.     LONG x; 
  452.     LONG y; 
  453.   };
  454.  
  455. Also note that C<typedef> automatically defines an 'LPNAME' type,
  456. which holds a pointer to your structure. In the example above,
  457. 'LPPOINT' is also defined and can be used in a call to a 
  458. Win32::API (in fact, this is what you're really going to use when
  459. doing API calls).
  460.  
  461. =item C<new NAME>
  462.  
  463. This creates a structure (a Win32::API::Struct object) of the
  464. type C<NAME> (it must have been defined with C<typedef>). In Perl,
  465. when you create a structure, all the members are undefined. But
  466. when you use that structure in C (eg. a Win32::API call), you
  467. can safely assume that they will be treated as zero (or NULL).
  468.  
  469. =item C<sizeof>
  470.  
  471. This returns the size, in bytes, of the structure. Acts just like
  472. the C function of the same name. It is particularly useful for 
  473. structures that need a member to be initialized to the structure's
  474. own size.
  475.  
  476. =item C<align [SIZE]>
  477.  
  478. Sets or returns the structure alignment (eg. how the structure is
  479. stored in memory). This is a very advanced option, and you normally 
  480. don't need to mess with it. 
  481. All structures in the Win32 Platform SDK should work without it. 
  482. But if you define your own structure, you may need to give it an 
  483. explicit alignment. In most cases, passing a C<SIZE> of 'auto' 
  484. should keep the world happy.
  485.  
  486. =back
  487.  
  488. =head2 THE C<tie> INTERFACE
  489.  
  490. Instead of creating an object with the C<new> method, you can
  491. tie a hash, which will hold the desired structure, using the 
  492. C<tie> builtin function:
  493.  
  494.   tie %structure, Win32::API::Struct => 'NAME';
  495.  
  496. The differences between the tied and non-tied approaches are:
  497.  
  498. =over 4
  499.  
  500. =item *
  501. with tied structures, you can access members directly as
  502. hash lookups, eg.
  503.  
  504.   # tied              # non-tied
  505.   $Point{x}    vs.    $Point->{x}
  506.  
  507. =item *
  508. with tied structures, when you try to fetch or store a
  509. member that is not part of the structure, it will result
  510. in a warning, eg.
  511.  
  512.   print $Point{z};
  513.   # this will warn: 'z' is not a member of Win32::API::Struct POINT
  514.  
  515. =item *
  516. when you pass a tied structure as a Win32::API parameter, 
  517. remember to backslash it, eg.
  518.  
  519.   # tied                            # non-tied
  520.   GetCursorPos( \%Point )    vs.    GetCursorPos( $Point )
  521.  
  522. =back
  523.  
  524. =head1 AUTHOR
  525.  
  526. Aldo Calpini ( I<dada@perl.it> ).
  527.  
  528. =cut
  529.