Affix
view release on metacpan or search on metacpan
builder/Affix.pm view on Meta::CPAN
#print $dest->child($filename) . " is up to date\n";
my $extract = $dest->child('extract');
my $output = $dest->child('output');
my $ret = unzip( $filename, $extract );
warn $ret;
my $pre = Path::Tiny->cwd->child( qw[blib arch auto], $opt{meta}->name )->absolute;
#$pre->mkpath;
for my $sub (qw[lib include]) {
for my $kid ( $ret->child($sub)->children ) {
$pre->child( $sub, $kid->basename )->parent->mkpath;
$kid->copy( $pre->child( $sub, $kid->basename ) );
}
}
}
else {
die sprintf 'Failed to download %s: %s!', $response->{url}, $response->{content}
unless $response->{success};
}
}
else { # Build from source on all other platforms
builder/Affix.pm view on Meta::CPAN
my $header = $u->getHeaderInfo();
#ddx $header;
my $destfile = $dest->child( $header->{Name} );
next if $header->{Name} =~ m[/$]; # Directory
next if $destfile->is_dir;
next
if $destfile->is_file &&
stat( $destfile->absolute->stringify )->mtime < $header->{Time};
warn $destfile;
$destfile->parent->mkpath;
my $raw = '';
while ( ( $status = $u->read( my $buff ) ) > 0 ) { $raw .= $buff }
$destfile->spew_raw($raw);
$destfile->touch;
$retval = $destfile->parent if $destfile =~ 'build.log';
}
return $retval;
}
1;
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
# them. I use the same boilerplate as the starting point for all
# and just copy it with different configurations. This was what the
# separate ADD_LATEX_DOCUMENT method was supposed to originally be for.
# Since its external use is pretty much deprecated, I removed that
# documentation.
#
# 1.4.1 Copy .sty files along with the other class and package files.
#
# 1.4.0 Added a MANGLE_TARGET_NAMES option that will mangle the target names.
#
# Fixed problem with copying bib files that became apparent with
# CMake 2.4.
#
# 1.3.0 Added a LATEX_OUTPUT_PATH variable that allows you or the user to
# specify where the built latex documents to go. This is especially
# handy if you want to do in-source builds.
#
# Removed the ADD_LATEX_IMAGES macro and absorbed the functionality
# into ADD_LATEX_DOCUMENT. The old interface was always kind of
# clunky anyway since you had to specify the image directory in both
# places. It also made supporting LATEX_OUTPUT_PATH problematic.
dyncall/doc/disas_examples/arm.darwin_thumb.disas view on Meta::CPAN
14: 05 91 str r1, [sp, #20]
16: 04 92 str r2, [sp, #16]
18: 03 93 str r3, [sp, #12]
1a: cd f8 08 e0 str.w lr, [sp, #8]
1e: cd f8 04 c0 str.w r12, [sp, #4]
22: cd f8 00 90 str.w r9, [sp]
26: 07 b0 add sp, #28
28: 80 bd pop {r7, pc}
_nonleaf_call:
2a: 83 b0 sub sp, #12 ; | space for spill area (b/c pushing was apparently too easy)
2c: 80 b5 push {r7, lr} ; |
2e: 6f 46 mov r7, sp ; |
30: 8d b0 sub sp, #52 ; | prolog
32: 3b 61 str r3, [r7, #16] ; | |
34: fa 60 str r2, [r7, #12] ; | | spill (before reg save area)
36: b9 60 str r1, [r7, #8] ; | |
38: 4c 21 movs r1, #76
3a: 0b aa add r2, sp, #44
3c: 0c 90 str r0, [sp, #48]
3e: 07 f1 08 00 add.w r0, r7, #8
dyncall/doc/disas_examples/ppc.darwin.disas view on Meta::CPAN
40: 94 21 ff b0 stwu 1, -80(1) ; | open frame and store sp at top of stack
44: 7c 3e 0b 78 mr 30, 1 ; / sp -> gpr30, latter used for some fixed addressing below
48: 90 7e 00 68 stw 3, 104(30) ; \
4c: 90 9e 00 6c stw 4, 108(30) ; |
50: 90 be 00 70 stw 5, 112(30) ; |
54: 90 de 00 74 stw 6, 116(30) ; |
58: 90 fe 00 78 stw 7, 120(30) ; | all in args -> spill area in prev frame
5c: 91 1e 00 7c stw 8, 124(30) ; |
60: 91 3e 00 80 stw 9, 128(30) ; |
64: 91 5e 00 84 stw 10, 132(30) ; |
68: 80 01 00 00 lwz 0, 0(1) ; fetch back-chain ptr (parent frame's sp) from stack of top by prolog -> gpr0, and ...
6c: 94 01 ff 10 stwu 0, -240(1) ; ... update it further up the stack for alloca(220) - with padding to guarantee alignment
70: 38 41 00 40 addi 2, 1, 64 ; |
74: 38 02 00 0f addi 0, 2, 15 ; | start of alloca()'d memory -> gpr2, by ...
78: 54 00 e1 3e srwi 0, 0, 4 ; | ... using gpr0 as helper to align to 16b, leaving at least 64b at top of stack
7c: 54 02 20 36 slwi 2, 0, 4 ; |
80: 38 00 00 4c li 0, 76 ; 'L' -> gpr0, and ...
84: 98 02 00 00 stb 0, 0(2) ; ... store in local area (of alloca()'d space)
88: 80 7e 00 6c lwz 3, 108(30) ; |
8c: 80 9e 00 70 lwz 4, 112(30) ; |
90: 80 be 00 74 lwz 5, 116(30) ; |
dyncall/doc/disas_examples/ppc.darwin.disas view on Meta::CPAN
44: 94 21 ff a0 stwu 1, -96(1) ; |
48: 7c 3e 0b 78 mr 30, 1 ; /
4c: 90 7e 00 78 stw 3, 120(30) ; \
50: 90 9e 00 7c stw 4, 124(30) ; |
54: 90 be 00 80 stw 5, 128(30) ; |
58: 90 de 00 84 stw 6, 132(30) ; |
5c: 90 fe 00 88 stw 7, 136(30) ; | in args 0,1,2,3,4,5,6,7 -> spill area in prev frame
60: 91 1e 00 8c stw 8, 140(30) ; |
64: 91 3e 00 90 stw 9, 144(30) ; |
68: 91 5e 00 94 stw 10, 148(30) ; |
6c: 80 01 00 00 lwz 0, 0(1) ; fetch back-chain ptr (parent frame's sp) from stack of top by prolog -> gpr0, and ...
70: 94 01 ff 10 stwu 0, -240(1) ; ... update it further up the stack for alloca(220) - with padding to guarantee alignment
74: 38 41 00 50 addi 2, 1, 80 ; |
78: 38 02 00 0f addi 0, 2, 15 ; | start of alloca()'d memory -> gpr2, by ...
7c: 54 00 e1 3e srwi 0, 0, 4 ; | ... using gpr0 as helper to align to 16b, leaving at least 64b at top of stack
80: 54 02 20 36 slwi 2, 0, 4 ; |
84: 38 00 00 4c li 0, 76 ; 'L' -> gpr0, and ...
88: 98 02 00 00 stb 0, 0(2) ; ... store in local area (of alloca()'d space)
8c: 80 1e 00 9c lwz 0, 156(30) ; arg 7 (fetched from stack param area from prev frame), and ...
90: 90 01 00 38 stw 0, 56(1) ; ... "pushed" onto stack
94: 80 7e 00 7c lwz 3, 124(30) ; |
dyncall/doc/disas_examples/ppc.darwin.disas view on Meta::CPAN
134: 90 1e 00 74 stw 0, 116(30) ; | in arg 8
138: 80 09 00 00 lwz 0, 0(9) ; |
13c: 90 1e 00 64 stw 0, 100(30) ; /
140: 81 3e 00 74 lwz 9, 116(30) ; \
144: 80 5e 00 74 lwz 2, 116(30) ; |
148: 38 02 00 08 addi 0, 2, 8 ; |
14c: 90 1e 00 74 stw 0, 116(30) ; | in arg 9 (float, promoted to double)
150: c8 09 00 00 lfd 0, 0(9) ; |
154: fc 00 00 18 frsp 0, 0 ; |
158: d0 1e 00 70 stfs 0, 112(30) ; /
15c: 80 01 00 00 lwz 0, 0(1) ; fetch back-chain ptr (parent frame's sp) from stack of top by prolog -> gpr0, and ...
160: 94 01 ff 10 stwu 0, -240(1) ; ... update it further up the stack for alloca
164: 38 41 00 50 addi 2, 1, 80 ; |
168: 38 02 00 0f addi 0, 2, 15 ; | start of alloca()'d memory -> gpr2, by ...
16c: 54 00 e1 3e srwi 0, 0, 4 ; | ... using gpr0 as helper to align to 16b, l
170: 54 02 20 36 slwi 2, 0, 4 ; |
174: 38 00 00 4c li 0, 76 ; 'L' -> gpr0, and ...
178: 98 02 00 00 stb 0, 0(2) ; ... store in local area (of alloca()'d space)
17c: 80 7e 00 50 lwz 3, 80(30) ; arg 0
180: 80 9e 00 54 lwz 4, 84(30) ; arg 1
184: 80 be 00 58 lwz 5, 88(30) ; arg 2
dyncall/doc/disas_examples/ppc64.elfabi.disas view on Meta::CPAN
60: 7c 60 1b 78 mr r0,r3 ; in arg 0 -> gpr0
64: 7c 8b 23 78 mr r11,r4 ; in arg 1 -> gpr11
68: 90 1f 00 c0 stw r0,192(r31) ; |
6c: 91 7f 00 c8 stw r11,200(r31) ; |
70: 90 bf 00 d0 stw r5,208(r31) ; |
74: 90 df 00 d8 stw r6,216(r31) ; |
78: 90 ff 00 e0 stw r7,224(r31) ; | all in args -> spill area in prev frame (jump over own frame (144) + linkage area of prev frame (48) = 192)
7c: 91 1f 00 e8 stw r8,232(r31) ; |
80: 91 3f 00 f0 stw r9,240(r31) ; |
84: 91 5f 00 f8 stw r10,248(r31) ; |
88: e8 01 00 00 ld r0,0(r1) ; fetch back-chain ptr (parent frame's sp) from stack of top by prolog -> gpr0, and ...
8c: f8 01 ff 11 stdu r0,-240(r1) ; ... update it further up the stack for alloca(220) - with padding to guarantee alignment
90: 39 21 00 70 addi r9,r1,112 ; |
94: f9 3f 00 70 std r9,112(r31) ; |
98: e9 3f 00 70 ld r9,112(r31) ; |
9c: 38 09 00 0f addi r0,r9,15 ; | start of alloca()'d memory -> gpr9, by ...
a0: 78 00 e1 02 rldicl r0,r0,60,4 ; | ... using gpr0 as helper to align to 16b, leaving at least 112b at top of stack
a4: 78 00 26 e4 rldicr r0,r0,4,59 ; |
a8: f8 1f 00 70 std r0,112(r31) ; |
ac: e9 3f 00 70 ld r9,112(r31) ; |
b0: 38 00 00 4c li r0,76 ; 'L' -> gpr0, and ...
dyncall/doc/manual/callconvs/callconv_ppc32.tex view on Meta::CPAN
& 9th word of arg data & & \\
& gpr10 & \mrrbrace{3}{spill area (as needed)} & \\
& \ldots & & \\
& gpr3 & & \\
\hhline{~-~~}
\mrlbrace{6}{linkage area} & reserved & & \\
& reserved & & \\
& reserved & & \\
& return address (callee saved) & & \\
& condition reg (callee saved) & & \\
& parent stack frame pointer & & \\
\hhline{~=~~}
register save area & & & \mrrbrace{4}{current frame} \\
\hhline{~-~~}
local data & & & \\
\hhline{~-~~}
parameter area & & & \\
\hhline{~-~~}
linkage area & \vdots & & \\
\end{tabular}
\caption{Stack layout on ppc32 Darwin}
dyncall/doc/manual/callconvs/callconv_ppc32.tex view on Meta::CPAN
register save area & \hspace{4cm} & & \mrrbrace{7}{caller's frame} \\
\hhline{~-~~}
local data & & & \\
\hhline{~-~~}
\mrlbrace{3}{parameter area} & last arg & \mrrbrace{3}{stack parameters} & \\
& \ldots & & \\
& first arg passed via stack & & \\
\hhline{~-~~}
& return address (callee saved) & & \\
\hhline{~-~~}
& parent stack frame pointer & & \\
\hhline{~=~~}
register save area & & & \mrrbrace{4}{current frame} \\
\hhline{~-~~}
local data & & & \\
\hhline{~-~~}
parameter area & & & \\
\hhline{~-~~}
& \vdots & & \\
\end{tabular}
\caption{Stack layout on System V ABI for PowerPC 32-bit calling convention}
dyncall/doc/manual/callconvs/callconv_ppc64.tex view on Meta::CPAN
& arg 8 & & \\
& gpr10 & \mrrbrace{3}{spill area (as needed)} & \\
& \ldots & & \\
& gpr3 & & \\
\hhline{~-~~}
\mrlbrace{6}{linkage area} & TOC ptr reg & & \\
& reserved & & \\
& reserved & & \\
& return address (callee saved) & & \\
& condition reg (callee saved) & & \\
& parent stack frame pointer & & \\
\hhline{~=~~}
register save area & & & \mrrbrace{4}{current frame} \\
\hhline{~-~~}
local data & & & \\
\hhline{~-~~}
parameter area & & & \\
\hhline{~-~~}
linkage area & \vdots & & \\
\end{tabular}
\caption{Stack layout on ppc64 ELF ABI}
dyncall/dyncall/dyncall_call_ppc32.S view on Meta::CPAN
Details:
- Stack frames are always aligned on 16 byte
- Reserve GPR2 (System register)
- The GPR3 .. GPR10 are loaded
- The FPR1 .. FPR8 are loaded
- No support for Vector Parameters so far.
Frame structure:
on entry, parent frame layout:
offset
4: LR save word (Callee stores LR in parent frame)
0: parent stack frame (back-chain)
after frame initialization:
stack size = ( (8+15) + stacksize ) & -(16)
... locals and register spills
8: parameter list area
4: LR save word (Callee stores LR in parent frame)
0: parent stack frame (back-chain)
*/
.align 2
GLOBAL_C(dcCall_ppc32_sysv)
ENTRY_C(dcCall_ppc32_sysv)
mflr r0 /* r0 = return address */
stw r0,4(r1) /* store r0 to link-area */
/* compute aligned stack-size */
dyncall/dyncall/dyncall_call_ppc64.S view on Meta::CPAN
- Stack frames are always aligned on 16 byte
- Reserve GPR2 (System register)
- The GPR3 .. GPR10 are loaded
- The FPR1 .. FPR8 are loaded
- No support for Vector Parameters so far.
- Parameter Area (min. v1:64 Bytes v2:0 Byte)
- Frame Header Area (v1:48 Bytes v2:32 Bytes)
Frame structure:
on entry, parent frame layout:
offset
16: LR save word (Callee stores LR in parent frame)
0: parent stack frame (back-chain)
after frame initialization:
v1: stack size = ( (48+64+8+15) + stacksize ) & -(16)
v2: stack size = ( (32+0+8+15) + stacksize ) & -(16)
... locals and register spills
48 or 32: parameter list area
16: LR save word (Callee stores LR in parent frame)
0: parent stack frame (back-chain)
*/
/* Constants */
#if DC__ABI_PPC64_ELF_V != 2
STACK_MIN = 120 /* v1 */
TOC_SAVE = 40
PARAM_SAVE = 48
#else
STACK_MIN = 40 /* v2 */
TOC_SAVE = 24
dyncall/dyncallback/dyncall_callback_sparc32.s view on Meta::CPAN
.globl dcCallbackThunkEntry
/* Called by thunk - thunk stores pointer to DCCallback */
/* in %g1, and pointer to called function in %g2 */
dcCallbackThunkEntry:
/* Prolog. */
/* Frame size of 104b comes from needing storage space for the following: */
/* req_reg_save_area:64 + spill:24 + dcargs:4 + retval:8 + pad:4 */
/* Spill area could theoretically be only 16b, b/c cbHandler function has */
/* 4 arguments, but let's be conservative. */ /* cbHandler function might decide to spill (6x4b) @@@ testcode, or rely on 8byte return space in parent stack */
save %sp, -104, %sp
/* Spill register args as dcargs is based on that (in prev frame, after */
/* req_reg_save_area and struct_ret_ptr). */
add %fp, 68, %l0
st %i0, [ %l0 + 0 ] /* reg arg 0 */
st %i1, [ %l0 + 4 ] /* reg arg 1 */
st %i2, [ %l0 + 8 ] /* reg arg 2 */
st %i3, [ %l0 + 12 ] /* reg arg 3 */
st %i4, [ %l0 + 16 ] /* reg arg 4 */
dyncall/dyncallback/dyncall_callback_x64.S view on Meta::CPAN
SET(DCArgs_size_win64,96) /* 8 (stack_ptr) + 4 (reg_count) + 4 (pad_w) + 4 (aggr_return_register) + 4 (pad) + 8*4 (int regs) + 8 (aggrs) + 8*4 (float regs) */
SET(DCArgs_size_sysv,144) /* 8 (stack_ptr) + 8 (reg_count) + 4 (aggr_return_register) + 4 (pad) + 8*6 (int regs) + 8 (aggrs) + 8*8 (float regs) */
SET(DCValue_size,8)
SET(DCRetRegs_SystemV_size,32)
/* frame local variable offsets relative to %rbp */
SET(FRAME_arg0_win64,48)
SET(FRAME_arg0_sysv,16)
SET(FRAME_return,8)
SET(FRAME_parent,0)
/* struct DCCallback layout, relative to ptr passed to functions below via RAX */
SET(CTX_thunk,0)
SET(CTX_handler,24)
SET(CTX_userdata,32)
SET(CTX_aggr_ret_reg,40)
SET(CTX_pad,44)
SET(CTX_aggrs_pp,48)
SET(DCCallback_size,56)
dyncall/dyncallback/dyncall_callback_x64_masm.asm view on Meta::CPAN
; auto-generated by gen-masm.sh
.CODE
DCThunk_size = 24
DCArgs_size_win64 = 96
DCArgs_size_sysv = 144
DCValue_size = 8
DCRetRegs_SystemV_size = 32
FRAME_arg0_win64 = 48
FRAME_arg0_sysv = 16
FRAME_return = 8
FRAME_parent = 0
CTX_thunk = 0
CTX_handler = 24
CTX_userdata = 32
CTX_aggr_ret_reg = 40
CTX_pad = 44
CTX_aggrs_pp = 48
DCCallback_size = 56
dcCallback_x64_sysv PROC
OPTION PROLOGUE:NONE, EPILOGUE:NONE
push RBP
dyncall/dyncallback/dyncall_callback_x86.S view on Meta::CPAN
DCValue_size = 8
CTX_thunk = 0
CTX_phandler = 16
CTX_pargsvt = 20
CTX_stack_cleanup = 24
CTX_userdata = 28
frame_arg0 = 8
frame_ret = 4
frame_parent = 0
frame_CTX = -4
frame_DCArgs = -24
frame_DCValue = -32
#define ASCII_L 76
#define ASCII_l 108
#define ASCII_d 100
#define ASCII_f 102
#define ASCII_i 105
#define ASCII_v 118
dyncall/dyncallback/dyncall_callback_x86.S view on Meta::CPAN
MOVL(ESP,EDX) /* EDX = DCValue* */
ANDL(LIT(-16),ESP) /* align stack to 16 bytes. */
/* call handler(context) */
PUSH(DWORD(EAX,CTX_userdata)) /* userdata */
PUSH(EDX) /* DCValue* */
PUSH(ECX) /* DCargs* */
PUSH(EAX) /* DCCallback* */
CALL_DWORD(EAX,CTX_phandler)
/* cleanup stack */
MOVL(EBP,ESP) /* reset esp to frame */
POP(ECX) /* skip parent frame */
POP(ECX) /* pop return address */
MOVL(DWORD(EBP,frame_CTX),EDX)
ADD(DWORD(EDX,CTX_stack_cleanup),ESP) /* cleanup stack */
PUSH(ECX) /* push back return address */
LEA(DWORD(EBP,frame_DCValue), EDX)
MOVL(DWORD(EBP,0), EBP) /* EBP = parent frame */
/* handle return value */
#if !defined(DC__OS_Minix)
CMP(LIT(ASCII_f),AL)
JE(LOCAL(return_f32))
CMP(LIT(ASCII_d),AL)
JE(LOCAL(return_f64))
#endif
/* All int cases (+ pointer & string cases) fall in the return_i64 case, here */
dyncall/dyncallback/dyncall_callback_x86_masm.asm view on Meta::CPAN
DCThunk_size = 16
DCArgs_size = 20
DCValue_size = 8
CTX_thunk = 0
CTX_phandler = 16
CTX_pargsvt = 20
CTX_stack_cleanup = 24
CTX_userdata = 28
frame_arg0 = 8
frame_ret = 4
frame_parent = 0
frame_CTX = -4
frame_DCArgs = -24
frame_DCValue = -32
_dcCallbackThunkEntry PROC
OPTION PROLOGUE:NONE, EPILOGUE:NONE
push EBP
mov EBP,ESP
push EAX
push 0
push EDX
dyncall/test/call_suite_aggrs/mk-cases.lua view on Meta::CPAN
require"config"
-- use shared helpers to generate cases
package.path = '../common/?.lua;' .. package.path
require"mk-cases"
-- returns: generated case str, num args; accumulates unique idx => aggr-sig in
-- aggrs (sequentially) and aggr-sig => {body,name} in seen_aggrs (depth first
-- for nested aggrs, so sub-aggrs conveniently precede parents)
function mkcase(id, sig, aggrs, seen_aggrs)
local sig = trim(sig)
local fsig = put_sig_rtype_first(sig)
local h = { "/* ",id,":",sig," */ " }
local t = { }
local pos = -1
local n_nest = 0
local aggr = { }
local aggr_sig = { }
aggr[0] = { } -- non-sequential [0] collects all non-aggr types (not used, though)
dyncall/test/callback_suite_aggrs/mk-cases.lua view on Meta::CPAN
require "config"
-- use shared helpers to generate cases
package.path = '../common/?.lua;' .. package.path
require"mk-cases"
-- returns: generated case str, num args; accumulates unique idx => aggr-sig in
-- aggrs (sequentially) and aggr-sig => {body,name} in seen_aggrs (depth first
-- for nested aggrs, so sub-aggrs conveniently precede parents)
function mkcase(id, sig, aggrs, seen_aggrs)
local sig = trim(sig)
local fsig = put_sig_rtype_first(sig)
local h = { "/* ",id,":",sig," */ " }
local t = { }
local pos = -1
local n_nest = 0
local aggr = { }
local aggr_sig = { }
aggr[0] = { } -- non-sequential [0] collects all non-aggr types (not used, though)
lib/Affix.pm view on Meta::CPAN
use Sub::Util qw[subname];
use Text::ParseWords;
use Carp qw[];
use vars qw[@EXPORT_OK @EXPORT %EXPORT_TAGS];
use XSLoader;
#~ our $VMSize = 2; # defaults to 4096; passed to dcNewCallVM( ... )
my $ok = XSLoader::load();
END { _shutdown() if $ok; }
#
use parent 'Exporter';
@EXPORT_OK = sort map { @$_ = sort @$_; @$_ } values %EXPORT_TAGS;
$EXPORT_TAGS{'all'} = \@EXPORT_OK; # When you want to import everything
#@{ $EXPORT_TAGS{'enum'} } # Merge these under a single tag
# = sort map { defined $EXPORT_TAGS{$_} ? @{ $EXPORT_TAGS{$_} } : () }
# qw[types?]
# if 1 < scalar keys %EXPORT_TAGS;
@EXPORT # Export these tags (if prepended w/ ':') or functions by default
= sort map { m[^:(.+)] ? @{ $EXPORT_TAGS{$1} } : $_ } qw[:default :types]
if keys %EXPORT_TAGS > 1;
lib/Affix.xs view on Meta::CPAN
/* Returns the amount of padding needed after `offset` to ensure that the
following address will be aligned to `alignment`. */
size_t padding_needed_for(size_t offset, size_t alignment) {
if (alignment == 0) return 0;
size_t misalignment = offset % alignment;
if (misalignment) // round to the next multiple of alignment
return alignment - misalignment;
return 0; // already a multiple of alignment*/
}
void set_isa(const char *klass, const char *parent) {
dTHX;
HV *parent_stash = gv_stashpv(parent, GV_ADD | GV_ADDMULTI);
av_push(get_av(form("%s::ISA", klass), TRUE), newSVpv(parent, 0));
// TODO: make this spider up the list and make deeper connections?
}
void register_constant(const char *package, const char *name, SV *value) {
dTHX;
HV *_stash = gv_stashpv(package, TRUE);
newCONSTSUB(_stash, (char *)name, value);
}
void export_function__(HV *_export, const char *what, const char *_tag) {
( run in 0.342 second using v1.01-cache-2.11-cpan-4d50c553e7e )