head

Image

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

NativeHelpers::Array - helper subroutines for native arrays


This provides a number of exported subroutines that may be useful for
working with native L<CArray>s.  The subroutines aren't particularly
complicated but it saves having to have the same code in multiple modules.


sub copy-to-carray(@items, Mu $type) returns CArray is export


Copy the array to the new CArray typed as per C<$type>. If the supplied type
is not a valid native type there will be an exception.  If the elements of the
array are out of range for the type then the values in the CArray may be
truncated.


sub copy-to-array(CArray $carray, Int $items) returns Array is export


Copy the supplied CArray of the given length to a new Array.


sub copy-buf-to-carray(Buf $buf) returns CArray[uint8] is export


Copy the elements of the supplied L<Buf> to a L<CArray[uint8]>.


sub copy-carray-to-buf(CArray $array, Int $no-elems) returns Buf is export


Copy the L<CArray[uint8]> of the specified number of elements to a L<Buf>




module NativeHelpers::Array {

    use NativeCall;

    sub copy-to-carray(@items, Mu $type --> CArray ) is export {
        my $array = CArray[$type].new;
        $array[$_] = @items[$_] for ^@items.elems;
        $array;
    }

    sub copy-to-array(CArray $carray, Int $items --> Array ) is export {
        my @array;
        @array[$_] = $carray[$_] for ^$items;
        @array;
    }

    sub copy-buf-to-carray(Buf $buf --> CArray[uint8] ) is export {
        my $carray = CArray[uint8].new;
        $carray[$_] = $buf[$_] for ^$buf.elems;
        $carray;
    }

    sub copy-carray-to-buf(CArray $array, Int $no-elems --> Buf ) is export {
        my $buf = Buf.new;
        $buf[$_] = $array[$_] for ^$no-elems;
        $buf;
    }

}
# vim: expandtab shiftwidth=4 ft=raku


Array

use v6;
use NativeCall;
use NativeCall::Types;



This module provides a role for binary serialization of simple structs. At this stage, only scalar native integer and numeric attributes are supported.


This role is applicable to classes that contain only simple native numeric
attributes, representing the structure of the data.


# open a GIF read the 'screen' header
my class GifHeader
    does Native::Packing[Endian::Vax] {
    has uint16 $.width;
    has uint16 $.height;
    has uint8 $.flags;
    has uint8 $.bgColorIndex;
    has uint8 $.aspect;
}


my $fh = "t/lightbulb.gif".IO.open( :r :bin);
$fh.read(6);  # skip GIF header


say "GIF has size {$screen.width} X {$screen.height}";


Class level method. Unpack bytes from a buffer. Create a struct object.


Object level method. Serialize the object to a buffer.


Class level method. Read data from a binary file. Create an object.


Object level method. Write the object to a file


Determine the overall size of the struct. Sum of all its attributes.


Return the endian of the host Endian::Network(0) or Endian::Vax(1).



my enum Native::Packing::Endian is export(:Endian) <Network Vax Host>;

