NativeCall and nativecast walk into a bar....

use NativeCall;

constant XQC_VERSION_NUMBER = 1;

## Enumerations

enum XQC_Error is export (
   XQC_NO_ERROR => 0,
   XQC_END_OF_SEQUENCE => 1,
   XQC_NO_CURRENT_ITEM => 2,
   XQC_PARSE_ERROR => 3,
   XQC_INVALID_ARGUMENT => 4,
   XQC_NOT_NODE => 5,
   XQC_INTERNAL_ERROR => 6,
   XQC_NOT_IMPLEMENTED => 7,
   XQC_UNRECOGNIZED_ENCODING => 8,
   XQC_STATIC_ERROR => 9,
   XQC_TYPE_ERROR => 10,
   XQC_DYNAMIC_ERROR => 11,
   XQC_SERIALIZATION_ERROR => 12
);

enum XQC_ItemType is export (
   XQC_EMPTY_TYPE => 0,
   XQC_DOCUMENT_TYPE => 1,
   XQC_ELEMENT_TYPE => 2,
   XQC_ATTRIBUTE_TYPE => 3,
   XQC_TEXT_TYPE => 4,
   XQC_PROCESSING_INSTRUCTION_TYPE => 5,
   XQC_COMMENT_TYPE => 6,
   XQC_NAMESPACE_TYPE => 7,
   XQC_ANY_SIMPLE_TYPE => 8,
   XQC_ANY_URI_TYPE => 9,
   XQC_BASE_64_BINARY_TYPE => 10,
   XQC_BOOLEAN_TYPE => 11,
   XQC_DATE_TYPE => 12,
   XQC_DATE_TIME_TYPE => 13,
   XQC_DAY_TIME_DURATION_TYPE => 14,
   XQC_DECIMAL_TYPE => 15,
   XQC_DOUBLE_TYPE => 16,
   XQC_DURATION_TYPE => 17,
   XQC_FLOAT_TYPE => 18,
   XQC_G_DAY_TYPE => 19,
   XQC_G_MONTH_TYPE => 20,
   XQC_G_MONTH_DAY_TYPE => 21,
   XQC_G_YEAR_TYPE => 22,
   XQC_G_YEAR_MONTH_TYPE => 23,
   XQC_HEX_BINARY_TYPE => 24,
   XQC_NOTATION_TYPE => 25,
   XQC_QNAME_TYPE => 26,
   XQC_STRING_TYPE => 27,
   XQC_TIME_TYPE => 28,
   XQC_UNTYPED_ATOMIC_TYPE => 29,
   XQC_YEAR_MONTH_DURATION_TYPE => 30
);

enum XQC_XPath1Mode is export (
   XQC_XPATH2_0 => 0,
   XQC_XPATH1_0 => 1
);

enum XQC_OrderingMode is export (
   XQC_ORDERED => 0,
   XQC_UNORDERED => 1
);

enum XQC_OrderEmptyMode is export (
   XQC_EMPTY_GREATEST => 0,
   XQC_EMPTY_LEAST => 1
);

enum XQC_InheritMode is export (
   XQC_INHERIT_NS => 0,
   XQC_NO_INHERIT_NS => 1
);

enum XQC_PreserveMode is export (
   XQC_PRESERVE_NS => 0,
   XQC_NO_PRESERVE_NS => 1
);

enum XQC_BoundarySpaceMode is export (
   XQC_PRESERVE_SPACE => 0,
   XQC_STRIP_SPACE => 1
);

enum XQC_ConstructionMode is export (
   XQC_PRESERVE_CONS => 0,
   XQC_STRIP_CONS => 1
);
## Structures


# == /usr/include/xqc.h ==

class XQC_InputStream_s is repr<CStruct> {
    has Str                           $.encoding; # const char* encoding
    has Pointer                       $.user_data; # void* user_data
    has Pointer                       $!read; # F:unsigned int ( Typedef<XQC_InputStream>->|XQC_InputStream_s|*, void*, unsigned int)* read
    has Pointer                       $!free; # F:void ( Typedef<XQC_InputStream>->|XQC_InputStream_s|*)* free

    method read(str $b, Int $v where * > 0) {
        my &func_sig = nativecast(:(XQC_InputStream_s, Pointer, uint32), $!read);

        return func_sig(self, $b, $v);
    }

    submethod DESTROY {
        $!free();
    }
}

