Handle
Widget_shape( Handle self, Bool set, Handle mask)
{
if ( var-> stage > csFrozen) return nilHandle;
if ( !set) {
if ( apc_widget_get_shape( self, nilHandle)) {
HV * profile = newHV();
Handle i = Object_create( "Prima::Image", profile);
sv_free(( SV *) profile);
apc_widget_get_shape( self, i);
--SvREFCNT( SvRV((( PAnyObject) i)-> mate));
return i;
} else
return nilHandle;
}
if ( mask && !kind_of( mask, CImage)) {
warn("RTC008A: Illegal object reference passed to Widget::shape");
return nilHandle;
}
if ( mask && (( PImage( mask)-> type & imBPP) != imbpp1)) {
Handle i = CImage( mask)-> dup( mask);
++SvREFCNT( SvRV( PImage( i)-> mate));
CImage( i)-> set_conversion( i, ictNone);
CImage( i)-> set_type( i, imBW);
apc_widget_set_shape( self, i);
--SvREFCNT( SvRV( PImage( i)-> mate));
Object_destroy( i);
} else
apc_widget_set_shape( self, mask);
return nilHandle;
}
SV* call_ftn(SV* arg) {
append_to_log_file(refcount_to_string("Refcount 3 (inside the callee):", SvREFCNT(arg)));
FILE* fp;
fp = fopen("print_scalar.txt", "w");
fprintf(fp, "%s", SvPV_nolen(arg));
fclose(fp);
SvREFCNT_dec(arg);
append_to_log_file(refcount_to_string("Refcount 4 (inside the callee, after dec):", SvREFCNT(arg)));
return arg;
}
/*
FFT
profile keys: inverse => BOOL; direct or inverse transform
*/
PImage
IPA__Global_fft(PImage img,HV *profile)
{
#define METHOD "IPA::Global::fft"
dPROFILE;
Bool inverse = 0, failed = false;
PImage ret = nil;
double * buffer = nil;
if ( sizeof(double) % 2) {
warn("%s:'double' is even-sized on this platform", METHOD);
return nil;
}
if ( !img || !kind_of(( Handle) img, CImage))
croak("%s: not an image passed", METHOD);
if ( !pow2( img-> w))
croak("%s: image width is not a power of 2", METHOD);
if ( !pow2( img-> h))
croak("%s: image height is not a power of 2", METHOD);
if ( pexist( inverse)) inverse = pget_B( inverse);
/* preparing structures */
ret = ( PImage) img-> self-> dup(( Handle) img);
if ( !ret) fail( "%s: Return image allocation failed");
++SvREFCNT( SvRV( ret-> mate));
ret-> self-> set_type(( Handle) ret, imDComplex);
if ( ret-> type != imDComplex) {
warn("%s:Cannot set image to imDComplex", METHOD);
failed = 1;
goto EXIT;
}
buffer = malloc((sizeof(double) * img-> w * 2));
if ( !buffer) {
warn("%s: Error allocating %d bytes", METHOD, (int)(sizeof(double) * img-> w * 2));
failed = 1;
goto EXIT;
}
fft_2d(( double *) ret-> data, ret-> w, ret-> h, inverse ? FFT_INVERSE : FFT_DIRECT, buffer);
EXIT:
free( buffer);
if ( ret)
--SvREFCNT( SvRV( ret-> mate));
return failed ? nil : ret;
#undef METHOD
}
static void
new_arena( SV * sva, const void *p ) {
const where *w = p;
int err;
/*fprintf(stderr, "%s, line %d: New arena: %p\n", (const char *) (w + 1), w->line, sva); */
SV *sv = sva + 1;
SV *svend = &sva[SvREFCNT( sva )];
while ( sv < svend ) {
if ( live_sv( sv ) ) {
/* New variable */
new_var( sv, w );
}
else {
/* Pretend any new free SVs were already in the free list otherwise
* when we compare the new free list with the old one it'll look as
* if lots of variables that never existed have been freed.
*/
if ( err = list_append( ¤t_free, sv ), ERR_None != err ) {
nomem( );
}
}
++sv;
}
/*fprintf(stderr, "%s, line %d: End new arena: %p\n", (const char *) (w + 1), w->line, sva); */
}
Handle
Widget_pointerIcon( Handle self, Bool set, Handle icon)
{
enter_method;
Point hotSpot;
if ( var-> stage > csFrozen) return nilHandle;
if ( !set) {
HV * profile = newHV();
Handle icon = Object_create( "Prima::Icon", profile);
sv_free(( SV *) profile);
apc_pointer_get_bitmap( self, icon);
--SvREFCNT( SvRV((( PAnyObject) icon)-> mate));
return icon;
}
if ( icon != nilHandle && !kind_of( icon, CIcon)) {
warn("RTC083: Illegal object reference passed to Widget::pointerIcon");
return nilHandle;
}
hotSpot = my-> get_pointerHotSpot( self);
apc_pointer_set_user( self, icon, hotSpot);
if ( var-> pointerType == crUser) my-> first_that( self, (void*)sptr, nil);
return nilHandle;
}
static SV *
image_server( Handle self, PClipboardFormatReg instance, int function, SV * data)
{
ClipboardDataRec c;
switch( function) {
case cefInit:
return ( SV *) cfBitmap;
case cefFetch:
{
HV * profile = newHV();
c. image = Object_create( "Prima::Image", profile);
sv_free(( SV *) profile);
if ( apc_clipboard_get_data( self, cfBitmap, &c)) {
--SvREFCNT( SvRV( PImage(c. image)-> mate));
return newSVsv( PImage(c. image)-> mate);
}
Object_destroy( c. image);
}
break;
case cefStore:
c. image = gimme_the_mate( data);
if ( !kind_of( c. image, CImage)) {
warn("Not an image passed to clipboard");
return nilSV;
}
instance-> success = apc_clipboard_set_data( self, cfBitmap, &c);
instance-> written = true;
break;
}
return nilSV;
}
uint32_t
kino_Obj_get_refcount(kino_Obj *self)
{
return self->ref.count < 4
? self->ref.count
: SvREFCNT((SV*)self->ref.host_obj);
}
Handle
Window_icon( Handle self, Bool set, Handle icon)
{
if ( var-> stage > csFrozen) return nilHandle;
if ( !set) {
if ( apc_window_get_icon( self, nilHandle)) {
HV * profile = newHV();
Handle i = Object_create( "Prima::Icon", profile);
sv_free(( SV *) profile);
apc_window_get_icon( self, i);
--SvREFCNT( SvRV((( PAnyObject) i)-> mate));
return i;
} else
return nilHandle;
}
if ( icon && !kind_of( icon, CImage)) {
warn("Illegal object reference passed to Window::icon");
return nilHandle;
}
my-> first_that( self, (void*)icon_notify, (void*)icon);
apc_window_set_icon( self, icon);
opt_clear( optOwnerIcon);
return nilHandle;
}
static void
passport_finalize(
JSContext *cx,
JSObject *passport
) {
dTHX;
SV *box = (SV *)JS_GetPrivate(cx, passport);
if(box && SvOK(box) && SvROK(box)) {
AV *avbox = (AV *)SvRV(box);
#ifdef PJSDEBUG
JSObject *parent = JS_GetParent(cx, passport);
#endif
PJS_DEBUG3("About to free a %s rc:%d,%d\n", JS_GET_CLASS(cx, parent)->name,
SvREFCNT(box), SvREFCNT(avbox));
if(PL_dirty) return;
av_store(avbox, 0, &PL_sv_undef);
sv_free(box);
} else croak("PJS_Assert: Bad finalize for passport\n"); /* Assertion */
}
MP_INLINE void modperl_io_handle_untie(pTHX_ GV *handle)
{
#ifdef MP_TRACE
if (mg_find(TIEHANDLE_SV(handle), PERL_MAGIC_tiedscalar)) {
MP_TRACE_r(MP_FUNC, "untie *%s(0x%lx), REFCNT=%d",
GvNAME(handle), (unsigned long)handle,
SvREFCNT(TIEHANDLE_SV(handle)));
}
#endif
sv_unmagic(TIEHANDLE_SV(handle), PERL_MAGIC_tiedscalar);
}
void
tools_show_used( void ) {
/* SV *sva; */
hash_iter i;
const void *k;
size_t kl;
#ifdef BRUTE_FORCE
fprintf( stderr, "Leaks found by free list snooping:\n" );
#endif
k = hash_get_first_key( var_map, &i, &kl );
while ( k ) {
const where *w =
( const where * ) hash_GETNULL( hash_get( var_map, k, kl ) );
if ( w ) {
print_var( *( SV ** ) k, w );
}
k = hash_get_next_key( var_map, &i, &kl );
}
#if 0
for ( sva = PL_sv_arenaroot; sva; sva = ( SV * ) SvANY( sva ) ) {
SV *sv = sva + 1;
SV *svend = &sva[SvREFCNT( sva )];
while ( sv < svend ) {
if ( live_sv( sv ) ) {
fprintf( stderr, "var in pool at %p\n", sv );
}
++sv;
}
}
#endif
#ifdef BRUTE_FORCE
if ( brute ) {
fprintf( stderr, "Leaks found by brute force:\n" );
k = hash_get_first_key( brute, &i, &kl );
while ( k ) {
const where *w =
( const where * ) hash_GETNULL( hash_get( brute, k, kl ) );
if ( w ) {
print_var( *( SV ** ) k, w );
}
k = hash_get_next_key( brute, &i, &kl );
}
}
#endif
}
static void
brute_force( int line, const char *file ) {
SV *sva;
hash *baby;
const where *w;
int err;
fprintf( stderr, "brute_force(%d, \"%s\")\n", line, file );
w = get_where( line, file );
if ( err = hash_new( PL_sv_count, &baby ), ERR_None != err ) {
nomem( );
}
for ( sva = PL_sv_arenaroot; sva; sva = ( SV * ) SvANY( sva ) ) {
SV *sv = sva + 1;
SV *svend = &sva[SvREFCNT( sva )];
while ( sv < svend ) {
if ( live_sv( sv ) ) {
const where *nw = w;
if ( brute ) {
const where *ow;
if ( ( ow = hash_get( brute, &sv, sizeof( sv ) ) ) ) {
nw = hash_GETNULL( ow );
}
else {
if ( w ) {
fprintf( stderr,
"%s, line %d: New var (bf): %p\n",
( const char * ) ( w + 1 ), w->line, sv );
}
}
}
if ( err = hash_put( baby, &sv, sizeof( sv ),
hash_PUTNULL( ( void * ) nw ) ),
ERR_None != err ) {
nomem( );
}
}
++sv;
}
}
hash_delete( brute );
brute = baby;
}
SV *hook_call(pTHX_ SV *self, const char *id_pre, const char *id,
const TypeHooks *pTH, enum HookId hook_id, SV *in, int mortal)
{
CT_DEBUG(MAIN, ("hook_call(id='%s%s', pTH=%p, in=%p(%d), mortal=%d)",
id_pre, id, pTH, in, (int) SvREFCNT(in), mortal));
assert(self != NULL);
assert(pTH != NULL);
assert(id != NULL);
assert(in != NULL);
return single_hook_call(aTHX_ self, gs_HookIdStr[hook_id], id_pre, id,
&pTH->hooks[hook_id], in, mortal);
}
/* Sanity check - compare the free list with the list of free SVs in the arenas */
static void
free_list_sane( void ) {
list real_free;
list comp_free;
int err;
SV *sva;
long diff;
/* Get the real free list */
if ( err =
list_build( &real_free, PL_sv_root, list_hint( ¤t_free ) ),
ERR_None != err ) {
nomem( );
}
/* Get the list of all the free SVs in all the arenas */
if ( err =
list_init( &comp_free, list_hint( &real_free ) ),
ERR_None != err ) {
nomem( );
}
for ( sva = PL_sv_arenaroot; sva; sva = ( SV * ) SvANY( sva ) ) {
SV *sv = sva + 1;
SV *svend = &sva[SvREFCNT( sva )];
while ( sv < svend ) {
if ( free_sv( sv ) ) {
if ( err = list_append( &comp_free, sv ), ERR_None != err ) {
nomem( );
}
}
++sv;
}
}
diff =
list_true_diff( &real_free, &comp_free, NULL, in_free_only,
in_comp_only );
if ( diff != 0 ) {
fprintf( stderr, "Lists have %ld differences, stopping\n", diff );
fprintf( stderr,
"%ld items in free list, %ld free items in arenas\n",
( long ) list_used( &real_free ),
( long ) list_used( &comp_free ) );
exit( 1 );
}
}
MP_INLINE void modperl_io_handle_tie(pTHX_ GV *handle,
char *classname, void *ptr)
{
SV *obj = modperl_ptr2obj(aTHX_ classname, ptr);
modperl_io_handle_untie(aTHX_ handle);
sv_magic(TIEHANDLE_SV(handle), obj, PERL_MAGIC_tiedscalar, (char *)NULL, 0);
SvREFCNT_dec(obj); /* since sv_magic did SvREFCNT_inc */
MP_TRACE_r(MP_FUNC, "tie *%s(0x%lx) => %s, REFCNT=%d",
GvNAME(handle), (unsigned long)handle, classname,
SvREFCNT(TIEHANDLE_SV(handle)));
}
static int
hr_freehook(pTHX_ SV* object, MAGIC *mg)
{
if(PL_dirty) {
HR_DEBUG("Not triggering during global destruction");
return;
}
HR_DEBUG("FREEHOOK: mg=%p, obj=%p", mg, object);
HR_DEBUG("Object refcount: %d", SvREFCNT(object));
OURMAGIC_infree(mg) = 1;
#if (PERL_VERSION < 10) || (PERL_VERSION == 10 && PERL_SUBVERSION < 1)
#warning "Nasty SvMAGIC_set hack"
SvMAGIC_set(object, mg);
#endif
HR_trigger_and_free_actions(_mg_action_list(mg), object);
}
/* all ap_filter_t filter cleanups should go here */
static apr_status_t modperl_filter_f_cleanup(void *data)
{
ap_filter_t *f = (ap_filter_t *)data;
modperl_filter_ctx_t *ctx = (modperl_filter_ctx_t *)(f->ctx);
/* mod_perl filter ctx cleanup */
if (ctx->data){
#ifdef USE_ITHREADS
dTHXa(ctx->perl);
#endif
if (SvOK(ctx->data) && SvREFCNT(ctx->data)) {
SvREFCNT_dec(ctx->data);
ctx->data = NULL;
}
ctx->perl = NULL;
}
return APR_SUCCESS;
}
static void boot_core_cperl(pTHX) {
const char he_name1[] = "feature_signatures";
const char he_name2[] = "feature_lexsubs";
SV* on = newSViv(1);
/* use feature "signatures";
i.e. $^H{$feature{signatures}} = 1; */
/* This broke CM-364 by nasty side-effect. HINT_LOCALIZE_HH was added to fix
strtable global destruction issues with wrong refcounts.
So we get now only signatures and lexsubs for free.
PL_hints |= HINT_LOCALIZE_HH | (FEATURE_BUNDLE_515 << HINT_FEATURE_SHIFT);
*/
CopHINTHASH_set(&PL_compiling,
cophh_store_pvn(CopHINTHASH_get(&PL_compiling), he_name1, sizeof(he_name1)-1, 0,
on, 0));
CopHINTHASH_set(&PL_compiling,
cophh_store_pvn(CopHINTHASH_get(&PL_compiling), he_name2, sizeof(he_name2)-1, 0,
on, 0));
SvREFCNT(on) = 2;
}
Handle
Application_get_image( Handle self, int x, int y, int xLen, int yLen)
{
HV * profile;
Handle i;
Bool ret;
Point sz;
if ( var-> stage > csFrozen) return nilHandle;
if ( x < 0 || y < 0 || xLen <= 0 || yLen <= 0) return nilHandle;
sz = apc_application_get_size( self);
if ( x + xLen > sz. x) xLen = sz. x - x;
if ( y + yLen > sz. y) yLen = sz. y - y;
if ( x >= sz. x || y >= sz. y || xLen <= 0 || yLen <= 0) return nilHandle;
profile = newHV();
i = Object_create( "Prima::Image", profile);
sv_free(( SV *) profile);
ret = apc_application_get_bitmap( self, i, x, y, xLen, yLen);
--SvREFCNT( SvRV((( PAnyObject) i)-> mate));
return ret ? i : nilHandle;
}
static Handle xdup( Handle self, char * className)
{
Handle h;
PDrawable i;
HV * profile = newHV();
Point s;
pset_H( owner, var-> owner);
pset_i( width, var-> w);
pset_i( height, var-> h);
pset_i( type, var-> monochrome ? imMono : imRGB);
h = Object_create( className, profile);
sv_free(( SV *) profile);
i = ( PDrawable) h;
s = i-> self-> get_size( h);
i-> self-> begin_paint( h);
i-> self-> put_image_indirect( h, self, 0, 0, 0, 0, s.x, s.y, s.x, s.y, ropCopyPut);
i-> self-> end_paint( h);
--SvREFCNT( SvRV( i-> mate));
return h;
}
uint32_t
kino_Obj_dec_refcount(kino_Obj *self)
{
uint32_t modified_refcount = I32_MAX;
switch (self->ref.count) {
case 0:
CFISH_THROW(KINO_ERR, "Illegal refcount of 0");
break; // useless
case 1:
modified_refcount = 0;
Kino_Obj_Destroy(self);
break;
case 2:
case 3:
modified_refcount = --self->ref.count;
break;
default:
modified_refcount = SvREFCNT((SV*)self->ref.host_obj) - 1;
// If the SV's refcount falls to 0, DESTROY will be invoked from
// Perl-space.
SvREFCNT_dec((SV*)self->ref.host_obj);
}
return modified_refcount;
}
Handle
Application_icon( Handle self, Bool set, Handle icon)
{
if ( var-> stage > csFrozen) return nilHandle;
if ( !set)
return var-> icon;
if ( icon && !kind_of( icon, CImage)) {
warn("Illegal object reference passed to Application::icon");
return nilHandle;
}
if ( icon) {
icon = ((( PImage) icon)-> self)-> dup( icon);
++SvREFCNT( SvRV((( PAnyObject) icon)-> mate));
}
my-> first_that( self, (void*)icon_notify, (void*)icon);
if ( var-> icon)
my-> detach( self, var-> icon, true);
var-> icon = icon;
if ( icon && ( list_index_of( var-> components, icon) < 0))
my-> attach( self, icon);
return nilHandle;
}
SV *
DeadCode(pTHX)
{
#ifdef PURIFY
return Nullsv;
#else
SV* sva;
SV* sv;
SV* ret = newRV_noinc((SV*)newAV());
register SV* svend;
int tm = 0, tref = 0, ts = 0, ta = 0, tas = 0;
for (sva = PL_sv_arenaroot; sva; sva = (SV*)SvANY(sva)) {
svend = &sva[SvREFCNT(sva)];
for (sv = sva + 1; sv < svend; ++sv) {
if (SvTYPE(sv) == SVt_PVCV) {
CV *cv = (CV*)sv;
AV* padlist = CvPADLIST(cv), *argav;
SV** svp;
SV** pad;
int i = 0, j, levelm, totm = 0, levelref, totref = 0;
int levels, tots = 0, levela, tota = 0, levelas, totas = 0;
int dumpit = 0;
if (CvXSUB(sv)) {
continue; /* XSUB */
}
if (!CvGV(sv)) {
continue; /* file-level scope. */
}
if (!CvROOT(cv)) {
/* PerlIO_printf(Perl_debug_log, " no root?!\n"); */
continue; /* autoloading stub. */
}
do_gvgv_dump(0, Perl_debug_log, "GVGV::GV", CvGV(sv));
if (CvDEPTH(cv)) {
PerlIO_printf(Perl_debug_log, " busy\n");
continue;
}
svp = AvARRAY(padlist);
while (++i <= AvFILL(padlist)) { /* Depth. */
SV **args;
pad = AvARRAY((AV*)svp[i]);
argav = (AV*)pad[0];
if (!argav || (SV*)argav == &PL_sv_undef) {
PerlIO_printf(Perl_debug_log, " closure-template\n");
continue;
}
args = AvARRAY(argav);
levelm = levels = levelref = levelas = 0;
levela = sizeof(SV*) * (AvMAX(argav) + 1);
if (AvREAL(argav)) {
for (j = 0; j < AvFILL(argav); j++) {
if (SvROK(args[j])) {
PerlIO_printf(Perl_debug_log, " ref in args!\n");
levelref++;
}
/* else if (SvPOK(args[j]) && SvPVX(args[j])) { */
else if (SvTYPE(args[j]) >= SVt_PV && SvLEN(args[j])) {
levelas += SvLEN(args[j])/SvREFCNT(args[j]);
}
}
}
for (j = 1; j < AvFILL((AV*)svp[1]); j++) { /* Vars. */
if (SvROK(pad[j])) {
levelref++;
do_sv_dump(0, Perl_debug_log, pad[j], 0, 4, 0, 0);
dumpit = 1;
}
/* else if (SvPOK(pad[j]) && SvPVX(pad[j])) { */
else if (SvTYPE(pad[j]) >= SVt_PVAV) {
if (!SvPADMY(pad[j])) {
levelref++;
do_sv_dump(0, Perl_debug_log, pad[j], 0, 4, 0, 0);
dumpit = 1;
}
}
else if (SvTYPE(pad[j]) >= SVt_PV && SvLEN(pad[j])) {
levels++;
levelm += SvLEN(pad[j])/SvREFCNT(pad[j]);
/* Dump(pad[j],4); */
}
}
PerlIO_printf(Perl_debug_log, " level %i: refs: %i, strings: %i in %i,\targsarray: %i, argsstrings: %i\n",
i, levelref, levelm, levels, levela, levelas);
totm += levelm;
tota += levela;
totas += levelas;
tots += levels;
totref += levelref;
if (dumpit)
do_sv_dump(0, Perl_debug_log, (SV*)cv, 0, 2, 0, 0);
}
if (AvFILL(padlist) > 1) {
PerlIO_printf(Perl_debug_log, " total: refs: %i, strings: %i in %i,\targsarrays: %i, argsstrings: %i\n",
totref, totm, tots, tota, totas);
}
tref += totref;
tm += totm;
ts += tots;
ta += tota;
tas += totas;
}
}
}
PerlIO_printf(Perl_debug_log, "total: refs: %i, strings: %i in %i\targsarray: %i, argsstrings: %i\n", tref, tm, ts, ta, tas);
return ret;
#endif /* !PURIFY */
}
GV *
Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, I32 sv_type)
{
register const char *name = nambeg;
register GV *gv = 0;
GV**gvp;
I32 len;
register const char *namend;
HV *stash = 0;
if (*name == '*' && isALPHA(name[1])) /* accidental stringify on a GV? */
name++;
for (namend = name; *namend; namend++) {
if ((*namend == ':' && namend[1] == ':')
|| (*namend == '\'' && namend[1]))
{
if (!stash)
stash = PL_defstash;
if (!stash || !SvREFCNT(stash)) /* symbol table under destruction */
return Nullgv;
len = namend - name;
if (len > 0) {
char smallbuf[256];
char *tmpbuf;
if (len + 3 < sizeof smallbuf)
tmpbuf = smallbuf;
else
New(601, tmpbuf, len+3, char);
Copy(name, tmpbuf, len, char);
tmpbuf[len++] = ':';
tmpbuf[len++] = ':';
tmpbuf[len] = '\0';
gvp = (GV**)hv_fetch(stash,tmpbuf,len,add);
gv = gvp ? *gvp : Nullgv;
if (gv && gv != (GV*)&PL_sv_undef) {
if (SvTYPE(gv) != SVt_PVGV)
gv_init(gv, stash, tmpbuf, len, (add & GV_ADDMULTI));
else
GvMULTI_on(gv);
}
if (tmpbuf != smallbuf)
Safefree(tmpbuf);
if (!gv || gv == (GV*)&PL_sv_undef)
return Nullgv;
if (!(stash = GvHV(gv)))
stash = GvHV(gv) = newHV();
if (!HvNAME(stash))
HvNAME(stash) = savepvn(nambeg, namend - nambeg);
}
if (*namend == ':')
namend++;
namend++;
name = namend;
if (!*name)
return gv ? gv : (GV*)*hv_fetch(PL_defstash, "main::", 6, TRUE);
}
}
// This function reads the various JavaBin datatypes and returns a Perl SV.
// Different datatypes are jumped to view a lookup in an array of computed gotos.
//
// The first group (undef to enum) use the entire tag for the index of the type.
//
// The second are matched by taking the tag byte, shifting it by 5 so to only read
// the first 3 bits of the tag byte, giving it a range or 0-7 inclusive.
//
// To store both in one array the second group have 18 added to them. See DISPATCH.
//
// The remaining 5 bits can then be used to store the size of the datatype, e.g. how
// many chars in a string, this therefore has a range of 0-31, if the size exceeds or
// matches this then an additional vint is added.
//
// The overview of the tag byte is therefore TTTSSSSS with T and S being type and size.
static SV* read_sv(pTHX) {
void* dispatch[] = {
&&read_undef,
&&read_bool,
&&read_bool,
&&read_byte,
&&read_short,
&&read_double,
&&read_int,
&&read_long,
&&read_float,
&&read_date,
&&read_map,
&&read_solr_doc,
&&read_solr_doc_list,
&&read_byte_array,
&&read_iterator,
NULL,
NULL,
NULL,
&&read_enum,
&&read_string,
&&read_small_int,
&&read_small_long,
&&read_array,
&&read_map,
&&read_map,
};
in++;
goto *dispatch[in[-1] >> 5 ? (in[-1] >> 5) + 18 : in[-1]];
read_undef:
return &PL_sv_undef;
read_bool: {
SV *rv = newSV_type(SVt_IV), *sv = in[-1] == 1 ? bool_true : bool_false;
SvREFCNT(sv)++;
SvROK_on(rv);
SvRV_set(rv, sv);
return rv;
}
read_byte:
return newSViv((int8_t) *in++);
read_short: {
const int16_t s = in[0] << 8 | in[1];
in += 2;
return newSViv(s);
}
read_double: {
// For perls with double length NVs this conversion is simple.
// Read 8 bytes, cast to double, return. For long double perls
// more magic is used, see read_float for more details.
const int_double u = { (uint64_t) in[0] << 56 |
(uint64_t) in[1] << 48 |
(uint64_t) in[2] << 40 |
(uint64_t) in[3] << 32 |
(uint64_t) in[4] << 24 |
(uint64_t) in[5] << 16 |
(uint64_t) in[6] << 8 |
(uint64_t) in[7] };
in += 8;
#ifdef USE_LONG_DOUBLE
char *str = alloca(snprintf(NULL, 0, "%.14f", u.d));
sprintf(str, "%.14f", u.d);
return newSVnv(strtold(str, NULL));
#else
return newSVnv(u.d);
#endif
}
read_int: {
const int32_t i = in[0] << 24 | in[1] << 16 | in[2] << 8 | in[3];
in += 4;
return newSViv(i);
}
read_long: {
const int64_t l = (uint64_t) in[0] << 56 |
(uint64_t) in[1] << 48 |
(uint64_t) in[2] << 40 |
(uint64_t) in[3] << 32 |
(uint64_t) in[4] << 24 |
(uint64_t) in[5] << 16 |
(uint64_t) in[6] << 8 |
(uint64_t) in[7];
in += 8;
return newSViv(l);
}
read_float: {
// JavaBin has a 4byte float format, NVs in perl are double or long double,
// therefore a little magic is required. Read the 4 bytes into an int in the
// correct endian order. Re-read these bits as a float, stringify this float,
// then finally numify the string into a double or long double.
const int_float u = { in[0] << 24 | in[1] << 16 | in[2] << 8 | in[3] };
in += 4;
char *str = alloca(snprintf(NULL, 0, "%f", u.f));
sprintf(str, "%f", u.f);
#ifdef USE_LONG_DOUBLE
return newSVnv(strtold(str, NULL));
#else
return newSVnv(strtod(str, NULL));
#endif
}
read_date: {
const int64_t date_ms = (uint64_t) in[0] << 56 |
(uint64_t) in[1] << 48 |
(uint64_t) in[2] << 40 |
(uint64_t) in[3] << 32 |
(uint64_t) in[4] << 24 |
(uint64_t) in[5] << 16 |
(uint64_t) in[6] << 8 |
(uint64_t) in[7];
in += 8;
const time_t date = date_ms / 1000;
const struct tm *t = gmtime(&date);
char date_str[25];
sprintf(date_str, "%u-%02u-%02uT%02u:%02u:%02u.%03uZ", t->tm_year + 1900,
t->tm_mon + 1,
t->tm_mday,
t->tm_hour,
t->tm_min,
t->tm_sec,
(uint32_t) (date_ms % 1000));
return newSVpvn(date_str, 24);
}
read_solr_doc:
in++; // Assume a solr doc is a map.
read_map: {
HV *hv = (HV*)newSV_type(SVt_PVHV);
uint32_t len = in[-1] >> 5 ? READ_LEN : read_v_int();
while (len--) {
cached_key key;
in++;
const uint32_t i = READ_LEN;
if (i)
key = cached_keys[i];
else {
in++;
cached_keys[++cache_pos] = key = (cached_key){ (char*)in, 0, READ_LEN };
uint8_t *key_str = in;
in += key.len;
// Set the UTF8 flag if we hit a high byte.
while (key_str != in) {
if (*key_str++ & 128) {
key.flags = HVhek_UTF8;
break;
}
}
}
hv_common(hv, NULL, key.key, key.len, key.flags, HV_FETCH_ISSTORE, read_sv(aTHX), 0);
}
SV *rv = newSV_type(SVt_IV);
SvROK_on(rv);
SvRV_set(rv, (SV*)hv);
return rv;
}
read_solr_doc_list: {
HV *hv = (HV*)newSV_type(SVt_PVHV);
// Assume values are in an array, skip tag & read_sv.
in++;
hv_set(hv, "numFound", read_sv(aTHX), numFound);
hv_set(hv, "start", read_sv(aTHX), start);
hv_set(hv, "maxScore", read_sv(aTHX), maxScore);
hv_set(hv, "docs", read_sv(aTHX), docs);
SV *rv = newSV_type(SVt_IV);
SvROK_on(rv);
SvRV_set(rv, (SV*)hv);
return rv;
}
read_byte_array: {
AV *av = (AV*)newSV_type(SVt_PVAV);
SSize_t len = read_v_int();
SV **ary = safemalloc(len * sizeof(SV*));
AvALLOC(av) = AvARRAY(av) = ary;
AvFILLp(av) = AvMAX(av) = len - 1;
while (len--)
*ary++ = newSViv((int8_t) *in++);
SV *rv = newSV_type(SVt_IV);
SvROK_on(rv);
SvRV_set(rv, (SV*)av);
return rv;
}
read_iterator: {
AV *av = (AV*)newSV_type(SVt_PVAV);
uint32_t len = 0;
while (*in != 15)
av_store(av, len++, read_sv(aTHX));
in++;
SV *rv = newSV_type(SVt_IV);
SvROK_on(rv);
SvRV_set(rv, (SV*)av);
return rv;
}
read_enum: {
SV *sv = read_sv(aTHX); // small_int if +ve, int otherwise.
sv_upgrade(sv, SVt_PVMG);
in++;
const STRLEN len = READ_LEN;
char *str = sv_grow(sv, len + 1);
memcpy(str, in, len);
in += len;
str[len] = '\0';
SvCUR(sv) = len;
SvFLAGS(sv) = SVf_IOK | SVp_IOK | SVs_OBJECT | SVf_POK | SVp_POK | SVt_PVMG | SVf_UTF8;
HV *stash = CALL(gv_stashpvn, STR_WITH_LEN("JavaBin::Enum"), 0);
SvREFCNT(stash)++;
SvSTASH_set(sv, stash);
SV *rv = newSV_type(SVt_IV);
SvROK_on(rv);
SvRV_set(rv, sv);
return rv;
}
read_string: {
const STRLEN len = READ_LEN;
SV *sv = newSV_type(SVt_PV);
char *str = SvPVX(sv) = (char*)safemalloc(len);
memcpy(str, in, len);
SvCUR(sv) = SvLEN(sv) = len;
SvFLAGS(sv) |= SVf_POK | SVp_POK | SVf_UTF8;
in += len;
return sv;
}
read_small_int: {
uint32_t result = in[-1] & 15;
if (in[-1] & 16)
result |= read_v_int() << 4;
return newSViv(result);
}
read_small_long: {
uint64_t result = in[-1] & 15;
// Inlined variable-length +ve long code, see read_v_int().
if (in[-1] & 16) {
uint8_t shift = 4;
do result |= (*in++ & 127) << shift;
while (in[-1] & 128 && (shift += 7));
}
return newSViv(result);
}
read_array: {
AV *av = (AV*)newSV_type(SVt_PVAV);
SSize_t len = READ_LEN;
SV **ary = safemalloc(len * sizeof(SV*));
AvALLOC(av) = AvARRAY(av) = ary;
AvFILLp(av) = AvMAX(av) = len - 1;
while (len--)
*ary++ = read_sv(aTHX);
SV *rv = newSV_type(SVt_IV);
SvROK_on(rv);
SvRV(rv) = (SV*)av;
return rv;
}
}
static void grow_out(pTHX_ const STRLEN want) {
const STRLEN len = out_buf - (uint8_t *)SvPVX(out_sv);
// If we want more than we have, realloc the string.
if (len + want >= SvLEN(out_sv)) {
sv_grow(out_sv, len + want);
out_buf = (uint8_t *)SvPVX(out_sv) + len;
}
}
static void write_v_int(uint32_t i) {
while (i & ~127) {
*out_buf++ = (i & 127) | 128;
i >>= 7;
}
*out_buf++ = i;
}
static void write_shifted_tag(uint8_t tag, uint32_t len) {
if (len < 31)
*out_buf++ = tag | len;
else {
*out_buf++ = tag | 31;
write_v_int(len - 31);
}
}
static void write_sv(pTHX_ SV *sv) {
SvGETMAGIC(sv);
if (SvPOKp(sv)) {
const STRLEN len = SvCUR(sv);
grow_out(aTHX_ len + 5);
write_shifted_tag(32, len);
memcpy(out_buf, SvPVX(sv), len);
out_buf += len;
}
else if (SvNOKp(sv)) {
const int_double u = { .d = SvNV(sv) };
grow_out(aTHX_ 9);
*out_buf++ = 5;
*out_buf++ = u.i >> 56;
*out_buf++ = u.i >> 48;
*out_buf++ = u.i >> 40;
*out_buf++ = u.i >> 32;
*out_buf++ = u.i >> 24;
*out_buf++ = u.i >> 16;
*out_buf++ = u.i >> 8;
*out_buf++ = u.i;
}
else if (SvIOKp(sv)) {
SV *single_hook_call(pTHX_ SV *self, const char *hook_id_str, const char *id_pre,
const char *id, const SingleHook *hook, SV *in, int mortal)
{
dSP;
int count;
SV *out;
CT_DEBUG(MAIN, ("single_hook_call(hid='%s', id='%s%s', hook=%p, in=%p(%d), mortal=%d)",
hook_id_str, id_pre, id, hook, in, in ? (int) SvREFCNT(in) : 0, mortal));
assert(self != NULL);
assert(hook != NULL);
if (hook->sub == NULL)
return in;
ENTER;
SAVETMPS;
PUSHMARK(SP);
if (hook->arg)
{
I32 ix, len;
len = av_len(hook->arg);
for (ix = 0; ix <= len; ++ix)
{
SV **pSV = av_fetch(hook->arg, ix, 0);
SV *sv;
if (pSV == NULL)
fatal("NULL returned by av_fetch() in single_hook_call()");
if (SvROK(*pSV) && sv_isa(*pSV, ARGTYPE_PACKAGE))
{
HookArgType type = (HookArgType) SvIV(SvRV(*pSV));
switch (type)
{
case HOOK_ARG_SELF:
sv = sv_mortalcopy(self);
break;
case HOOK_ARG_DATA:
assert(in != NULL);
sv = sv_mortalcopy(in);
break;
case HOOK_ARG_TYPE:
assert(id != NULL);
sv = sv_newmortal();
if (id_pre)
{
sv_setpv(sv, id_pre);
sv_catpv(sv, CONST_CHAR(id));
}
else
sv_setpv(sv, id);
break;
case HOOK_ARG_HOOK:
if (hook_id_str)
{
sv = sv_newmortal();
sv_setpv(sv, hook_id_str);
}
else
{
sv = &PL_sv_undef;
}
break;
default:
fatal("Invalid hook argument type (%d) in single_hook_call()", type);
break;
}
}
else
sv = sv_mortalcopy(*pSV);
XPUSHs(sv);
}
}
else
{
if (in)
{
/* only push the data argument */
XPUSHs(in);
}
}
PUTBACK;
count = call_sv(hook->sub, G_SCALAR);
SPAGAIN;
if (count != 1)
fatal("Hook returned %d elements instead of 1", count);
out = POPs;
CT_DEBUG(MAIN, ("single_hook_call: in=%p(%d), out=%p(%d)",
in, in ? (int) SvREFCNT(in) : 0, out, (int) SvREFCNT(out)));
if (!mortal && in != NULL)
SvREFCNT_dec(in);
SvREFCNT_inc(out);
PUTBACK;
FREETMPS;
LEAVE;
if (mortal)
sv_2mortal(out);
CT_DEBUG(MAIN, ("single_hook_call: out=%p(%d)", out, (int) SvREFCNT(out)));
return out;
}
static int perl_init_aaaa()
{
dTARG;
dSP;
listop_list[0].op_ppaddr = PL_ppaddr[OP_LEAVE];
op_list[0].op_ppaddr = PL_ppaddr[OP_ENTER];
cop_list[0].op_ppaddr = PL_ppaddr[OP_NEXTSTATE];
cop_list[0].cop_warnings = pWARN_STD;
CopFILE_set(&cop_list[0], "hello.p");
CopSTASHPV_set(&cop_list[0], "main");
listop_list[1].op_ppaddr = PL_ppaddr[OP_PRINT];
op_list[1].op_ppaddr = PL_ppaddr[OP_PUSHMARK];
svop_list[0].op_ppaddr = PL_ppaddr[OP_CONST];
gv_list[0] = gv_fetchpv("main::/", TRUE, SVt_PV);
SvFLAGS(gv_list[0]) = 0x600d;
GvFLAGS(gv_list[0]) = 0xa;
GvLINE(gv_list[0]) = 0;
SvPVX(gv_list[0]) = emptystring;
SvREFCNT(gv_list[0]) += 4;
GvREFCNT(gv_list[0]) += 1;
gv_list[1] = gv_fetchpv("main::stderr", TRUE, SVt_PV);
SvFLAGS(gv_list[1]) = 0x600d;
GvFLAGS(gv_list[1]) = 0x2;
GvLINE(gv_list[1]) = 0;
SvPVX(gv_list[1]) = emptystring;
SvREFCNT(gv_list[1]) += 2;
GvREFCNT(gv_list[1]) += 1;
GvSV(gv_list[1]) = &sv_list[0];
GvFILE(gv_list[1]) = "hello.p";
IoIFP((IO*)&sv_list[1])=PerlIO_stderr();
IoOFP((IO*)&sv_list[1])=PerlIO_stderr();
hv0 = gv_stashpv("FileHandle", TRUE);
SvSTASH((IO*)&sv_list[1]) = hv0;
GvIOp(gv_list[1]) = (IO*)&sv_list[1];
gv_list[2] = gv_fetchpv("main::SIG", TRUE, SVt_PV);
SvFLAGS(gv_list[2]) = 0x600d;
GvFLAGS(gv_list[2]) = 0xa;
GvLINE(gv_list[2]) = 62;
SvPVX(gv_list[2]) = emptystring;
SvREFCNT(gv_list[2]) += 12;
GvREFCNT(gv_list[2]) += 1;
gv_list[3] = gv_fetchpv("main::,", TRUE, SVt_PV);
SvFLAGS(gv_list[3]) = 0x600d;
GvFLAGS(gv_list[3]) = 0xa;
GvLINE(gv_list[3]) = 474;
SvPVX(gv_list[3]) = emptystring;
SvREFCNT(gv_list[3]) += 6;
GvREFCNT(gv_list[3]) += 1;
gv_list[4] = gv_fetchpv("utf8::unicode_to_native", TRUE, SVt_PV);
SvFLAGS(gv_list[4]) = 0x600d;
GvFLAGS(gv_list[4]) = 0xa;
GvLINE(gv_list[4]) = 0;
SvPVX(gv_list[4]) = emptystring;
SvREFCNT(gv_list[4]) += 3;
GvREFCNT(gv_list[4]) += 1;
GvSV(gv_list[4]) = &sv_list[2];
GvCV(gv_list[4]) = (CV*)((perl_get_cv("utf8::unicode_to_native",TRUE)));
GvFILE(gv_list[4]) = "hello.p";
gv_list[5] = gv_fetchpv("utf8::encode", TRUE, SVt_PV);
SvFLAGS(gv_list[5]) = 0x600d;
GvFLAGS(gv_list[5]) = 0x2;
GvLINE(gv_list[5]) = 0;
SvPVX(gv_list[5]) = emptystring;
SvREFCNT(gv_list[5]) += 2;
GvREFCNT(gv_list[5]) += 1;
GvSV(gv_list[5]) = &sv_list[3];
GvCV(gv_list[5]) = (CV*)((perl_get_cv("utf8::encode",TRUE)));
GvFILE(gv_list[5]) = "hello.p";
gv_list[6] = gv_fetchpv("utf8::valid", TRUE, SVt_PV);
SvFLAGS(gv_list[6]) = 0x600d;
GvFLAGS(gv_list[6]) = 0x2;
GvLINE(gv_list[6]) = 0;
SvPVX(gv_list[6]) = emptystring;
SvREFCNT(gv_list[6]) += 2;
GvREFCNT(gv_list[6]) += 1;
GvSV(gv_list[6]) = &sv_list[4];
GvCV(gv_list[6]) = (CV*)((perl_get_cv("utf8::valid",TRUE)));
GvFILE(gv_list[6]) = "hello.p";
gv_list[7] = gv_fetchpv("utf8::native_to_unicode", TRUE, SVt_PV);
SvFLAGS(gv_list[7]) = 0x600d;
GvFLAGS(gv_list[7]) = 0x2;
GvLINE(gv_list[7]) = 0;
SvPVX(gv_list[7]) = emptystring;
SvREFCNT(gv_list[7]) += 2;
GvREFCNT(gv_list[7]) += 1;
GvSV(gv_list[7]) = &sv_list[5];
GvCV(gv_list[7]) = (CV*)((perl_get_cv("utf8::native_to_unicode",TRUE)));
GvFILE(gv_list[7]) = "hello.p";
gv_list[8] = gv_fetchpv("utf8::decode", TRUE, SVt_PV);
SvFLAGS(gv_list[8]) = 0x600d;
GvFLAGS(gv_list[8]) = 0x2;
GvLINE(gv_list[8]) = 0;
SvPVX(gv_list[8]) = emptystring;
SvREFCNT(gv_list[8]) += 2;
GvREFCNT(gv_list[8]) += 1;
GvSV(gv_list[8]) = &sv_list[6];
GvCV(gv_list[8]) = (CV*)((perl_get_cv("utf8::decode",TRUE)));
GvFILE(gv_list[8]) = "hello.p";
gv_list[9] = gv_fetchpv("utf8::downgrade", TRUE, SVt_PV);
SvFLAGS(gv_list[9]) = 0x600d;
GvFLAGS(gv_list[9]) = 0x2;
GvLINE(gv_list[9]) = 0;
SvPVX(gv_list[9]) = emptystring;
SvREFCNT(gv_list[9]) += 2;
GvREFCNT(gv_list[9]) += 1;
GvSV(gv_list[9]) = &sv_list[7];
GvCV(gv_list[9]) = (CV*)((perl_get_cv("utf8::downgrade",TRUE)));
GvFILE(gv_list[9]) = "hello.p";
gv_list[10] = gv_fetchpv("utf8::upgrade", TRUE, SVt_PV);
SvFLAGS(gv_list[10]) = 0x600d;
GvFLAGS(gv_list[10]) = 0x2;
GvLINE(gv_list[10]) = 0;
SvPVX(gv_list[10]) = emptystring;
SvREFCNT(gv_list[10]) += 2;
GvREFCNT(gv_list[10]) += 1;
GvSV(gv_list[10]) = &sv_list[8];
GvCV(gv_list[10]) = (CV*)((perl_get_cv("utf8::upgrade",TRUE)));
GvFILE(gv_list[10]) = "hello.p";
gv_list[11] = gv_fetchpv("utf8::is_utf8", TRUE, SVt_PV);
SvFLAGS(gv_list[11]) = 0x600d;
GvFLAGS(gv_list[11]) = 0x2;
GvLINE(gv_list[11]) = 0;
SvPVX(gv_list[11]) = emptystring;
SvREFCNT(gv_list[11]) += 2;
GvREFCNT(gv_list[11]) += 1;
GvSV(gv_list[11]) = &sv_list[9];
GvCV(gv_list[11]) = (CV*)((perl_get_cv("utf8::is_utf8",TRUE)));
GvFILE(gv_list[11]) = "hello.p";
gv_list[12] = gv_fetchpv("main::\"", TRUE, SVt_PV);
SvFLAGS(gv_list[12]) = 0x600d;
GvFLAGS(gv_list[12]) = 0xa;
GvLINE(gv_list[12]) = 0;
SvPVX(gv_list[12]) = emptystring;
SvREFCNT(gv_list[12]) += 10;
GvREFCNT(gv_list[12]) += 1;
gv_list[13] = gv_fetchpv("main::stdout", TRUE, SVt_PV);
SvFLAGS(gv_list[13]) = 0x600d;
GvFLAGS(gv_list[13]) = 0x2;
GvLINE(gv_list[13]) = 0;
SvPVX(gv_list[13]) = emptystring;
SvREFCNT(gv_list[13]) += 2;
GvREFCNT(gv_list[13]) += 1;
GvSV(gv_list[13]) = &sv_list[10];
GvFILE(gv_list[13]) = "hello.p";
IoIFP((IO*)&sv_list[11])=PerlIO_stdout();
IoOFP((IO*)&sv_list[11])=PerlIO_stdout();
SvSTASH((IO*)&sv_list[11]) = hv0;
GvIOp(gv_list[13]) = (IO*)&sv_list[11];
gv_list[14] = gv_fetchpv("main::\022", TRUE, SVt_PV);
SvFLAGS(gv_list[14]) = 0x600d;
GvFLAGS(gv_list[14]) = 0x2;
GvLINE(gv_list[14]) = 0;
SvPVX(gv_list[14]) = emptystring;
SvREFCNT(gv_list[14]) += 2;
GvREFCNT(gv_list[14]) += 1;
gv_list[15] = gv_fetchpv("main::|", TRUE, SVt_PV);
SvFLAGS(gv_list[15]) = 0x600d;
GvFLAGS(gv_list[15]) = 0xa;
GvLINE(gv_list[15]) = 466;
SvPVX(gv_list[15]) = emptystring;
SvREFCNT(gv_list[15]) += 5;
GvREFCNT(gv_list[15]) += 1;
gv_list[16] = gv_fetchpv("Regexp::DESTROY", TRUE, SVt_PV);
SvFLAGS(gv_list[16]) = 0x600d;
GvFLAGS(gv_list[16]) = 0x2;
GvLINE(gv_list[16]) = 0;
SvPVX(gv_list[16]) = emptystring;
SvREFCNT(gv_list[16]) += 2;
GvREFCNT(gv_list[16]) += 1;
GvSV(gv_list[16]) = &sv_list[12];
GvCV(gv_list[16]) = (CV*)((perl_get_cv("Regexp::DESTROY",TRUE)));
GvFILE(gv_list[16]) = "hello.p";
gv_list[17] = gv_fetchpv("main::\f", TRUE, SVt_PV);
SvFLAGS(gv_list[17]) = 0x600d;
GvFLAGS(gv_list[17]) = 0xa;
GvLINE(gv_list[17]) = 554;
SvPVX(gv_list[17]) = emptystring;
SvREFCNT(gv_list[17]) += 4;
GvREFCNT(gv_list[17]) += 1;
gv_list[18] = gv_fetchpv("main::^", TRUE, SVt_PV);
SvFLAGS(gv_list[18]) = 0x600d;
GvFLAGS(gv_list[18]) = 0xa;
GvLINE(gv_list[18]) = 538;
SvPVX(gv_list[18]) = emptystring;
SvREFCNT(gv_list[18]) += 4;
GvREFCNT(gv_list[18]) += 1;
gv_list[19] = gv_fetchpv("main::\001", TRUE, SVt_PV);
SvFLAGS(gv_list[19]) = 0x600d;
GvFLAGS(gv_list[19]) = 0xa;
GvLINE(gv_list[19]) = 562;
SvPVX(gv_list[19]) = emptystring;
SvREFCNT(gv_list[19]) += 5;
GvREFCNT(gv_list[19]) += 1;
gv_list[20] = gv_fetchpv("main::$", TRUE, SVt_PV);
SvFLAGS(gv_list[20]) = 0x600d;
GvFLAGS(gv_list[20]) = 0x2;
GvLINE(gv_list[20]) = 0;
SvPVX(gv_list[20]) = emptystring;
SvREFCNT(gv_list[20]) += 2;
GvREFCNT(gv_list[20]) += 1;
gv_list[21] = gv_fetchpv("main::\\", TRUE, SVt_PV);
SvFLAGS(gv_list[21]) = 0x600d;
GvFLAGS(gv_list[21]) = 0xa;
GvLINE(gv_list[21]) = 441;
SvPVX(gv_list[21]) = emptystring;
SvREFCNT(gv_list[21]) += 9;
GvREFCNT(gv_list[21]) += 1;
gv_list[22] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm", TRUE, SVt_PV);
SvFLAGS(gv_list[22]) = 0x600d;
GvFLAGS(gv_list[22]) = 0x2;
GvLINE(gv_list[22]) = 4294967295;
SvPVX(gv_list[22]) = emptystring;
SvREFCNT(gv_list[22]) += 2;
GvREFCNT(gv_list[22]) += 1;
xpv_list[0].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm", 56);
GvSV(gv_list[22]) = &sv_list[13];
GvFILE(gv_list[22]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[23] = gv_fetchpv("main::~", TRUE, SVt_PV);
SvFLAGS(gv_list[23]) = 0x600d;
GvFLAGS(gv_list[23]) = 0xa;
GvLINE(gv_list[23]) = 530;
SvPVX(gv_list[23]) = emptystring;
SvREFCNT(gv_list[23]) += 4;
GvREFCNT(gv_list[23]) += 1;
gv_list[24] = gv_fetchpv("main::-", TRUE, SVt_PV);
SvFLAGS(gv_list[24]) = 0x600d;
GvFLAGS(gv_list[24]) = 0xa;
GvLINE(gv_list[24]) = 0;
SvPVX(gv_list[24]) = emptystring;
SvREFCNT(gv_list[24]) += 4;
GvREFCNT(gv_list[24]) += 1;
gv_list[25] = gv_fetchpv("main::_<perlmain.c", TRUE, SVt_PV);
SvFLAGS(gv_list[25]) = 0x600d;
GvFLAGS(gv_list[25]) = 0x2;
GvLINE(gv_list[25]) = 0;
SvPVX(gv_list[25]) = emptystring;
SvREFCNT(gv_list[25]) += 2;
GvREFCNT(gv_list[25]) += 1;
xpv_list[1].xpv_pv = savepvn("perlmain.c", 10);
GvSV(gv_list[25]) = &sv_list[14];
GvFILE(gv_list[25]) = "hello.p";
gv_list[26] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/File/Spec/Unix.pm", TRUE, SVt_PV);
SvFLAGS(gv_list[26]) = 0x600d;
GvFLAGS(gv_list[26]) = 0x2;
GvLINE(gv_list[26]) = 98;
SvPVX(gv_list[26]) = emptystring;
SvREFCNT(gv_list[26]) += 2;
GvREFCNT(gv_list[26]) += 1;
xpv_list[2].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/File/Spec/Unix.pm", 38);
GvSV(gv_list[26]) = &sv_list[15];
GvFILE(gv_list[26]) = "x/\031\b q\024\b\332T\305";
gv_list[27] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/C/C.so", TRUE, SVt_PV);
SvFLAGS(gv_list[27]) = 0x600d;
GvFLAGS(gv_list[27]) = 0x2;
GvLINE(gv_list[27]) = 87;
SvPVX(gv_list[27]) = emptystring;
SvREFCNT(gv_list[27]) += 2;
GvREFCNT(gv_list[27]) += 1;
xpv_list[3].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/C/C.so", 58);
GvSV(gv_list[27]) = &sv_list[16];
GvFILE(gv_list[27]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[28] = gv_fetchpv("main::_<universal.c", TRUE, SVt_PV);
SvFLAGS(gv_list[28]) = 0x600d;
GvFLAGS(gv_list[28]) = 0x2;
GvLINE(gv_list[28]) = 0;
SvPVX(gv_list[28]) = emptystring;
SvREFCNT(gv_list[28]) += 2;
GvREFCNT(gv_list[28]) += 1;
xpv_list[4].xpv_pv = savepvn("universal.c", 11);
GvSV(gv_list[28]) = &sv_list[17];
GvFILE(gv_list[28]) = "hello.p";
gv_list[29] = gv_fetchpv("main::BEGIN", TRUE, SVt_PV);
SvFLAGS(gv_list[29]) = 0x600d;
GvFLAGS(gv_list[29]) = 0x2;
GvLINE(gv_list[29]) = 0;
SvPVX(gv_list[29]) = emptystring;
SvREFCNT(gv_list[29]) += 2;
GvREFCNT(gv_list[29]) += 1;
GvSV(gv_list[29]) = &sv_list[18];
GvFILE(gv_list[29]) = "hello.p";
gv_list[30] = gv_fetchpv("main::_<xsutils.c", TRUE, SVt_PV);
SvFLAGS(gv_list[30]) = 0x600d;
GvFLAGS(gv_list[30]) = 0x2;
GvLINE(gv_list[30]) = 0;
SvPVX(gv_list[30]) = emptystring;
SvREFCNT(gv_list[30]) += 2;
GvREFCNT(gv_list[30]) += 1;
xpv_list[5].xpv_pv = savepvn("xsutils.c", 9);
GvSV(gv_list[30]) = &sv_list[19];
GvFILE(gv_list[30]) = "hello.p";
gv_list[31] = gv_fetchpv("main::!", TRUE, SVt_PV);
SvFLAGS(gv_list[31]) = 0x600d;
GvFLAGS(gv_list[31]) = 0xa;
GvLINE(gv_list[31]) = 2054;
SvPVX(gv_list[31]) = emptystring;
SvREFCNT(gv_list[31]) += 3;
GvREFCNT(gv_list[31]) += 1;
GvFILE(gv_list[31]) = "";
gv_list[32] = gv_fetchpv("main::\024AINT", TRUE, SVt_PV);
SvFLAGS(gv_list[32]) = 0x600d;
GvFLAGS(gv_list[32]) = 0xa;
GvLINE(gv_list[32]) = 1589;
SvPVX(gv_list[32]) = emptystring;
SvREFCNT(gv_list[32]) += 3;
GvREFCNT(gv_list[32]) += 1;
sv_magic((SV*)&sv_list[20], (SV*)gv_list[32], '\000', "\024AINT", 5);
GvSV(gv_list[32]) = &sv_list[20];
GvFILE(gv_list[32]) = "";
gv_list[33] = gv_fetchpv("main::\017", TRUE, SVt_PV);
SvFLAGS(gv_list[33]) = 0x600d;
GvFLAGS(gv_list[33]) = 0xa;
GvLINE(gv_list[33]) = 55;
SvPVX(gv_list[33]) = emptystring;
SvREFCNT(gv_list[33]) += 4;
GvREFCNT(gv_list[33]) += 1;
gv_list[34] = gv_fetchpv("main::%", TRUE, SVt_PV);
SvFLAGS(gv_list[34]) = 0x600d;
GvFLAGS(gv_list[34]) = 0xa;
GvLINE(gv_list[34]) = 506;
SvPVX(gv_list[34]) = emptystring;
SvREFCNT(gv_list[34]) += 4;
GvREFCNT(gv_list[34]) += 1;
gv_list[35] = gv_fetchpv("main::\030", TRUE, SVt_PV);
SvFLAGS(gv_list[35]) = 0x600d;
GvFLAGS(gv_list[35]) = 0x2;
GvLINE(gv_list[35]) = 0;
SvPVX(gv_list[35]) = emptystring;
SvREFCNT(gv_list[35]) += 2;
GvREFCNT(gv_list[35]) += 1;
gv_list[36] = gv_fetchpv("main::_", TRUE, SVt_PV);
SvFLAGS(gv_list[36]) = 0x630d;
GvFLAGS(gv_list[36]) = 0xa;
GvLINE(gv_list[36]) = 0;
SvPVX(gv_list[36]) = emptystring;
SvREFCNT(gv_list[36]) += 470;
GvREFCNT(gv_list[36]) += 1;
gv_list[37] = gv_fetchpv("main::+", TRUE, SVt_PV);
SvFLAGS(gv_list[37]) = 0x600d;
GvFLAGS(gv_list[37]) = 0x2;
GvLINE(gv_list[37]) = 0;
SvPVX(gv_list[37]) = emptystring;
SvREFCNT(gv_list[37]) += 2;
GvREFCNT(gv_list[37]) += 1;
gv_list[38] = gv_fetchpv("Internals::SvREFCNT", TRUE, SVt_PV);
SvFLAGS(gv_list[38]) = 0x600d;
GvFLAGS(gv_list[38]) = 0x2;
GvLINE(gv_list[38]) = 0;
SvPVX(gv_list[38]) = emptystring;
SvREFCNT(gv_list[38]) += 2;
GvREFCNT(gv_list[38]) += 1;
GvSV(gv_list[38]) = &sv_list[21];
GvCV(gv_list[38]) = (CV*)((perl_get_cv("Internals::SvREFCNT",TRUE)));
GvFILE(gv_list[38]) = "hello.p";
gv_list[39] = gv_fetchpv("Internals::hv_clear_placeholders", TRUE, SVt_PV);
SvFLAGS(gv_list[39]) = 0x600d;
GvFLAGS(gv_list[39]) = 0x2;
GvLINE(gv_list[39]) = 0;
SvPVX(gv_list[39]) = emptystring;
SvREFCNT(gv_list[39]) += 2;
GvREFCNT(gv_list[39]) += 1;
GvSV(gv_list[39]) = &sv_list[22];
GvCV(gv_list[39]) = (CV*)((perl_get_cv("Internals::hv_clear_placeholders",TRUE)));
GvFILE(gv_list[39]) = "hello.p";
gv_list[40] = gv_fetchpv("Internals::hash_seed", TRUE, SVt_PV);
SvFLAGS(gv_list[40]) = 0x600d;
GvFLAGS(gv_list[40]) = 0x2;
GvLINE(gv_list[40]) = 0;
SvPVX(gv_list[40]) = emptystring;
SvREFCNT(gv_list[40]) += 2;
GvREFCNT(gv_list[40]) += 1;
GvSV(gv_list[40]) = &sv_list[23];
GvCV(gv_list[40]) = (CV*)((perl_get_cv("Internals::hash_seed",TRUE)));
GvFILE(gv_list[40]) = "hello.p";
gv_list[41] = gv_fetchpv("Internals::SvREADONLY", TRUE, SVt_PV);
SvFLAGS(gv_list[41]) = 0x600d;
GvFLAGS(gv_list[41]) = 0x2;
GvLINE(gv_list[41]) = 0;
SvPVX(gv_list[41]) = emptystring;
SvREFCNT(gv_list[41]) += 2;
GvREFCNT(gv_list[41]) += 1;
GvSV(gv_list[41]) = &sv_list[24];
GvCV(gv_list[41]) = (CV*)((perl_get_cv("Internals::SvREADONLY",TRUE)));
GvFILE(gv_list[41]) = "hello.p";
gv_list[42] = gv_fetchpv("Internals::HvREHASH", TRUE, SVt_PV);
SvFLAGS(gv_list[42]) = 0x600d;
GvFLAGS(gv_list[42]) = 0x2;
GvLINE(gv_list[42]) = 0;
SvPVX(gv_list[42]) = emptystring;
SvREFCNT(gv_list[42]) += 2;
GvREFCNT(gv_list[42]) += 1;
GvSV(gv_list[42]) = &sv_list[25];
GvCV(gv_list[42]) = (CV*)((perl_get_cv("Internals::HvREHASH",TRUE)));
GvFILE(gv_list[42]) = "hello.p";
gv_list[43] = gv_fetchpv("Internals::rehash_seed", TRUE, SVt_PV);
SvFLAGS(gv_list[43]) = 0x600d;
GvFLAGS(gv_list[43]) = 0x2;
GvLINE(gv_list[43]) = 0;
SvPVX(gv_list[43]) = emptystring;
SvREFCNT(gv_list[43]) += 2;
GvREFCNT(gv_list[43]) += 1;
GvSV(gv_list[43]) = &sv_list[26];
GvCV(gv_list[43]) = (CV*)((perl_get_cv("Internals::rehash_seed",TRUE)));
GvFILE(gv_list[43]) = "hello.p";
gv_list[44] = gv_fetchpv("main::STDIN", TRUE, SVt_PV);
SvFLAGS(gv_list[44]) = 0x600d;
GvFLAGS(gv_list[44]) = 0xa;
GvLINE(gv_list[44]) = 0;
SvPVX(gv_list[44]) = emptystring;
SvREFCNT(gv_list[44]) += 2;
GvREFCNT(gv_list[44]) += 1;
gv_list[45] = gv_fetchpv("DB::args", TRUE, SVt_PV);
SvFLAGS(gv_list[45]) = 0x600d;
GvFLAGS(gv_list[45]) = 0xa;
GvLINE(gv_list[45]) = 431;
SvPVX(gv_list[45]) = emptystring;
SvREFCNT(gv_list[45]) += 4;
GvREFCNT(gv_list[45]) += 1;
GvSV(gv_list[45]) = &sv_list[27];
GvAV(gv_list[45]) = (AV*)&sv_list[28];
GvFILE(gv_list[45]) = "\260\r\016\b";
gv_list[46] = gv_fetchpv("main::\026", TRUE, SVt_PV);
SvFLAGS(gv_list[46]) = 0x600d;
GvFLAGS(gv_list[46]) = 0xa;
GvLINE(gv_list[46]) = 30;
SvPVX(gv_list[46]) = emptystring;
SvREFCNT(gv_list[46]) += 2;
GvREFCNT(gv_list[46]) += 1;
gv_list[47] = gv_fetchpv("main::=", TRUE, SVt_PV);
SvFLAGS(gv_list[47]) = 0x600d;
GvFLAGS(gv_list[47]) = 0xa;
GvLINE(gv_list[47]) = 514;
SvPVX(gv_list[47]) = emptystring;
SvREFCNT(gv_list[47]) += 4;
GvREFCNT(gv_list[47]) += 1;
gv_list[48] = gv_fetchpv("main::2", TRUE, SVt_PV);
SvFLAGS(gv_list[48]) = 0x600d;
GvFLAGS(gv_list[48]) = 0xa;
GvLINE(gv_list[48]) = 257;
SvPVX(gv_list[48]) = emptystring;
SvREFCNT(gv_list[48]) += 6;
GvREFCNT(gv_list[48]) += 1;
gv_list[49] = gv_fetchpv("main::_<Fcntl.c", TRUE, SVt_PV);
SvFLAGS(gv_list[49]) = 0x600d;
GvFLAGS(gv_list[49]) = 0x2;
GvLINE(gv_list[49]) = 92;
SvPVX(gv_list[49]) = emptystring;
SvREFCNT(gv_list[49]) += 2;
GvREFCNT(gv_list[49]) += 1;
xpv_list[6].xpv_pv = savepvn("Fcntl.c", 7);
GvSV(gv_list[49]) = &sv_list[29];
GvFILE(gv_list[49]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[50] = gv_fetchpv("main::1", TRUE, SVt_PV);
SvFLAGS(gv_list[50]) = 0x600d;
GvFLAGS(gv_list[50]) = 0xa;
GvLINE(gv_list[50]) = 74;
SvPVX(gv_list[50]) = emptystring;
SvREFCNT(gv_list[50]) += 28;
GvREFCNT(gv_list[50]) += 1;
gv_list[51] = gv_fetchpv("main::_<IO.c", TRUE, SVt_PV);
SvFLAGS(gv_list[51]) = 0x600d;
GvFLAGS(gv_list[51]) = 0x2;
GvLINE(gv_list[51]) = 92;
SvPVX(gv_list[51]) = emptystring;
SvREFCNT(gv_list[51]) += 2;
GvREFCNT(gv_list[51]) += 1;
xpv_list[7].xpv_pv = savepvn("IO.c", 4);
GvSV(gv_list[51]) = &sv_list[30];
GvFILE(gv_list[51]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[52] = gv_fetchpv("main::\027ARNING_BITS", TRUE, SVt_PV);
SvFLAGS(gv_list[52]) = 0x600d;
GvFLAGS(gv_list[52]) = 0xa;
GvLINE(gv_list[52]) = 341;
SvPVX(gv_list[52]) = emptystring;
SvREFCNT(gv_list[52]) += 6;
GvREFCNT(gv_list[52]) += 1;
sv_magic((SV*)&sv_list[31], (SV*)gv_list[52], '\000', "\027ARNING_BITS", 12);
GvSV(gv_list[52]) = &sv_list[31];
GvFILE(gv_list[52]) = "\260\r\016\b";
gv_list[53] = gv_fetchpv("main::_<B.c", TRUE, SVt_PV);
SvFLAGS(gv_list[53]) = 0x600d;
GvFLAGS(gv_list[53]) = 0x2;
GvLINE(gv_list[53]) = 92;
SvPVX(gv_list[53]) = emptystring;
SvREFCNT(gv_list[53]) += 2;
GvREFCNT(gv_list[53]) += 1;
xpv_list[8].xpv_pv = savepvn("B.c", 3);
GvSV(gv_list[53]) = &sv_list[32];
GvFILE(gv_list[53]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[54] = gv_fetchpv("main::_<DynaLoader.c", TRUE, SVt_PV);
SvFLAGS(gv_list[54]) = 0x600d;
GvFLAGS(gv_list[54]) = 0x2;
GvLINE(gv_list[54]) = 16;
SvPVX(gv_list[54]) = emptystring;
SvREFCNT(gv_list[54]) += 2;
GvREFCNT(gv_list[54]) += 1;
xpv_list[9].xpv_pv = savepvn("DynaLoader.c", 12);
GvSV(gv_list[54]) = &sv_list[33];
GvFILE(gv_list[54]) = "\335\367\302";
gv_list[55] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/IO/IO.so", TRUE, SVt_PV);
SvFLAGS(gv_list[55]) = 0x600d;
GvFLAGS(gv_list[55]) = 0x2;
GvLINE(gv_list[55]) = 87;
SvPVX(gv_list[55]) = emptystring;
SvREFCNT(gv_list[55]) += 2;
GvREFCNT(gv_list[55]) += 1;
xpv_list[10].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/IO/IO.so", 58);
GvSV(gv_list[55]) = &sv_list[34];
GvFILE(gv_list[55]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[56] = gv_fetchpv("attributes::bootstrap", TRUE, SVt_PV);
SvFLAGS(gv_list[56]) = 0x600d;
GvFLAGS(gv_list[56]) = 0x2;
GvLINE(gv_list[56]) = 0;
SvPVX(gv_list[56]) = emptystring;
SvREFCNT(gv_list[56]) += 2;
GvREFCNT(gv_list[56]) += 1;
GvSV(gv_list[56]) = &sv_list[35];
GvFILE(gv_list[56]) = "hello.p";
gv_list[57] = gv_fetchpv("main::stdin", TRUE, SVt_PV);
SvFLAGS(gv_list[57]) = 0x600d;
GvFLAGS(gv_list[57]) = 0x2;
GvLINE(gv_list[57]) = 0;
SvPVX(gv_list[57]) = emptystring;
SvREFCNT(gv_list[57]) += 2;
GvREFCNT(gv_list[57]) += 1;
GvSV(gv_list[57]) = &sv_list[36];
GvFILE(gv_list[57]) = "hello.p";
IoIFP((IO*)&sv_list[37])=PerlIO_stdin();
IoOFP((IO*)&sv_list[37])=PerlIO_stdin();
SvSTASH((IO*)&sv_list[37]) = hv0;
GvIOp(gv_list[57]) = (IO*)&sv_list[37];
gv_list[58] = gv_fetchpv("main::ARGV", TRUE, SVt_PV);
SvFLAGS(gv_list[58]) = 0x600d;
GvFLAGS(gv_list[58]) = 0x2;
GvLINE(gv_list[58]) = 0;
SvPVX(gv_list[58]) = emptystring;
SvREFCNT(gv_list[58]) += 2;
GvREFCNT(gv_list[58]) += 1;
gv_list[59] = gv_fetchpv("main::INC", TRUE, SVt_PV);
SvFLAGS(gv_list[59]) = 0x600d;
GvFLAGS(gv_list[59]) = 0xa;
GvLINE(gv_list[59]) = 0;
SvPVX(gv_list[59]) = emptystring;
SvREFCNT(gv_list[59]) += 7;
GvREFCNT(gv_list[59]) += 1;
GvSV(gv_list[59]) = &sv_list[38];
xpv_list[11].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi", 44);
xpv_list[12].xpv_pv = savepvn("/usr/lib/perl5/5.8.5", 20);
xpv_list[13].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5/i386-linux-thread-multi", 54);
xpv_list[14].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4/i386-linux-thread-multi", 54);
xpv_list[15].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3/i386-linux-thread-multi", 54);
xpv_list[16].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2/i386-linux-thread-multi", 54);
xpv_list[17].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1/i386-linux-thread-multi", 54);
xpv_list[18].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0/i386-linux-thread-multi", 54);
xpv_list[19].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5", 30);
xpv_list[20].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4", 30);
xpv_list[21].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3", 30);
xpv_list[22].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2", 30);
xpv_list[23].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1", 30);
xpv_list[24].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0", 30);
xpv_list[25].xpv_pv = savepvn("/usr/lib/perl5/site_perl", 24);
xpv_list[26].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5/i386-linux-thread-multi", 56);
xpv_list[27].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4/i386-linux-thread-multi", 56);
xpv_list[28].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3/i386-linux-thread-multi", 56);
xpv_list[29].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2/i386-linux-thread-multi", 56);
xpv_list[30].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1/i386-linux-thread-multi", 56);
xpv_list[31].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0/i386-linux-thread-multi", 56);
xpv_list[32].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5", 32);
xpv_list[33].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4", 32);
xpv_list[34].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3", 32);
xpv_list[35].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2", 32);
xpv_list[36].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1", 32);
xpv_list[37].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0", 32);
xpv_list[38].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl", 26);
xpv_list[39].xpv_pv = savepvn(".", 1);
xpv_list[40].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi", 44);
xpv_list[41].xpv_pv = savepvn("/usr/lib/perl5/5.8.5", 20);
xpv_list[42].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5/i386-linux-thread-multi", 54);
xpv_list[43].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4/i386-linux-thread-multi", 54);
xpv_list[44].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3/i386-linux-thread-multi", 54);
xpv_list[45].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2/i386-linux-thread-multi", 54);
xpv_list[46].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1/i386-linux-thread-multi", 54);
xpv_list[47].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0/i386-linux-thread-multi", 54);
xpv_list[48].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5", 30);
xpv_list[49].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4", 30);
xpv_list[50].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3", 30);
xpv_list[51].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2", 30);
xpv_list[52].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1", 30);
xpv_list[53].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0", 30);
xpv_list[54].xpv_pv = savepvn("/usr/lib/perl5/site_perl", 24);
xpv_list[55].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5/i386-linux-thread-multi", 56);
xpv_list[56].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4/i386-linux-thread-multi", 56);
xpv_list[57].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3/i386-linux-thread-multi", 56);
xpv_list[58].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2/i386-linux-thread-multi", 56);
xpv_list[59].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1/i386-linux-thread-multi", 56);
xpv_list[60].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0/i386-linux-thread-multi", 56);
xpv_list[61].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5", 32);
xpv_list[62].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4", 32);
xpv_list[63].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3", 32);
xpv_list[64].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2", 32);
xpv_list[65].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1", 32);
xpv_list[66].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0", 32);
xpv_list[67].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl", 26);
xpv_list[68].xpv_pv = savepvn(".", 1);
{
SV **svp;
AV *av = (AV*)&sv_list[39];
av_extend(av, 57);
svp = AvARRAY(av);
*svp++ = (SV*)&sv_list[40];
*svp++ = (SV*)&sv_list[41];
*svp++ = (SV*)&sv_list[42];
*svp++ = (SV*)&sv_list[43];
*svp++ = (SV*)&sv_list[44];
*svp++ = (SV*)&sv_list[45];
*svp++ = (SV*)&sv_list[46];
*svp++ = (SV*)&sv_list[47];
*svp++ = (SV*)&sv_list[48];
*svp++ = (SV*)&sv_list[49];
*svp++ = (SV*)&sv_list[50];
*svp++ = (SV*)&sv_list[51];
*svp++ = (SV*)&sv_list[52];
*svp++ = (SV*)&sv_list[53];
*svp++ = (SV*)&sv_list[54];
*svp++ = (SV*)&sv_list[55];
*svp++ = (SV*)&sv_list[56];
*svp++ = (SV*)&sv_list[57];
*svp++ = (SV*)&sv_list[58];
*svp++ = (SV*)&sv_list[59];
*svp++ = (SV*)&sv_list[60];
*svp++ = (SV*)&sv_list[61];
*svp++ = (SV*)&sv_list[62];
*svp++ = (SV*)&sv_list[63];
*svp++ = (SV*)&sv_list[64];
*svp++ = (SV*)&sv_list[65];
*svp++ = (SV*)&sv_list[66];
*svp++ = (SV*)&sv_list[67];
*svp++ = (SV*)&sv_list[68];
*svp++ = (SV*)&sv_list[69];
*svp++ = (SV*)&sv_list[70];
*svp++ = (SV*)&sv_list[71];
*svp++ = (SV*)&sv_list[72];
*svp++ = (SV*)&sv_list[73];
*svp++ = (SV*)&sv_list[74];
*svp++ = (SV*)&sv_list[75];
*svp++ = (SV*)&sv_list[76];
*svp++ = (SV*)&sv_list[77];
*svp++ = (SV*)&sv_list[78];
*svp++ = (SV*)&sv_list[79];
*svp++ = (SV*)&sv_list[80];
*svp++ = (SV*)&sv_list[81];
*svp++ = (SV*)&sv_list[82];
*svp++ = (SV*)&sv_list[83];
*svp++ = (SV*)&sv_list[84];
*svp++ = (SV*)&sv_list[85];
*svp++ = (SV*)&sv_list[86];
*svp++ = (SV*)&sv_list[87];
*svp++ = (SV*)&sv_list[88];
*svp++ = (SV*)&sv_list[89];
*svp++ = (SV*)&sv_list[90];
*svp++ = (SV*)&sv_list[91];
*svp++ = (SV*)&sv_list[92];
*svp++ = (SV*)&sv_list[93];
*svp++ = (SV*)&sv_list[94];
*svp++ = (SV*)&sv_list[95];
*svp++ = (SV*)&sv_list[96];
*svp++ = (SV*)&sv_list[97];
AvFILLp(av) = 57;
}
GvAV(gv_list[59]) = (AV*)&sv_list[39];
GvHV(gv_list[59]) = (HV*)&sv_list[98];
GvFILE(gv_list[59]) = "";
gv_list[60] = gv_fetchpv("main::ENV", TRUE, SVt_PV);
SvFLAGS(gv_list[60]) = 0x600d;
GvFLAGS(gv_list[60]) = 0xa;
GvLINE(gv_list[60]) = 0;
SvPVX(gv_list[60]) = emptystring;
SvREFCNT(gv_list[60]) += 5;
GvREFCNT(gv_list[60]) += 1;
gv_list[61] = gv_fetchpv("main::_<perlio.c", TRUE, SVt_PV);
SvFLAGS(gv_list[61]) = 0x600d;
GvFLAGS(gv_list[61]) = 0x2;
GvLINE(gv_list[61]) = 0;
SvPVX(gv_list[61]) = emptystring;
SvREFCNT(gv_list[61]) += 2;
GvREFCNT(gv_list[61]) += 1;
xpv_list[69].xpv_pv = savepvn("perlio.c", 8);
GvSV(gv_list[61]) = &sv_list[99];
GvFILE(gv_list[61]) = "hello.p";
gv_list[62] = gv_fetchpv("main:::", TRUE, SVt_PV);
SvFLAGS(gv_list[62]) = 0x600d;
GvFLAGS(gv_list[62]) = 0xa;
GvLINE(gv_list[62]) = 546;
SvPVX(gv_list[62]) = emptystring;
SvREFCNT(gv_list[62]) += 4;
GvREFCNT(gv_list[62]) += 1;
gv_list[63] = gv_fetchpv("PerlIO::get_layers", TRUE, SVt_PV);
SvFLAGS(gv_list[63]) = 0x600d;
GvFLAGS(gv_list[63]) = 0x2;
GvLINE(gv_list[63]) = 0;
SvPVX(gv_list[63]) = emptystring;
SvREFCNT(gv_list[63]) += 2;
GvREFCNT(gv_list[63]) += 1;
GvSV(gv_list[63]) = &sv_list[100];
GvCV(gv_list[63]) = (CV*)((perl_get_cv("PerlIO::get_layers",TRUE)));
GvFILE(gv_list[63]) = "hello.p";
gv_list[64] = gv_fetchpv("PerlIO::Layer::NoWarnings", TRUE, SVt_PV);
SvFLAGS(gv_list[64]) = 0x600d;
GvFLAGS(gv_list[64]) = 0x2;
GvLINE(gv_list[64]) = 0;
SvPVX(gv_list[64]) = emptystring;
SvREFCNT(gv_list[64]) += 2;
GvREFCNT(gv_list[64]) += 1;
GvSV(gv_list[64]) = &sv_list[101];
GvCV(gv_list[64]) = (CV*)((perl_get_cv("PerlIO::Layer::NoWarnings",TRUE)));
GvFILE(gv_list[64]) = "hello.p";
gv_list[65] = gv_fetchpv("PerlIO::Layer::find", TRUE, SVt_PV);
SvFLAGS(gv_list[65]) = 0x600d;
GvFLAGS(gv_list[65]) = 0x2;
GvLINE(gv_list[65]) = 0;
SvPVX(gv_list[65]) = emptystring;
SvREFCNT(gv_list[65]) += 2;
GvREFCNT(gv_list[65]) += 1;
GvSV(gv_list[65]) = &sv_list[102];
GvCV(gv_list[65]) = (CV*)((perl_get_cv("PerlIO::Layer::find",TRUE)));
GvFILE(gv_list[65]) = "hello.p";
gv_list[66] = gv_fetchpv("main::0", TRUE, SVt_PV);
SvFLAGS(gv_list[66]) = 0x600d;
GvFLAGS(gv_list[66]) = 0xa;
GvLINE(gv_list[66]) = 0;
SvPVX(gv_list[66]) = emptystring;
SvREFCNT(gv_list[66]) += 5;
GvREFCNT(gv_list[66]) += 1;
gv_list[67] = gv_fetchpv("main::.", TRUE, SVt_PV);
SvFLAGS(gv_list[67]) = 0x600d;
GvFLAGS(gv_list[67]) = 0xa;
GvLINE(gv_list[67]) = 496;
SvPVX(gv_list[67]) = emptystring;
SvREFCNT(gv_list[67]) += 5;
GvREFCNT(gv_list[67]) += 1;
gv_list[68] = gv_fetchpv("main::\b", TRUE, SVt_PV);
SvFLAGS(gv_list[68]) = 0x600d;
GvFLAGS(gv_list[68]) = 0xa;
GvLINE(gv_list[68]) = 0;
SvPVX(gv_list[68]) = emptystring;
SvREFCNT(gv_list[68]) += 5;
GvREFCNT(gv_list[68]) += 1;
gv_list[69] = gv_fetchpv("main::@", TRUE, SVt_PV);
SvFLAGS(gv_list[69]) = 0x600d;
GvFLAGS(gv_list[69]) = 0xa;
GvLINE(gv_list[69]) = 0;
SvPVX(gv_list[69]) = emptystring;
SvREFCNT(gv_list[69]) += 13;
GvREFCNT(gv_list[69]) += 1;
gv_list[70] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/base.pm", TRUE, SVt_PV);
SvFLAGS(gv_list[70]) = 0x600d;
GvFLAGS(gv_list[70]) = 0x2;
GvLINE(gv_list[70]) = 8;
SvPVX(gv_list[70]) = emptystring;
SvREFCNT(gv_list[70]) += 2;
GvREFCNT(gv_list[70]) += 1;
xpv_list[70].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/base.pm", 28);
GvSV(gv_list[70]) = &sv_list[103];
GvFILE(gv_list[70]) = "\270/\r\b";
gv_list[71] = gv_fetchpv("main::STDOUT", TRUE, SVt_PV);
SvFLAGS(gv_list[71]) = 0x630d;
GvFLAGS(gv_list[71]) = 0xa;
GvLINE(gv_list[71]) = 0;
SvPVX(gv_list[71]) = emptystring;
SvREFCNT(gv_list[71]) += 13;
GvREFCNT(gv_list[71]) += 1;
gv_list[72] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/B/C.pm", TRUE, SVt_PV);
SvFLAGS(gv_list[72]) = 0x600d;
GvFLAGS(gv_list[72]) = 0x2;
GvLINE(gv_list[72]) = 1096;
SvPVX(gv_list[72]) = emptystring;
SvREFCNT(gv_list[72]) += 2;
GvREFCNT(gv_list[72]) += 1;
xpv_list[71].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/B/C.pm", 51);
GvSV(gv_list[72]) = &sv_list[104];
GvFILE(gv_list[72]) = "";
gv_list[73] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/B.pm", TRUE, SVt_PV);
SvFLAGS(gv_list[73]) = 0x600d;
GvFLAGS(gv_list[73]) = 0x2;
GvLINE(gv_list[73]) = 87;
SvPVX(gv_list[73]) = emptystring;
SvREFCNT(gv_list[73]) += 2;
GvREFCNT(gv_list[73]) += 1;
xpv_list[72].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/B.pm", 49);
GvSV(gv_list[73]) = &sv_list[105];
GvFILE(gv_list[73]) = "\210\327\a\b\b";
gv_list[74] = gv_fetchpv("main::]", TRUE, SVt_PV);
SvFLAGS(gv_list[74]) = 0x600d;
GvFLAGS(gv_list[74]) = 0xa;
GvLINE(gv_list[74]) = 41;
SvPVX(gv_list[74]) = emptystring;
SvREFCNT(gv_list[74]) += 2;
GvREFCNT(gv_list[74]) += 1;
gv_list[75] = gv_fetchpv("main::\027", TRUE, SVt_PV);
SvFLAGS(gv_list[75]) = 0x600d;
GvFLAGS(gv_list[75]) = 0xa;
GvLINE(gv_list[75]) = 227;
SvPVX(gv_list[75]) = emptystring;
SvREFCNT(gv_list[75]) += 4;
GvREFCNT(gv_list[75]) += 1;
gv_list[76] = gv_fetchpv("main::STDERR", TRUE, SVt_PV);
SvFLAGS(gv_list[76]) = 0x630d;
GvFLAGS(gv_list[76]) = 0xa;
GvLINE(gv_list[76]) = 0;
SvPVX(gv_list[76]) = emptystring;
SvREFCNT(gv_list[76]) += 4;
GvREFCNT(gv_list[76]) += 1;
gv_list[77] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/B.so", TRUE, SVt_PV);
SvFLAGS(gv_list[77]) = 0x600d;
GvFLAGS(gv_list[77]) = 0x2;
GvLINE(gv_list[77]) = 87;
SvPVX(gv_list[77]) = emptystring;
SvREFCNT(gv_list[77]) += 2;
GvREFCNT(gv_list[77]) += 1;
xpv_list[73].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/B.so", 56);
GvSV(gv_list[77]) = &sv_list[106];
GvFILE(gv_list[77]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
gv_list[78] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/Fcntl/Fcntl.so", TRUE, SVt_PV);
SvFLAGS(gv_list[78]) = 0x600d;
GvFLAGS(gv_list[78]) = 0x2;
GvLINE(gv_list[78]) = 87;
SvPVX(gv_list[78]) = emptystring;
SvREFCNT(gv_list[78]) += 2;
GvREFCNT(gv_list[78]) += 1;
xpv_list[74].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/Fcntl/Fcntl.so", 64);
GvSV(gv_list[78]) = &sv_list[107];
GvFILE(gv_list[78]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
PL_dowarn = ( 0 ) ? G_WARN_ON : G_WARN_OFF;
PL_main_root = (OP*)&listop_list[0];
PL_main_start = &op_list[0];
PL_initav = (AV *) Nullsv;
PL_endav = (AV*) Nullsv;
xpv_list[75].xpv_pv = savepvn("Hello World\n", 12);
{
SV **svp;
AV *av = (AV*)&sv_list[109];
av_extend(av, 2);
svp = AvARRAY(av);
*svp++ = (SV*)&PL_sv_undef;
*svp++ = (SV*)&sv_list[110];
*svp++ = (SV*)&sv_list[111];
AvFILLp(av) = 2;
}
PL_curpad = AvARRAY((AV*)&sv_list[109]);
GvHV(PL_incgv) = (HV*)&sv_list[98];
GvAV(PL_incgv) = (AV*)&sv_list[39];
av_store(CvPADLIST(PL_main_cv),0,SvREFCNT_inc((AV*)&sv_list[108]));
av_store(CvPADLIST(PL_main_cv),1,SvREFCNT_inc((AV*)&sv_list[109]));
PL_amagic_generation= 0;
return 0;
}
int
Tcl_IsShared(Tcl_Obj *objPtr)
{
return SvREFCNT(objPtr) > 1;
}
static void attr_destroy_trigger(SV *self_sv, SV *encap_obj, HR_Action *action_list)
{
HR_DEBUG("self_sv=%p", self_sv);
HR_DEBUG("Attr destroy hook");
HR_DEBUG("We are ATTR=%p", self_sv);
//sv_dump(self_sv);
hrattr_simple *attr = attr_from_sv(self_sv);
HR_DEBUG("hrattr=%p", attr);
HR_Table_t parent = attr_parent_tbl(attr);
HR_DEBUG("Parent=%p", parent);
SV *rlookup = NULL, *attr_lookup = NULL;
if(SvREFCNT(parent)) {
get_hashes(parent,
HR_HKEY_LOOKUP_REVERSE, &rlookup,
HR_HKEY_LOOKUP_ATTR, &attr_lookup,
HR_HKEY_LOOKUP_NULL);
HR_DEBUG("rlookup=%p, attr_lookup=%p", rlookup, attr_lookup);
} else {
HR_DEBUG("Main lookup table being destroyed?");
parent = NULL;
}
char *ktmp;
int attrsz = attr_getsize(attr);
SV *vtmp, *vhash;
I32 tmplen;
mk_ptr_string(oaddr, self_sv);
int oaddr_len = strlen(oaddr);
SV *attrhash_ref = NULL, *self_ref = NULL;
RV_Newtmp( attrhash_ref, ((SV*)attr->attrhash) );
RV_Newtmp( self_ref, self_sv );
if(action_list) {
while( (HR_nullify_action(action_list,
(SV*)&attr_destroy_trigger,
NULL,
HR_KEY_TYPE_NULL|HR_KEY_SFLAG_HASHREF_OPAQUE)
== HR_ACTION_DELETED) );
/*No body*/
} else {
HR_PL_del_action_container(self_ref, (SV*)&attr_destroy_trigger);
}
HR_DEBUG("Deleted self destroy hook");
if(attr->encap) {
hrattr_encap *aencap = (hrattr_encap*)attr;
if(aencap->obj_paddr) {
SV *encap_ref = NULL;
RV_Newtmp(encap_ref, (SV*)aencap->obj_paddr);
HR_PL_del_action_container(encap_ref,
(SV*)&encap_attr_destroy_hook);
RV_Freetmp(encap_ref);
HR_DEBUG("Deleted encap destroy hook");
}
if(aencap->obj_rv) {
SvREFCNT_dec( aencap->obj_rv );
}
}
if(attr_lookup) {
HR_DEBUG("Deleting our attr_lookup entry..");
hv_delete(REF2HASH(attr_lookup),
attr_strkey(attr, attrsz),
strlen(attr_strkey(attr, attrsz)),
G_DISCARD);
HR_DEBUG("attr_lookup entry deleted");
}
U32 old_refcount = refcnt_ka_begin(self_sv);
I32 attrvals = hv_iterinit(attr->attrhash);
HR_DEBUG("We have %d values", attrvals);
while( (vtmp = hv_iternextsv(attr->attrhash, &ktmp, &tmplen)) ) {
SV *vptr, *vref;
sscanf(ktmp, "%lu", &vptr); /*Don't ask.. also, uses slightly less memory*/
RV_Newtmp(vref, vptr);
U32 old_v_refcount = refcnt_ka_begin(vptr);
attr_delete_value_from_attrhash(self_ref, vref);
if(SvROK(vref) && parent) {
HR_DEBUG("Deleting vhash entry");
attr_delete_from_vhash(self_ref, vref);
} else {
HR_DEBUG("Eh?");
}
RV_Freetmp(vref);
refcnt_ka_end(vptr, old_v_refcount);
}
SvREFCNT_dec(attr->attrhash);
RV_Freetmp(self_ref);
RV_Freetmp(attrhash_ref);
refcnt_ka_end(self_sv, old_refcount);
HR_DEBUG("Attr destroy done");
}
PImage
IPA__Global_band_filter(PImage img,HV *profile)
{
#define METHOD "IPA::Global::band_filter"
dPROFILE;
PImage ret;
int spatial = 1, homomorph = 0, lw, failed = 0, LowPass = 0;
double MinVal = 0.0, Power = 2.0, CutOff = 20.0, Boost = 0.7;
double * data, * buffer = nil;
if ( sizeof(double) % 2) {
warn("%s:'double' is even-sized on this platform", METHOD);
return nil;
}
if ( !img || !kind_of(( Handle) img, CImage))
croak("%s: not an image passed", METHOD);
if ( pexist( spatial)) spatial = pget_i( spatial);
if ( pexist( homomorph)) homomorph = pget_i( homomorph);
if ( pexist( power)) Power = pget_f( power);
if ( pexist( cutoff)) CutOff = pget_f( cutoff);
if ( pexist( boost)) Boost = pget_f( boost);
if ( pexist( low)) LowPass = pget_i( low);
if ( homomorph && !spatial)
croak("%s:Cannot perform the homomorph equalization in the spatial domain", METHOD);
if ( LowPass && ( CutOff < 0.0000001))
croak("%s:cutoff is too small for low pass", METHOD);
if ( !spatial && (( img-> type & imCategory) != imComplexNumber))
croak("%s: not an im::DComplex image passed", METHOD);
ret = ( PImage) img-> self-> dup(( Handle) img);
if ( !ret) fail( "%s: Return image allocation failed");
++SvREFCNT( SvRV( ret-> mate));
if ( spatial) {
ret-> self-> set_type(( Handle) ret, imDComplex);
if ( ret-> type != imDComplex) {
warn("%s: Cannot convert image to im::DComplex", METHOD);
failed = 1;
goto EXIT;
}
}
data = ( double *) ret-> data;
lw = ret-> w * 2;
/* Take log of input image */
if ( homomorph) {
long i, k = ret-> w * ret-> h * 2;
MinVal = *data;
for ( i = 0; i < k; i += 2)
if ( MinVal > data[i])
MinVal = data[i];
for ( i = 0; i < k; i += 2)
data[i] = ( double) log(( double) ( 1.0 + data[i] - MinVal));
}
/* fft */
if ( spatial) {
if ( !pow2( img-> w))
croak("%s: image width is not a power of 2", METHOD);
if ( !pow2( img-> h))
croak("%s: image height is not a power of 2", METHOD);
buffer = malloc((sizeof(double) * ret-> w * 2));
if ( !buffer) {
warn("%s: Error allocating %d bytes", METHOD, (int)(sizeof(double) * img-> w * 2));
failed = 1;
goto EXIT;
}
fft_2d( data, ret-> w, ret-> h, FFT_DIRECT, buffer);
}
butterworth( data, ret-> w, ret-> h, homomorph, LowPass, Power, CutOff, Boost);
/* inverse fft */
if ( spatial) {
fft_2d( data, ret-> w, ret-> h, FFT_INVERSE, buffer);
free( buffer);
buffer = nil;
}
/* Take exp of input image */
if ( homomorph) {
long i, k = ret-> w * ret-> h * 2;
for ( i = 0; i < k; i += 2)
data[i] = ( double) ( exp( data[i]) - 1.0 + MinVal);
}
/* converting type back */
if ( spatial && ret-> self-> get_preserveType(( Handle) ret))
ret-> self-> set_type(( Handle) ret, img-> type);
EXIT:
free( buffer);
if ( ret)
--SvREFCNT( SvRV( ret-> mate));
return failed ? nil : ret;
#undef METHOD
}