role Native::Packing:ver<0.0.5> {

    sub detect-host-endian {
        my $i = CArray[uint16].new(0x1234);
        my $j = nativecast(CArray[uint8], $i);
        if $j[0] == 0x12 {
            warn "unexpected high byte: $j[1]"
                unless $j[1] == 0x34;
            Network
        } else {
            warn "unexpected byte order: {$j>>.fmt('0x%X').join(',')}"
                unless $j[0] == 0x34 && $j[1] == 0x12;
            Vax;
        }
    }

    my constant HostEndian = detect-host-endian();

    method host-endian { HostEndian }

    multi sub unpack-foreign-attribute(Native::Packing $sub-rec, Buf $buf, UInt $off is rw) {
        my $bytes := $sub-rec.bytes;
        my $v := $sub-rec.unpack($buf.subbuf($off, $bytes));
        $off += $bytes;
        $v;
    }

    multi sub unpack-foreign-attribute($type, Buf $buf, UInt $off is rw) is default {
        my uint $byte-count = nativesizeof($type);
        my buf8 $native .= new: $buf.subbuf($off, $byte-count).reverse;
        $off += $byte-count;
        my $cval = nativecast(CArray[$type], $native);
        $cval[0];
    }

    sub storage-atts($class, :%pos, :@atts) {
        storage-atts($_, :%pos, :@atts) for $class.^parents;
        for $class.^attributes(:local) -> $att {
            my $name := $att.name;
            with %pos{$name} {
                @atts[$_] = $att;
            }
            elsif $name {
                %pos{$name} = +@atts;
                @atts.push: $att;
            }
        }
        @atts;
    }
    method !attributes {
        storage-atts(self.WHAT);
    }

    # convert between differing architectures
    method unpack-foreign(\buf, UInt :$offset is copy = 0) {
        # ensure we're working at the byte level
        my %args = self!attributes.map: {
            my $type = .type;
            my str $name = .name.substr(2);
            $name => unpack-foreign-attribute($type, buf, $offset);
        }
        self.new(|%args);
    }

    multi sub read-foreign-attribute(Native::Packing $sub-rec, \fh) {
        $sub-rec.read(fh);
    }

    multi sub read-foreign-attribute($type, \fh) is default {
        my uint $byte-count = nativesizeof($type);
        my $native = CArray[uint8].new: fh.read($byte-count).reverse;
        my $cval = nativecast(CArray[$type], $native);
        $cval[0];
    }

    # convert between differing architectures
    method read-foreign(\fh) {
        # ensure we're working at the byte level
        my %args = self!attributes.map: {
            my str $name = .name.substr(2);
            my $type = .type;
            $name => read-foreign-attribute($type, fh);
        }
        self.new(|%args);
    }

    multi sub unpack-host-attribute(Native::Packing $sub-rec, Buf $buf, UInt $off is rw) {
        my $bytes := $sub-rec.bytes;
        my $v := $sub-rec.unpack($buf.subbuf($off, $bytes));
        $off += $bytes;
        $v;
    }

    multi sub unpack-host-attribute($type, Buf $buf, UInt $off is rw) is default {
        my uint $byte-count = nativesizeof($type);
        my Buf $raw = $buf.subbuf($off, $byte-count);
        my $cval = nativecast(CArray[$type], $raw);
        $off += $byte-count;
        $cval[0];
    }

    # matching architecture - straight copy
    method unpack-host(\buf, UInt :$offset is copy = 0) {
        # ensure we're working at the byte level
        my %args = self!attributes.map: {
            my str $name = .name.substr(2);
            my $type = .type;
            $name => unpack-host-attribute($type, buf, $offset);
        }
        self.new(|%args);
    }

    multi sub read-host-attribute(Native::Packing $sub-rec, \fh) {
        $sub-rec.read(fh);
    }

    multi sub read-host-attribute($type, \fh) is default {
        my uint $byte-count = nativesizeof($type);
        my buf8 $raw = fh.read( $byte-count);
        my $cval = nativecast(CArray[$type], $raw);
        $cval[0];
    }

    # matching architecture - straight copy
    method read-host(\fh) {
        # ensure we're working at the byte level
        my %args = self!attributes.map: {
            my str $name = .name.substr(2);
            my $type = .type;
            $name => read-host-attribute($type, fh);
        }
        self.new(|%args);
    }

    multi sub pack-foreign-attribute(Native::Packing $, Buf $buf, Native::Packing $sub-rec) {
        $sub-rec.pack($buf);
    }

    multi sub pack-foreign-attribute($type, Buf $buf, $val) is default {
        my uint $byte-count = nativesizeof($type);
        my $cval = CArray[$type].new;
        $cval[0] = $val;
        my $bytes = nativecast(CArray[uint8], $cval);
        loop (my int $i = 1; $i <= $byte-count; $i++) {
            $buf.append: $bytes[$byte-count - $i];
        }
        $buf;
    }

    # convert between differing architectures
    method pack-foreign(buf8 $buf = buf8.new) {
        my $pad = 0 without self;
        for self!attributes {
            my $val = $pad // .get_value(self);
            pack-foreign-attribute(.type, $buf, $val);
        }
        $buf;
    }

    # convert between differing architectures
    method write-foreign($fh) {
        $fh.write: self.pack-foreign;
    }

    multi sub pack-host-attribute(Native::Packing $, Buf $buf, Native::Packing $sub-rec) {
        $sub-rec.pack($buf);
    }

    multi sub pack-host-attribute($type, Buf $buf, $val) is default {
        my uint $byte-count = nativesizeof($type);
        my $cval = CArray[$type].new;
        $cval[0] = $val;
        my $bytes = nativecast(CArray[uint8], $cval);
        loop (my int $i = 0; $i < $byte-count; $i++) {
            $buf.append: $bytes[$i];
        }
        $buf;
    }

    method pack-host(buf8 $buf = buf8.new) {
        my $pad = 0 without self;
        for self!attributes {
            my $val = $pad // .get_value(self);
            pack-host-attribute(.type, $buf, $val);
        }
        $buf;
    }

    # convert between differing architectures
    method write-host($fh) {
        $fh.write: self.pack-host;
    }

    method bytes {
        [+] self!attributes.map: {
            given .type {
                when Native::Packing { .bytes }
                default { nativesizeof($_) }
            }
        }
    }
}

role Native::Packing[Native::Packing::Endian $endian]
    does Native::Packing {

    method unpack(\buf, UInt :$offset = 0) {
        $endian == self.host-endian | Host
            ?? self.unpack-host(buf, :$offset)
            !! self.unpack-foreign(buf, :$offset)
    }

    method read(\fh, UInt :$offset) {
        fh.read($_) with $offset;
        $endian == self.host-endian | Host
            ?? self.read-host(fh)
            !! self.read-foreign(fh)
    }

    method pack($buf = buf8.new) {
        $endian == self.host-endian | Host
            ?? self.pack-host($buf)
            !! self.pack-foreign($buf)
    }

    method write(\fh) {
        $endian == self.host-endian | Host
            ?? self.write-host(fh)
            !! self.write-foreign(fh)
    }

}




Packing

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Native-Packing-raku

Description

Example

Endianess

Native::Packing v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation