Gecko [ oosaka-bmw-kaitori.com ]

Name	Size	Permission
AnyEvent	[ DIR ]	drwxr-xr-x
Astro	[ DIR ]	drwxr-xr-x
Attribute	[ DIR ]	drwxr-xr-x
Authen	[ DIR ]	drwxr-xr-x
B	[ DIR ]	drwxr-xr-x
BSD	[ DIR ]	drwxr-xr-x
BerkeleyDB	[ DIR ]	drwxr-xr-x
Bit	[ DIR ]	drwxr-xr-x
Bundle	[ DIR ]	drwxr-xr-x
CBOR	[ DIR ]	drwxr-xr-x
CGI	[ DIR ]	drwxr-xr-x
Cache	[ DIR ]	drwxr-xr-x
Cairo	[ DIR ]	drwxr-xr-x
Chemistry	[ DIR ]	drwxr-xr-x
Class	[ DIR ]	drwxr-xr-x
Compress	[ DIR ]	drwxr-xr-x
Convert	[ DIR ]	drwxr-xr-x
Cpanel	[ DIR ]	drwxr-xr-x
Crypt	[ DIR ]	drwxr-xr-x
DBD	[ DIR ]	drwxr-xr-x
DBI	[ DIR ]	drwxr-xr-x
Data	[ DIR ]	drwxr-xr-x
Date	[ DIR ]	drwxr-xr-x
DateTime	[ DIR ]	drwxr-xr-x
Devel	[ DIR ]	drwxr-xr-x
Device	[ DIR ]	drwxr-xr-x
Digest	[ DIR ]	drwxr-xr-x
EV	[ DIR ]	drwxr-xr-x
Encode	[ DIR ]	drwxr-xr-x
Event	[ DIR ]	drwxr-xr-x
File	[ DIR ]	drwxr-xr-x
Filesys	[ DIR ]	drwxr-xr-x
Filter	[ DIR ]	drwxr-xr-x
GD	[ DIR ]	drwxr-xr-x
GSSAPI	[ DIR ]	drwxr-xr-x
Geo	[ DIR ]	drwxr-xr-x
Glib	[ DIR ]	drwxr-xr-x
Gtk2	[ DIR ]	drwxr-xr-x
HTML	[ DIR ]	drwxr-xr-x
HTTP	[ DIR ]	drwxr-xr-x
Hash	[ DIR ]	drwxr-xr-x
IO	[ DIR ]	drwxr-xr-x
IPC	[ DIR ]	drwxr-xr-x
Image	[ DIR ]	drwxr-xr-x
Inline	[ DIR ]	drwxr-xr-x
JSON	[ DIR ]	drwxr-xr-x
Judy	[ DIR ]	drwxr-xr-x
Lexical	[ DIR ]	drwxr-xr-x
Lingua	[ DIR ]	drwxr-xr-x
Linux	[ DIR ]	drwxr-xr-x
List	[ DIR ]	drwxr-xr-x
Locale	[ DIR ]	drwxr-xr-x
Lucy	[ DIR ]	drwxr-xr-x
LucyX	[ DIR ]	drwxr-xr-x
Mail	[ DIR ]	drwxr-xr-x
Math	[ DIR ]	drwxr-xr-x
Moose	[ DIR ]	drwxr-xr-x
MooseX	[ DIR ]	drwxr-xr-x
Mouse	[ DIR ]	drwxr-xr-x
Mozilla	[ DIR ]	drwxr-xr-x
Net	[ DIR ]	drwxr-xr-x
NetAddr	[ DIR ]	drwxr-xr-x
NetSNMP	[ DIR ]	drwxr-xr-x
OpenGL	[ DIR ]	drwxr-xr-x
PCP	[ DIR ]	drwxr-xr-x
PDL	[ DIR ]	drwxr-xr-x
POD2	[ DIR ]	drwxr-xr-x
POSIX	[ DIR ]	drwxr-xr-x
Package	[ DIR ]	drwxr-xr-x
Pango	[ DIR ]	drwxr-xr-x
Params	[ DIR ]	drwxr-xr-x
Perl	[ DIR ]	drwxr-xr-x
PerlIO	[ DIR ]	drwxr-xr-x
PerlReq	[ DIR ]	drwxr-xr-x
Prima	[ DIR ]	drwxr-xr-x
Proc	[ DIR ]	drwxr-xr-x
QtCore4	[ DIR ]	drwxr-xr-x
Razor2	[ DIR ]	drwxr-xr-x
Readonly	[ DIR ]	drwxr-xr-x
Ref	[ DIR ]	drwxr-xr-x
SGML	[ DIR ]	drwxr-xr-x
SVN	[ DIR ]	drwxr-xr-x
Scalar	[ DIR ]	drwxr-xr-x
Sereal	[ DIR ]	drwxr-xr-x
Socket	[ DIR ]	drwxr-xr-x
Sort	[ DIR ]	drwxr-xr-x
Squirrel	[ DIR ]	drwxr-xr-x
String	[ DIR ]	drwxr-xr-x
Sub	[ DIR ]	drwxr-xr-x
Sys	[ DIR ]	drwxr-xr-x
Taint	[ DIR ]	drwxr-xr-x
Template	[ DIR ]	drwxr-xr-x
Term	[ DIR ]	drwxr-xr-x
Test	[ DIR ]	drwxr-xr-x
Text	[ DIR ]	drwxr-xr-x
Tie	[ DIR ]	drwxr-xr-x
Time	[ DIR ]	drwxr-xr-x
Tk	[ DIR ]	drwxr-xr-x
UNIVERSAL	[ DIR ]	drwxr-xr-x
URL	[ DIR ]	drwxr-xr-x
Unicode	[ DIR ]	drwxr-xr-x
Unix	[ DIR ]	drwxr-xr-x
Variable	[ DIR ]	drwxr-xr-x
WWW	[ DIR ]	drwxr-xr-x
Win	[ DIR ]	drwxr-xr-x
XML	[ DIR ]	drwxr-xr-x
YAML	[ DIR ]	drwxr-xr-x
ZMQ	[ DIR ]	drwxr-xr-x
auto	[ DIR ]	drwxr-xr-x
autobox	[ DIR ]	drwxr-xr-x
threads	[ DIR ]	drwxr-xr-x
true	[ DIR ]	drwxr-xr-x
version	[ DIR ]	drwxr-xr-x
AE.pm	5.27 KB	-r--r--r--
AnyEvent.pm	109.45 KB	-r--r--r--
BDB.pm	29.52 KB	-rw-r--r--
BerkeleyDB.pm	40.3 KB	-rw-r--r--
BerkeleyDB.pod	75.4 KB	-rw-r--r--
CDB_File.pm	10.42 KB	-rw-r--r--
Cairo.pm	27.13 KB	-rw-r--r--
Cflow.pm	28.93 KB	-rw-r--r--
ClearSilver.pm	1.18 KB	-rw-r--r--
Clone.pm	2 KB	-rw-r--r--
Curses.pm	34.98 KB	-rw-r--r--
Cwd.pm	21.25 KB	-rw-r--r--
DBI.pm	304.17 KB	-rw-r--r--
DB_File.pm	62.24 KB	-rw-r--r--
DDS.pm	385 B	-rw-r--r--
DP.pm	458 B	-rw-r--r--
DateTime.pm	115.31 KB	-rw-r--r--
DateTimePP.pm	5.12 KB	-rw-r--r--
DateTimePPExtra.pm	1.33 KB	-rw-r--r--
EV.pm	39.37 KB	-rw-r--r--
Encode.pm	32.17 KB	-rw-r--r--
Event.pm	4.96 KB	-rw-r--r--
Event.pod	29.58 KB	-rw-r--r--
FCGI.pm	7.36 KB	-rw-r--r--
Fuse.pm	28.37 KB	-rw-r--r--
GD.pm	59.18 KB	-rw-r--r--
GSSAPI.pm	11.24 KB	-rw-r--r--
GTop.pm	1.65 KB	-rw-r--r--
GTop.pod	6.66 KB	-rw-r--r--
Glib.pm	22.58 KB	-rw-r--r--
Gtk2.pm	13.79 KB	-rw-r--r--
Guard.pm	6.26 KB	-rw-r--r--
Hamlib.pm	104.93 KB	-r--r--r--
Judy.pm	3.16 KB	-rw-r--r--
Judy.pod	8.15 KB	-rw-r--r--
Lchown.pm	1.84 KB	-rw-r--r--
Libnodeupdown.pm	7.05 KB	-rw-r--r--
Lucy.pm	15.56 KB	-rw-r--r--
Lucy.pod	5.66 KB	-rw-r--r--
Moose.pm	37.24 KB	-rw-r--r--
Mouse.pm	11.83 KB	-rw-r--r--
NKF.pm	9.13 KB	-r--r--r--
Newt.pm	34.88 KB	-rw-r--r--
Nodeupdown.pm	9.08 KB	-rw-r--r--
OpenGL.pm	138.73 KB	-rw-r--r--
OpenGL.pod	37.34 KB	-rw-r--r--
PDL.pm	5.8 KB	-rw-r--r--
PadWalker.pm	4.1 KB	-rw-r--r--
Pango.pm	3.77 KB	-rw-r--r--
Phonon.pm	1.62 KB	-rw-r--r--
Prelude.pm	22.34 KB	-r--r--r--
Prima.pm	12.86 KB	-rw-r--r--
QImageBlitz.pm	1.66 KB	-rw-r--r--
Qsci.pm	1.61 KB	-rw-r--r--
Qt3Support4.pm	4.81 KB	-rw-r--r--
QtCore4.pm	62.88 KB	-rw-r--r--
QtDBus4.pm	2.99 KB	-rw-r--r--
QtDeclarative4.pm	1.69 KB	-rw-r--r--
QtGui4.pm	2.59 KB	-rw-r--r--
QtHelp4.pm	1.63 KB	-rw-r--r--
QtMultimedia4.pm	1.68 KB	-rw-r--r--
QtNetwork4.pm	1.65 KB	-rw-r--r--
QtOpenGL4.pm	1.65 KB	-rw-r--r--
QtScript4.pm	1.65 KB	-rw-r--r--
QtSql4.pm	1.62 KB	-rw-r--r--
QtSvg4.pm	1.54 KB	-rw-r--r--
QtTest4.pm	2.41 KB	-rw-r--r--
QtUiTools4.pm	1.65 KB	-rw-r--r--
QtWebKit4.pm	1.65 KB	-rw-r--r--
QtXml4.pm	1.62 KB	-rw-r--r--
QtXmlPatterns4.pm	1.68 KB	-rw-r--r--
Qwt.pm	1.6 KB	-rw-r--r--
RPM2.pm	17.02 KB	-rw-r--r--
RRDp.pm	5.37 KB	-r--r--r--
RRDs.pm	4.13 KB	-r--r--r--
SNMP.pm	78.26 KB	-r--r--r--
Socket.pm	35.47 KB	-rw-r--r--
Socket6.pm	9.57 KB	-rw-r--r--
Squirrel.pm	1.76 KB	-rw-r--r--
Storable.pm	42.12 KB	-rw-r--r--
Template.pm	24.41 KB	-rw-r--r--
Tk.pm	18.09 KB	-rw-r--r--
Tk.pod	6.24 KB	-rw-r--r--
Want.pm	17.56 KB	-rw-r--r--
autobox.pm	13.35 KB	-rw-r--r--
autobox.pod	17.49 KB	-rw-r--r--
autovivification.pm	6.56 KB	-rw-r--r--
bun-x.pl	1.22 KB	-rwxr-xr-x
ccom.pm	2.08 KB	-rw-r--r--
dbixs_rev.pl	1.51 KB	-rwxr-xr-x
encoding.pm	20.04 KB	-rw-r--r--
fake.pm	1.32 KB	-rw-r--r--
gencls.pod	16.83 KB	-rw-r--r--
indirect.pm	9.18 KB	-rw-r--r--
metaclass.pm	2.93 KB	-rw-r--r--
oose.pm	2.32 KB	-rw-r--r--
ouse.pm	1.86 KB	-rw-r--r--
qd.pl	32.03 KB	-rwxr-xr-x
threads.pm	34.48 KB	-rw-r--r--
true.pm	4.64 KB	-rw-r--r--
version.pm	2.85 KB	-rw-r--r--
version.pod	9.6 KB	-rw-r--r--
yui.so	1.58 MB	-rwxr-xr-x

Code Editor : Lucy.pm

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

use strict;
use warnings;

package Lucy;

use 5.008003;
use Exporter;

our $VERSION = '0.003003';
$VERSION = eval $VERSION;

use XSLoader;
# This loads a large number of disparate subs.
BEGIN { XSLoader::load( 'Lucy', '0.3.3' ) }

BEGIN {
    push our @ISA, 'Exporter';
    our @EXPORT_OK = qw( to_clownfish to_perl kdump );
}

use Lucy::Autobinding;

sub kdump {
    require Data::Dumper;
    my $kdumper = Data::Dumper->new( [@_] );
    $kdumper->Sortkeys( sub { return [ sort keys %{ $_[0] } ] } );
    $kdumper->Indent(1);
    warn $kdumper->Dump;
}

sub error {$Lucy::Object::Err::error}

{
    package Lucy::Util::IndexFileNames;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    BEGIN {
        push our @ISA, 'Exporter';
        our @EXPORT_OK = qw(
            extract_gen
            latest_snapshot
        );
    }
}

{
    package Lucy::Util::StringHelper;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    BEGIN {
        push our @ISA, 'Exporter';
        our @EXPORT_OK = qw(
            utf8_flag_on
            utf8_flag_off
            to_base36
            from_base36
            utf8ify
            utf8_valid
            cat_bytes
        );
    }
}

{
    package Lucy::Analysis::Inversion;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

our %new_PARAMS = (
        # params
        text => undef
    );
}

{
    package Lucy::Analysis::Token;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

our %new_PARAMS = (
        text         => undef,
        start_offset => undef,
        end_offset   => undef,
        pos_inc      => 1,
        boost        => 1.0,
    );
}

{
    package Lucy::Analysis::RegexTokenizer;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub compile_token_re { return qr/$_[1]/ }

sub new {
        my ( $either, %args ) = @_;
        my $token_re = delete $args{token_re};
        $args{pattern} = "$token_re" if $token_re;
        return $either->_new(%args);
    }
}

{
    package Lucy::Document::Doc;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Storable qw( nfreeze thaw );
    use bytes;
    no bytes;

our %new_PARAMS = (
        fields => undef,
        doc_id => 0,
    );

use overload
        fallback => 1,
        '%{}'    => \&get_fields;

sub serialize_fields {
        my ( $self, $outstream ) = @_;
        my $buf = nfreeze( $self->get_fields );
        $outstream->write_c32( bytes::length($buf) );
        $outstream->print($buf);
    }

sub deserialize_fields {
        my ( $self, $instream ) = @_;
        my $len = $instream->read_c32;
        my $buf;
        $instream->read( $buf, $len );
        $self->set_fields( thaw($buf) );
    }
}

{
    package Lucy::Document::HitDoc;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

our %new_PARAMS = (
        fields => undef,
        score  => 0,
        doc_id => 0,
    );
}

{
    package Lucy::Object::I32Array;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    our %new_PARAMS = ( ints => undef );
}

{
    package Lucy::Object::LockFreeRegistry;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    no warnings 'redefine';
    sub DESTROY { }    # leak all
}

{
    package Lucy::Object::Obj;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Lucy qw( to_clownfish to_perl );
    sub load { return $_[0]->_load( to_clownfish( $_[1] ) ) }
}

{
    package Lucy::Object::VTable;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub find_parent_class {
        my ( undef, $package ) = @_;
        no strict 'refs';
        for my $parent ( @{"$package\::ISA"} ) {
            return $parent if $parent->isa('Lucy::Object::Obj');
        }
        return;
    }

sub novel_host_methods {
        my ( undef, $package ) = @_;
        no strict 'refs';
        my $stash = \%{"$package\::"};
        my $methods
            = Lucy::Object::VArray->new( capacity => scalar keys %$stash );
        while ( my ( $symbol, $glob ) = each %$stash ) {
            next if ref $glob;
            next unless *$glob{CODE};
            $methods->push( Lucy::Object::CharBuf->new($symbol) );
        }
        return $methods;
    }

sub _register {
        my ( undef, %args ) = @_;
        my $singleton_class = $args{singleton}->get_name;
        my $parent_class    = $args{parent}->get_name;
        if ( !$singleton_class->isa($parent_class) ) {
            no strict 'refs';
            push @{"$singleton_class\::ISA"}, $parent_class;
        }
    }

no warnings 'redefine';
    sub DESTROY { }    # leak all
}

{
    package Lucy::Index::Indexer;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub new {
        my ( $either, %args ) = @_;
        my $flags = 0;
        $flags |= CREATE   if delete $args{'create'};
        $flags |= TRUNCATE if delete $args{'truncate'};
        return $either->_new( %args, flags => $flags );
    }

our %add_doc_PARAMS = ( doc => undef, boost => 1.0 );
}

{
    package Lucy::Index::IndexReader;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Carp;

sub new {
        confess(
            "IndexReader is an abstract class; use open() instead of new()");
    }
    sub lexicon {
        my $self       = shift;
        my $lex_reader = $self->fetch("Lucy::Index::LexiconReader");
        return $lex_reader->lexicon(@_) if $lex_reader;
        return;
    }
    sub posting_list {
        my $self         = shift;
        my $plist_reader = $self->fetch("Lucy::Index::PostingListReader");
        return $plist_reader->posting_list(@_) if $plist_reader;
        return;
    }
    sub offsets { shift->_offsets->to_arrayref }
}

{
    package Lucy::Index::PolyReader;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Lucy qw( to_clownfish );

sub try_read_snapshot {
        my ( undef, %args ) = @_;
        my ( $snapshot, $folder, $path ) = @args{qw( snapshot folder path )};
        eval { $snapshot->read_file( folder => $folder, path => $path ); };
        if   ($@) { return Lucy::Object::CharBuf->new($@) }
        else      { return undef }
    }

sub try_open_segreaders {
        my ( $self, $segments ) = @_;
        my $schema   = $self->get_schema;
        my $folder   = $self->get_folder;
        my $snapshot = $self->get_snapshot;
        my $seg_readers
            = Lucy::Object::VArray->new( capacity => scalar @$segments );
        my $segs = to_clownfish($segments);    # FIXME: Don't convert twice.
        eval {
            # Create a SegReader for each segment in the index.
            my $num_segs = scalar @$segments;
            for ( my $seg_tick = 0; $seg_tick < $num_segs; $seg_tick++ ) {
                my $seg_reader = Lucy::Index::SegReader->new(
                    schema   => $schema,
                    folder   => $folder,
                    segments => $segs,
                    seg_tick => $seg_tick,
                    snapshot => $snapshot,
                );
                $seg_readers->push($seg_reader);
            }
        };
        if ($@) {
            return Lucy::Object::CharBuf->new($@);
        }
        return $seg_readers;
    }
}

{
    package Lucy::Index::Segment;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Lucy qw( to_clownfish );
    sub store_metadata {
        my ( $self, %args ) = @_;
        $self->_store_metadata( %args,
            metadata => to_clownfish( $args{metadata} ) );
    }
}

{
    package Lucy::Index::SegReader;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub try_init_components {
        my $self = shift;
        my $arch = $self->get_schema->get_architecture;
        eval { $arch->init_seg_reader($self); };
        if ($@) { return Lucy::Object::CharBuf->new($@); }
        return;
    }
}

{
    package Lucy::Index::SortCache;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    our %value_PARAMS = ( ord => undef, );
}

{
    package Lucy::Search::Compiler;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Carp;
    use Scalar::Util qw( blessed );

sub new {
        my ( $either, %args ) = @_;
        if ( !defined $args{boost} ) {
            confess("'parent' is not a Query")
                unless ( blessed( $args{parent} )
                and $args{parent}->isa("Lucy::Search::Query") );
            $args{boost} = $args{parent}->get_boost;
        }
        return $either->do_new(%args);
    }
}

{
    package Lucy::Search::Query;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub make_compiler {
        my ( $self, %args ) = @_;
        $args{boost} = $self->get_boost unless defined $args{boost};
        return $self->_make_compiler(%args);
    }
}

{
    package Lucy::Search::SortRule;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Carp;

my %types = (
        field  => FIELD(),
        score  => SCORE(),
        doc_id => DOC_ID(),
    );

sub new {
        my ( $either, %args ) = @_;
        my $type = delete $args{type} || 'field';
        confess("Invalid type: '$type'") unless defined $types{$type};
        return $either->_new( %args, type => $types{$type} );
    }
}

{
    package Lucy::Object::BitVector;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    sub to_arrayref { shift->to_array->to_arrayref }
}

{
    package Lucy::Object::ByteBuf;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    {
        # Override autogenerated deserialize binding.
        no warnings 'redefine';
        sub deserialize { shift->_deserialize(@_) }
    }
}

{
    package Lucy::Object::ViewByteBuf;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Carp;
    sub new { confess "ViewByteBuf objects can only be created from C." }
}

{
    package Lucy::Object::CharBuf;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

{
        # Defeat obscure bugs in the XS auto-generation by redefining clone()
        # and deserialize().  (Because of how the typemap works for CharBuf*,
        # the auto-generated methods return UTF-8 Perl scalars rather than
        # actual CharBuf objects.)
        no warnings 'redefine';
        sub clone       { shift->_clone(@_) }
        sub deserialize { shift->_deserialize(@_) }
    }
}

{
    package Lucy::Object::ViewCharBuf;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Carp;
    sub new { confess "ViewCharBuf has no public constructor." }
}

{
    package Lucy::Object::ZombieCharBuf;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use Carp;
    sub new { confess "ZombieCharBuf objects can only be created from C." }
    no warnings 'redefine';
    sub DESTROY { }
}

{
    package Lucy::Object::Err;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    sub do_to_string { shift->to_string }
    use Scalar::Util qw( blessed );
    use Carp qw( confess longmess );
    use overload
        '""'     => \&do_to_string,
        fallback => 1;

sub new {
        my ( $either, $message ) = @_;
        my ( undef, $file, $line ) = caller;
        $message .= ", $file line $line\n";
        return $either->_new( mess => Lucy::Object::CharBuf->new($message) );
    }

sub do_throw {
        my $err      = shift;
        my $longmess = longmess();
        $longmess =~ s/^\s*/\t/;
        $err->cat_mess($longmess);
        die $err;
    }

our $error;
    sub set_error {
        my $val = $_[1];
        if ( defined $val ) {
            confess("Not a Lucy::Object::Err")
                unless ( blessed($val)
                && $val->isa("Lucy::Object::Err") );
        }
        $error = $val;
    }
    sub get_error {$error}
}

{
    package Lucy::Object::Hash;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    no warnings 'redefine';
    sub deserialize { shift->_deserialize(@_) }
}

{
    package Lucy::Object::VArray;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    no warnings 'redefine';
    sub clone       { CORE::shift->_clone }
    sub deserialize { CORE::shift->_deserialize(@_) }
}

{
    package Lucy::Store::FileHandle;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    BEGIN {
        push our @ISA, 'Exporter';
        our @EXPORT_OK = qw( build_fh_flags );
    }

sub build_fh_flags {
        my $args  = shift;
        my $flags = 0;
        $flags |= FH_CREATE     if delete $args->{create};
        $flags |= FH_READ_ONLY  if delete $args->{read_only};
        $flags |= FH_WRITE_ONLY if delete $args->{write_only};
        $flags |= FH_EXCLUSIVE  if delete $args->{exclusive};
        return $flags;
    }

sub open {
        my ( $either, %args ) = @_;
        $args{flags} ||= 0;
        $args{flags} |= build_fh_flags( \%args );
        return $either->_open(%args);
    }
}

{
    package Lucy::Store::FSFileHandle;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub open {
        my ( $either, %args ) = @_;
        $args{flags} ||= 0;
        $args{flags} |= Lucy::Store::FileHandle::build_fh_flags( \%args );
        return $either->_open(%args);
    }
}

{
    package Lucy::Store::FSFolder;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    use File::Spec::Functions qw( rel2abs );
    sub absolutify { return rel2abs( $_[1] ) }
}

{
    package Lucy::Store::RAMFileHandle;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;

sub open {
        my ( $either, %args ) = @_;
        $args{flags} ||= 0;
        $args{flags} |= Lucy::Store::FileHandle::build_fh_flags( \%args );
        return $either->_open(%args);
    }
}

{
    package Lucy::Util::Debug;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    BEGIN {
        push our @ISA, 'Exporter';
        our @EXPORT_OK = qw(
            DEBUG
            DEBUG_PRINT
            DEBUG_ENABLED
            ASSERT
            set_env_cache
            num_allocated
            num_freed
            num_globals
        );
    }
}

{
    package Lucy::Object::Host;
    our $VERSION = '0.003003';
    $VERSION = eval $VERSION;
    BEGIN {
        if ( !__PACKAGE__->isa('Lucy::Object::Obj') ) {
            push our @ISA, 'Lucy::Object::Obj';
        }
    }
}

__END__

__BINDING__

my $xs_code = <<'END_XS_CODE';
MODULE = Lucy    PACKAGE = Lucy

BOOT:
    lucy_Lucy_bootstrap();

IV
_dummy_function()
CODE:
    RETVAL = 1;
OUTPUT:
    RETVAL

SV*
to_clownfish(sv)
    SV *sv;
CODE:
{
    lucy_Obj *obj = XSBind_perl_to_cfish(sv);
    RETVAL = CFISH_OBJ_TO_SV_NOINC(obj);
}
OUTPUT: RETVAL

SV*
to_perl(sv)
    SV *sv;
CODE:
{
    if (sv_isobject(sv) && sv_derived_from(sv, "Lucy::Object::Obj")) {
        IV tmp = SvIV(SvRV(sv));
        lucy_Obj* obj = INT2PTR(lucy_Obj*, tmp);
        RETVAL = XSBind_cfish_to_perl(obj);
    }
    else {
        RETVAL = newSVsv(sv);
    }
}
OUTPUT: RETVAL
END_XS_CODE

Clownfish::CFC::Binding::Perl::Class->register(
    parcel     => "Lucy",
    class_name => "Lucy",
    xs_code    => $xs_code,
);

${this.title}

Code Editor : Lucy.pm