class XQC_ErrorHandler_s is repr<CStruct> is export {
    has Pointer                       $.user_data; # void* user_data
    has Pointer                       $.error; # F:void ( Typedef<XQC_ErrorHandler>->|XQC_ErrorHandler_s|*, XQC_Error, const char*, const char*, const char*, Typedef<XQC_Sequence>->|XQC_Sequence_s|*)* error
}


class XQC_StaticContext_s is repr<CStruct> is export {
    has Pointer                       $.create_child_context; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, Typedef<XQC_StaticContext>->|XQC_StaticContext_s|**)* create_child_context
    has Pointer                       $.declare_ns; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char*, const char*)* declare_ns
    has Pointer                       $.get_ns_by_prefix; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char*, const char**)* get_ns_by_prefix
    has Pointer                       $.set_default_element_and_type_ns; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char*)* set_default_element_and_type_ns
    has Pointer                       $.get_default_element_and_type_ns; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char**)* get_default_element_and_type_ns
    has Pointer                       $.set_default_function_ns; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char*)* set_default_function_ns
    has Pointer                       $.get_default_function_ns; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char**)* get_default_function_ns
    has Pointer                       $.set_xpath_compatib_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_XPath1Mode)* set_xpath_compatib_mode
    has Pointer                       $.get_xpath_compatib_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_XPath1Mode*)* get_xpath_compatib_mode
    has Pointer                       $.set_construction_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_ConstructionMode)* set_construction_mode
    has Pointer                       $.get_construction_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_ConstructionMode*)* get_construction_mode
    has Pointer                       $.set_ordering_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_OrderingMode)* set_ordering_mode
    has Pointer                       $.get_ordering_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_OrderingMode*)* get_ordering_mode
    has Pointer                       $.set_default_order_empty_sequences; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_OrderEmptyMode)* set_default_order_empty_sequences
    has Pointer                       $.get_default_order_empty_sequences; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_OrderEmptyMode*)* get_default_order_empty_sequences
    has Pointer                       $.set_boundary_space_policy; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_BoundarySpaceMode)* set_boundary_space_policy
    has Pointer                       $.get_boundary_space_policy; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_BoundarySpaceMode*)* get_boundary_space_policy
    has Pointer                       $.set_copy_ns_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_PreserveMode, XQC_InheritMode)* set_copy_ns_mode
    has Pointer                       $.get_copy_ns_mode; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, XQC_PreserveMode*, XQC_InheritMode*)* get_copy_ns_mode
    has Pointer                       $.set_base_uri; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char*)* set_base_uri
    has Pointer                       $.get_base_uri; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char**)* get_base_uri
    has Pointer                       $.set_error_handler; # F:XQC_Error ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, Typedef<XQC_ErrorHandler>->|XQC_ErrorHandler_s|*)* set_error_handler
    has Pointer                       $.get_error_handler; # F:XQC_Error ( const Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, Typedef<XQC_ErrorHandler>->|XQC_ErrorHandler_s|**)* get_error_handler
    has Pointer                       $.get_interface; # F:void* ( const Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, const char*)* get_interface
    has Pointer                       $.free; # F:void ( Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*)* free
}
class XQC_Expression_s is repr<CStruct> is export {
    has Pointer                       $.create_context; # F:XQC_Error ( const Typedef<XQC_Expression>->|XQC_Expression_s|*, Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|**)* create_context
    has Pointer                       $.execute; # F:XQC_Error ( const Typedef<XQC_Expression>->|XQC_Expression_s|*, const Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* execute
    has Pointer                       $.get_interface; # F:void* ( const Typedef<XQC_Expression>->|XQC_Expression_s|*, const char*)* get_interface
    has Pointer                       $!free; # F:void ( Typedef<XQC_Expression>->|XQC_Expression_s|*)* free

    submethod DESTROY {
        $!free();
    }
}


class XQC_Sequence_s is repr<CStruct> is export {
    has Pointer                       $!next; # F:XQC_Error ( Typedef<XQC_Sequence>->|XQC_Sequence_s|*)* next
    has Pointer                       $!item_type; # F:XQC_Error ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, XQC_ItemType*)* item_type
    has Pointer                       $!type_name; # F:XQC_Error ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, const char**, const char**)* type_name
    has Pointer                       $!string_value; # F:XQC_Error ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, const char**)* string_value
    has Pointer                       $!integer_value; # F:XQC_Error ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, int*)* integer_value
    has Pointer                       $!double_value; # F:XQC_Error ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, double*)* double_value
    has Pointer                       $!node_name; # F:XQC_Error ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, const char**, const char**)* node_name
    has Pointer                       $!get_interface; # F:void* ( const Typedef<XQC_Sequence>->|XQC_Sequence_s|*, const char*)* get_interface
    has Pointer                       $!free; # F:void ( Typedef<XQC_Sequence>->|XQC_Sequence_s|*)* free

    method next {
        my &func_sig = nativecast(:(XQC_Sequence_s --> XQC_Error), $!next);

        my $err = &func_sig(self);
        testErr($err);
    }

    method item_type {
        my &func_sig = nativecast(:(XQC_Sequence_s, XQC_ItemType --> XQC_Error), $!item_type);

        my XQC_ItemType $it;
        my $err = &func_sig(self, $it);
        testErr($err);

        return $it;
    }

    method string_value {
        my &func_sig = nativecast(:(XQC_Sequence_s, Pointer --> XQC_Error), $!string_value);
        my str $sval = str.new();

        my $err = &func_sig(self, $sval);
        testErr($err);

        return $sval;
    }

    method integer_value {
        my &func_sig = nativecast(:(XQC_Sequence_s, Pointer --> XQC_Error), $!integer_value);
        my Int $ival = Int.new();

        my $err = &func_sig(self, $ival);
        testErr($err);

        return $ival;
    }


    method double_value {
        my &func_sig = nativecast(:(XQC_Sequence_s, Pointer --> XQC_Error), $!double_value);
        my Num $nval = Num.new();

        my $err = &func_sig(self, $nval);
        testErr($err);

        return $nval;
    }

    method node_name {
        my &func_sig = nativecast(:(XQC_Sequence_s, Pointer, Pointer --> XQC_Error), $!node_name);
        my str $uri = str.new();
        my str $name = str.new();

        my $err = &func_sig(self, $uri, $name);
        testErr($err);

        return ($uri, $name);
    }


    submethod DESTROY {
        $!free();
    }
}


class XQC_Implementation_s is repr<CStruct> is export {
    has Pointer                       $!create_context; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, Typedef<XQC_StaticContext>->|XQC_StaticContext_s|**)* create_context
    has Pointer                       $!prepare; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, const char*, const Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, Typedef<XQC_Expression>->|XQC_Expression_s|**)* prepare
    has Pointer                       $!prepare_file; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, Typedef<FILE>->|_IO_FILE|*, const Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, Typedef<XQC_Expression>->|XQC_Expression_s|**)* prepare_file
    has Pointer                       $!prepare_stream; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, Typedef<XQC_InputStream>->|XQC_InputStream_s|*, const Typedef<XQC_StaticContext>->|XQC_StaticContext_s|*, Typedef<XQC_Expression>->|XQC_Expression_s|**)* prepare_stream
    has Pointer                       $!parse_document; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, const char*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* parse_document
    has Pointer                       $!parse_document_file; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, Typedef<FILE>->|_IO_FILE|*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* parse_document_file
    has Pointer                       $!parse_document_stream; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, Typedef<XQC_InputStream>->|XQC_InputStream_s|*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* parse_document_stream
    has Pointer                       $!create_empty_sequence; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* create_empty_sequence
    has Pointer                       $!create_singleton_sequence; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, XQC_ItemType, const char*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* create_singleton_sequence
    has Pointer                       $!create_string_sequence; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, const char**, unsigned int, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* create_string_sequence
    has Pointer                       $!create_integer_sequence; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, int*, unsigned int, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* create_integer_sequence
    has Pointer                       $!create_double_sequence; # F:XQC_Error ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*, double*, unsigned int, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* create_double_sequence

    # cw: -YYY- Not implementing yet...
    has Pointer                       $!get_interface; # F:void* ( const Typedef<XQC_Implementation>->|XQC_Implementation_s|*, const char*)* get_interface
    has Pointer                       $!free; # F:void ( Typedef<XQC_Implementation>->|XQC_Implementation_s|*)* free

    #has XQC_StaticContext_s          $!context;

    sub new {
        createXQillaXQCImplementation(XQC_VERSION_NUMBER);
    }


    # cw: Implemented for completeness, but I do not yet see a need for its
    # use in the Perl6 methods, since passing 0 will give the default
    # static context.
    #method !createContext() {
    #   my &func_sig = nativecast(:(XQC_Implementation_s, XQC_StaticContext_s --> XQC_Error), $!create_context);
    #
    #   $!context = XQC_StaticContext_s.new();
    #
    #   my $err = &func_sig(self, $!context);
    #   testErr($err);
    #}

    method prepare(str $expr) {
        my &func_sig = nativecast(:(XQC_Implementation_s, str, Pointer, Pointer --> int32), $!prepare);
        my $xpr = XQC_Expression_s.new();

        my $err = &func_sig(self, $expr, 0, $xpr);
        testErr($err);

        return $xpr;
    }

    multi method prepare_file(IO::Handle $fh) {
        my &func_sig = nativecast(:(XQC_Implementation_s, Pointer, XQC_StaticContext_s, Pointer --> XQC_Error), $!prepare_file);
        #createContext() unless $!context.defined;
        my $NF = fdopen($fh.native-descriptor(), "r");
        my $xpr = XQC_Expression_s.new();

        my $err = &func_sig(self, $NF, XQC_StaticContext_s, $xpr);
        testErr($err);

        fdclose($NF);
        close($fh);
        free($NF);

        return $xpr;
    }

    multi method prepare_file(str $file_name) {
        die "File not found." unless $file_name.IO.e;
        my $fh = open $file_name, :r;

        return .prepare_file($fh);
    }

    method prepare_stream(XQC_InputStream_s $stream) {
        my &func_sig = nativecast(:(XQC_Implementation_s, XQC_InputStream_s, XQC_StaticContext_s, Pointer --> XQC_Error), $!prepare_stream);
        my $xpr = XQC_Expression_s.new();

        my $err = &func_sig(self, $stream, XQC_StaticContext_s, $xpr);
        testErr($err);

        return $xpr;
    }

    method parse_document(str $doc) {
        my &func_sig = nativecast(:(XQC_Implementation_s, str, Pointer --> XQC_Error), $!parse_document);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $doc, $seq);
        testErr($err);

        return $seq;
    }

    multi method parse_document_file(str $file_name) {
        die "File not found." unless $file_name.IO.e;
        my $fh = open $file_name, :r;

        return .parse_document_file($fh);
    }

    multi method parse_document_file(IO::Handle $fh) {
        my &func_sig = nativecast(:(XQC_Implementation_s, Pointer, Pointer --> XQC_Error), $!parse_document_file);
        my $seq = XQC_Sequence_s.new();

        my $NF = fdopen($fh.native-descriptor(), "r");
        my $err = &func_sig(self, $NF, $seq);
        testErr($err);

        fdclose($NF);
        close($fh);
        free($NF);

        return $seq;
    }

    method parse_document_stream(XQC_InputStream_s $stream) {
        my &func_sig = nativecast(:(XQC_Implementation_s, XQC_InputStream_s, Pointer --> XQC_Error), $!parse_document_stream);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $stream, $seq);
        testErr($err);

        return $seq;
    }

    method create_empty_sequence {
        my &func_sig = nativecast(:(XQC_Implementation_s, Pointer --> XQC_Error), $!create_empty_sequence);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $seq);
        testErr($err);

        return $seq;
    }

    method create_singleton_sequence(str $val, XQC_ItemType $type = XQC_ANY_SIMPLE_TYPE) {
        my &func_sig = nativecast(:(XQC_Implementation_s, XQC_ItemType, str, Pointer --> XQC_Error), $!create_singleton_sequence);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $type, $val, $seq);
        testErr($err);

        return $seq;
    }

    method create_string_sequence(Array $arr, Int $count?) {
        my $idx = 0;
        my $carr = CArray[Str].new();
        for ($arr) -> $v {
            die "Non string value encountered in create_string_sequence."
                unless $v ~~ Str;
            $carr[$idx++] = $v;
        }
        $count ||= $idx;
        if ($count != $idx) {
            warn "Count of objects does not match parameter in create_string_sequence.";
        }

        my &func_sig = nativecast(:(XQC_Implementation_s, CArray[Str], uint, Pointer --> XQC_Error), $!create_string_sequence);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $carr, $count, $seq);
        testErr($err);

        return $seq;
    }

    method create_integer_sequence(Array $arr, Int $count?) {
        my $idx = 0;
        my $carr = CArray[int32].new();
        for ($arr) -> $v {
            die "Non integer value or overflow encountered in create_integer_sequence."
                unless [&&] (
                    $v ~~ Int,
                    $v <= 2 ** 32 - 1,
                    $v >= -(2 ** 32)
                );

            $carr[$idx++] = $v;
        }
        $count ||= $idx;
        if ($count != $idx) {
            warn "Count of objects does not match parameter in create_integer_sequence.";
        }

        my &func_sig = nativecast(:(XQC_Implementation_s, CArray[int32], uint, Pointer --> XQC_Error), $!create_string_sequence);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $carr, $count, $seq);
        testErr($err);

        return $seq;
    }

    method create_double_sequence(Array $arr, Int $count?) {
        my $idx = 0;
        my $carr = CArray[num64].new();
        for ($arr) -> $v {
            die "Non double value encountered in create_double_sequence."
                unless $v ~~ Real;


            $carr[$idx++] = $v;
        }
        $count ||= $idx;
        if ($count != $idx) {
            warn "Count of objects does not match parameter in create_double_sequence.";
        }

        my &func_sig = nativecast(:(XQC_Implementation_s, CArray[num64], uint, Pointer --> XQC_Error), $!create_string_sequence);
        my $seq = XQC_Sequence_s.new();

        my $err = &func_sig(self, $carr, $count, $seq);
        testErr($err);

        return $seq;
    }


    submethod DESTROY {
        $!free();
    }
}


class XQC_DynamicContext_s is repr<CStruct> is export {
    has Pointer                       $!set_variable; # F:XQC_Error ( Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, const char*, const char*, Typedef<XQC_Sequence>->|XQC_Sequence_s|*)* set_variable
    has Pointer                       $!get_variable; # F:XQC_Error ( const Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, const char*, const char*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* get_variable
    has Pointer                       $!set_context_item; # F:XQC_Error ( Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, Typedef<XQC_Sequence>->|XQC_Sequence_s|*)* set_context_item
    has Pointer                       $!get_context_item; # F:XQC_Error ( const Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, Typedef<XQC_Sequence>->|XQC_Sequence_s|**)* get_context_item
    has Pointer                       $!set_implicit_timezone; # F:XQC_Error ( Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, int)* set_implicit_timezone
    has Pointer                       $!get_implicit_timezone; # F:XQC_Error ( const Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, int*)* get_implicit_timezone
    has Pointer                       $!set_error_handler; # F:XQC_Error ( Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, Typedef<XQC_ErrorHandler>->|XQC_ErrorHandler_s|*)* set_error_handler
    has Pointer                       $!get_error_handler; # F:XQC_Error ( const Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, Typedef<XQC_ErrorHandler>->|XQC_ErrorHandler_s|**)* get_error_handler
    has Pointer                       $!get_interface; # F:void* ( const Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*, const char*)* get_interface
    has Pointer                       $!free; # F:void ( Typedef<XQC_DynamicContext>->|XQC_DynamicContext_s|*)* free

    submethod DESTROY {
        $!free();
    }
}

constant XQC_Expression is export := XQC_Expression_s;
constant XQC_Sequence is export := XQC_Sequence_s;
constant XQC_InputStream is export := XQC_InputStream_s;
constant XQC_Implementation is export := XQC_Implementation_s;
constant XQC_ErrorHandler is export := XQC_ErrorHandler_s;
constant XQC_DynamicContext is export := XQC_DynamicContext_s;
constant XQC_StaticContext is export := XQC_StaticContext_s;

#
#  Creates an XQC_Implementation object that uses XQilla.
#
# ```C
# XQC_Implementation *createXQillaXQCImplementation(int version);
# ```
sub createXQillaXQCImplementation(int32 $version)
    is native('libxqilla') returns XQC_Implementation_s
    is export { * }

sub testErr($err) {
    # Throw exception based on value of my $err.
    return unless $err != 0;

    my $msg = do given $err {
        when XQC_END_OF_SEQUENCE {
            "End of Sequence";
        }

        when XQC_NO_CURRENT_ITEM {
            "No current item";
        }

        when XQC_PARSE_ERROR {
            "Parse error";
        }

        when XQC_INVALID_ARGUMENT {
            "Invalid argument";
        }

        when XQC_NOT_NODE {
            "Not node";
        }

        when XQC_INTERNAL_ERROR {
            "Internal error";
        }

        when XQC_NOT_IMPLEMENTED {
            "Not implemented";
        }

        when XQC_UNRECOGNIZED_ENCODING {
            "Unrecognized encoding";
        }

        when XQC_STATIC_ERROR {
            "Static error";
        }

        when XQC_TYPE_ERROR {
            "Type error";
        }

        when XQC_DYNAMIC_ERROR {
            "Dynamic error";
        }

        when XQC_SERIALIZATION_ERROR {
            "Serialization error";
        }
    }

    die "An XQilla error has occurred: $msg";
}

# cw: ---YYY--- It would be nice to make the following subs private to this module, but
#     it is enough that they are not exported by default.

# cw: ---YYY--- Insure that the use of int32 is correct on 64-bit systems.
# To get FILE* from IO::Handle
sub fdopen(int32, str)
    is native('libc')
    returns Pointer { * };

sub fdclose(int32)
    is native('libc')
    { * };

sub free(Pointer)
    is native('libc')
    { * };