Result:
found more than 616 distributions - search limited to the first 2001 files matching your query
( run in 0.775 )
Alien-libsdl2
view release on metacpan or search on metacpan
SDL_version compiled;
SDL_VERSION(&compiled);
printf("# [TA_MODULE] We compiled against SDL version %d.%d.%d ...\n",
compiled.major, compiled.minor, compiled.patch);
RETVAL = compiled.major;
OUTPUT:
RETVAL
Alien-libsecp256k1
view release on metacpan or search on metacpan
libsecp256k1/CMakeLists.txt view on Meta::CPAN
# guarantee that the flags appear at the end of the command line.
string(APPEND CMAKE_C_CREATE_SHARED_LIBRARY " ${SECP256K1_APPEND_LDFLAGS}")
string(APPEND CMAKE_C_LINK_EXECUTABLE " ${SECP256K1_APPEND_LDFLAGS}")
endif()
if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
endif()
if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
endif()
if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
endif()
add_subdirectory(src)
if(SECP256K1_BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
Alien-libuuid
view release on metacpan or search on metacpan
t/alien_libuuid.t view on Meta::CPAN
void
uuid_generate_random()
CODE:
uuid_t out;
uuid_generate_random(out);
OUTPUT:
EOF
xs_ok $xs, with_subtest {
libuuid::uuid_generate_random();
t/alien_libuuid.t view on Meta::CPAN
void
uuid_generate_random()
CODE:
uuid_t out;
uuid_generate_random(out);
OUTPUT:
EOF
xs_ok $xs, with_subtest {
libuuid::uuid_generate_random();
Alien-m4
view release on metacpan or search on metacpan
patch/01-fix-ftbfs-with-glibc-2.28.patch view on Meta::CPAN
<stdio.h>, because they need it for implementing getc() and putc() as
fast macros. */
-# if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */
+# if defined _IO_EOF_SEEN || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */
return ((fp->_flags & _IO_NO_WRITES) != 0
|| ((fp->_flags & (_IO_NO_READS | _IO_CURRENTLY_PUTTING)) == 0
&& fp->_IO_read_base != NULL));
--- a/lib/fseeko.c
+++ b/lib/fseeko.c
@@ -47,7 +47,7 @@
#endif
Alien-pkgconf
view release on metacpan or search on metacpan
patch/pkgconf-solaris-1.3.9.diff view on Meta::CPAN
+# https://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+# AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS], [INPUT])
+#
+# DESCRIPTION
+#
+# Check whether the given FLAG works with the current language's compiler
+# or gives an error. (Warnings, however, are ignored)
patch/pkgconf-solaris-1.3.9.diff view on Meta::CPAN
+# If EXTRA-FLAGS is defined, it is added to the current language's default
+# flags (e.g. CFLAGS) when the check is done. The check is thus made with
+# the flags: "CFLAGS EXTRA-FLAGS FLAG". This can for example be used to
+# force the compiler to issue an error when a bad flag is given.
+#
+# INPUT gives an alternative input source to AC_COMPILE_IFELSE.
+#
+# NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
+# macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG.
+#
+# LICENSE
Alien-uv
view release on metacpan or search on metacpan
libuv/configure.ac view on Meta::CPAN
])
AC_CHECK_HEADERS([sys/ahafs_evProds.h])
AC_CONFIG_FILES([Makefile libuv.pc])
AC_CONFIG_LINKS([test/fixtures/empty_file:test/fixtures/empty_file])
AC_CONFIG_LINKS([test/fixtures/load_error.node:test/fixtures/load_error.node])
AC_OUTPUT
AlignDB-IntSpanXS
view release on metacpan or search on metacpan
PUSHmortal|5.009002||p
PUSHn|||
PUSHp|||
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
PerlIO_clearerr||5.007003|
PerlIO_close||5.007003|
PerlIO_context_layers||5.009004|
PerlIO_eof||5.007003|
PerlIO_error||5.007003|
eval_sv(sv, G_SCALAR);
SvREFCNT_dec(sv);
SPAGAIN;
sv = POPs;
PUTBACK;
if (croak_on_error && SvTRUE(GvSV(errgv)))
croak(SvPVx(GvSV(errgv), na));
return sv;
Alt-Acme-Math-XS-CPP
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
my $junk = "";
my $current = \$junk;
while (<TYPEMAP>) {
next if /^\s*\#/;
my $line_no = $. + 1;
if (/^INPUT\s*$/) {$mode = 'Input'; $current = \$junk; next}
if (/^OUTPUT\s*$/) {$mode = 'Output'; $current = \$junk; next}
if (/^TYPEMAP\s*$/) {$mode = 'Typemap'; $current = \$junk; next}
if ($mode eq 'Typemap') {
chomp;
my $line = $_;
TrimWhitespace($_);
inc/Inline/C.pm view on Meta::CPAN
I32* temp;
CODE:
temp = PL_markstack_ptr++;
RETVAL = $function($arg_name_list);
PL_markstack_ptr = temp;
OUTPUT:
RETVAL
END
}
}
$XS .= "\n";
inc/Inline/C.pm view on Meta::CPAN
#define Inline_Stack_Vars dXSARGS
#define Inline_Stack_Items items
#define Inline_Stack_Item(x) ST(x)
#define Inline_Stack_Reset sp = mark
#define Inline_Stack_Push(x) XPUSHs(x)
#define Inline_Stack_Done PUTBACK
#define Inline_Stack_Return(x) XSRETURN(x)
#define Inline_Stack_Void XSRETURN(0)
#define INLINE_STACK_VARS Inline_Stack_Vars
#define INLINE_STACK_ITEMS Inline_Stack_Items
inc/Inline/C.pm view on Meta::CPAN
sub build_error_message {
my ($o, $cmd, $output_file, $build_noisy) = @_;
my $build_dir = $o->{API}{build_dir};
my $output = '';
if (not $build_noisy and
open(OUTPUT, $output_file)
) {
local $/;
$output = <OUTPUT>;
close OUTPUT;
}
my $errcode = $? >> 8;
$output .= <<END;
Alt-Acme-Math-XS-ModuleBuild
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
my $junk = "";
my $current = \$junk;
while (<TYPEMAP>) {
next if /^\s*\#/;
my $line_no = $. + 1;
if (/^INPUT\s*$/) {$mode = 'Input'; $current = \$junk; next}
if (/^OUTPUT\s*$/) {$mode = 'Output'; $current = \$junk; next}
if (/^TYPEMAP\s*$/) {$mode = 'Typemap'; $current = \$junk; next}
if ($mode eq 'Typemap') {
chomp;
my $line = $_;
TrimWhitespace($_);
inc/Inline/C.pm view on Meta::CPAN
I32* temp;
CODE:
temp = PL_markstack_ptr++;
RETVAL = $function($arg_name_list);
PL_markstack_ptr = temp;
OUTPUT:
RETVAL
END
}
}
$XS .= "\n";
inc/Inline/C.pm view on Meta::CPAN
#define Inline_Stack_Vars dXSARGS
#define Inline_Stack_Items items
#define Inline_Stack_Item(x) ST(x)
#define Inline_Stack_Reset sp = mark
#define Inline_Stack_Push(x) XPUSHs(x)
#define Inline_Stack_Done PUTBACK
#define Inline_Stack_Return(x) XSRETURN(x)
#define Inline_Stack_Void XSRETURN(0)
#define INLINE_STACK_VARS Inline_Stack_Vars
#define INLINE_STACK_ITEMS Inline_Stack_Items
inc/Inline/C.pm view on Meta::CPAN
sub build_error_message {
my ($o, $cmd, $output_file, $build_noisy) = @_;
my $build_dir = $o->{API}{build_dir};
my $output = '';
if (not $build_noisy and
open(OUTPUT, $output_file)
) {
local $/;
$output = <OUTPUT>;
close OUTPUT;
}
my $errcode = $? >> 8;
$output .= <<END;
Alt-Acme-Math-XS-ModuleInstall
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
my $junk = "";
my $current = \$junk;
while (<TYPEMAP>) {
next if /^\s*\#/;
my $line_no = $. + 1;
if (/^INPUT\s*$/) {$mode = 'Input'; $current = \$junk; next}
if (/^OUTPUT\s*$/) {$mode = 'Output'; $current = \$junk; next}
if (/^TYPEMAP\s*$/) {$mode = 'Typemap'; $current = \$junk; next}
if ($mode eq 'Typemap') {
chomp;
my $line = $_;
TrimWhitespace($_);
inc/Inline/C.pm view on Meta::CPAN
I32* temp;
CODE:
temp = PL_markstack_ptr++;
RETVAL = $function($arg_name_list);
PL_markstack_ptr = temp;
OUTPUT:
RETVAL
END
}
}
$XS .= "\n";
inc/Inline/C.pm view on Meta::CPAN
#define Inline_Stack_Vars dXSARGS
#define Inline_Stack_Items items
#define Inline_Stack_Item(x) ST(x)
#define Inline_Stack_Reset sp = mark
#define Inline_Stack_Push(x) XPUSHs(x)
#define Inline_Stack_Done PUTBACK
#define Inline_Stack_Return(x) XSRETURN(x)
#define Inline_Stack_Void XSRETURN(0)
#define INLINE_STACK_VARS Inline_Stack_Vars
#define INLINE_STACK_ITEMS Inline_Stack_Items
inc/Inline/C.pm view on Meta::CPAN
sub build_error_message {
my ($o, $cmd, $output_file, $build_noisy) = @_;
my $build_dir = $o->{API}{build_dir};
my $output = '';
if (not $build_noisy and
open(OUTPUT, $output_file)
) {
local $/;
$output = <OUTPUT>;
close OUTPUT;
}
my $errcode = $? >> 8;
$output .= <<END;
Alt-Alien-FFI-System
view release on metacpan or search on metacpan
int
test2(input_value);
unsigned char input_value;
CODE:
RETVAL = test2(input_value);
OUTPUT:
RETVAL
Alt-CWB-CL-ambs
view release on metacpan or search on metacpan
PosAttrib T_PTROBJ_CL
StrucAttrib T_PTROBJ_CL
AlignAttrib T_PTROBJ_CL
#############################################################################
INPUT
T_PTROBJ_CL
if (sv_derived_from($arg, \"CWB::CL::${ntype}\")) {
IV tmp = SvIV((SV*)SvRV($arg));
$var = INT2PTR($type,tmp);
}
else {
Perl_croak(aTHX_ \"$var is not of type CWB::CL::${ntype}\");
}
#############################################################################
OUTPUT
T_PTROBJ_CL
sv_setref_pv($arg, \"CWB::CL::${ntype}\", (void*)$var);
Alt-CWB-ambs
view release on metacpan or search on metacpan
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
sub new {
my $class = shift;
my $self = {
'PARAM_DEFAULTS' => {}, # globally set default values for parameters
'PARAM' => undef, # working copies of parameters during parse
'INPUT' => undef, # input string (defined while parsing)
'ERROR' => undef, # error message generated by last parse (undef = no error)
'CALLSTACK' => [], # call stack for backtrace in case of error
'GROUPS' => undef, # group structure for shift-reduce parser (undef if not active)
'GROUPSTACK' => undef, # stack of nested bracketing groups (undef if not active)
};
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
croak 'Usage: $result = $grammar->Parse($string [, $rule]);'
unless @_ == 2 or @_ == 3;
my ($self, $input, $rule) = @_;
$rule = "default"
unless defined $rule;
confess "CWB::CEQL::Parser: Parse() method is not re-entrant\n(tried to parse '$input' while parsing '".$self->{INPUT}."')"
if defined $self->{INPUT};
$self->{INPUT} = $input;
%{$self->{PARAM}} = %{$self->{PARAM_DEFAULTS}}; # shallow copy of hash
$self->{CALLSTACK} = []; # re-initialise call stack (should destroy information from last parse)
$self->{GROUPS} = undef; # indicate that shift-reduce parser is not active
$self->{CURRENT_GROUP} = undef;
$self->{GROUPSTACK} = undef;
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
my $result = eval { $self->Call($rule, $input) }; # catch exceptions from parse errors
if (not defined $result) {
my $error = $@;
chomp($error); # remove trailing newline
$error = "parse of '' ".$self->{INPUT}." '' returned no result (reason unknown)"
if $error eq "";
$error =~ s/\s*\n\s*/ **::** /g;
$self->{ERROR} = $error;
}
$self->{INPUT} = undef; # no active parse
$self->{PARAM} = undef; # restore global parameter values (PARAM_DEFAULTS)
return $result; # undef if parse failed
}
=item I<@lines_of_text> = I<$grammar>->B<ErrorMessage>;
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
my $error = $self->{ERROR};
return ()
unless defined $error;
my @lines = "**Error:** $error";
my $previous_frame = { RULE => "", INPUT => "" }; # init do dummy frame to avoid special case below
foreach my $frame (reverse @{$self->{CALLSTACK}}) {
my $rule = $frame->{RULE};
if ($rule eq "APPLY") {
my @done = @{$frame->{APPLY_DONE}};
my @remain = @{$frame->{APPLY_ITEMS}};
push @lines, " - at this location: '' @done ''**<==**'' @remain ''";
}
else {
my $input = $frame->{INPUT};
my $previous_input = $previous_frame->{INPUT} || "";
if (($previous_input eq $input) and ($previous_frame->{RULE} ne "APPLY")) {
$lines[-1] .= ", **$rule**";
}
else {
push @lines, " - when parsing '' $input '' as **$rule**";
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
sub SetParam {
croak 'Usage: $grammar->SetParam($name, $value)'
unless @_ == 3;
my ($self, $name, $value) = @_;
## select either global parameter values (user level) or working copy (during parse)
my $param_set = (defined $self->{INPUT}) ? $self->{PARAM} : $self->{PARAM_DEFAULTS};
croak "CWB::CEQL::Parser: parameter '$name' does not exist"
unless exists $param_set->{$name};
$param_set->{$name} = $value;
}
sub GetParam {
croak 'Usage: $grammar->GetParam($name)'
unless @_ == 2;
my ($self, $name) = @_;
my $param_set = (defined $self->{INPUT}) ? $self->{PARAM} : $self->{PARAM_DEFAULTS};
croak "CWB::CEQL::Parser: parameter '$name' does not exist"
unless exists $param_set->{$name};
return $param_set->{$name};
}
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
sub NewParam {
confess 'Usage: $self->NewParam($name, $default_value)'
unless @_ == 3;
my ($self, $name, $value) = @_;
## select either global parameter values (user level) or working copy (during parse)
my $param_set = (defined $self->{INPUT}) ? $self->{PARAM} : $self->{PARAM_DEFAULTS};
confess "CWB::CEQL::Parser: parameter '$name' already exists, cannot create with NewParam()"
if exists $param_set->{$name};
$param_set->{$name} = $value;
}
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
sub Call {
confess 'Usage: $result = $self->Call($rule, $input);'
unless @_ == 3;
my ($self, $rule, $input) = @_;
confess "Sorry, we're not parsing yet"
unless defined $self->{INPUT};
my $method = $self->can("$rule");
confess "the rule **$rule** does not exist in grammar **".ref($self)."** (internal error)\n"
unless defined $method;
my $frame = {RULE => $rule,
INPUT => $input};
push @{$self->{CALLSTACK}}, $frame;
my $result = $method->($self, $input);
die "rule **$rule** failed to return a result (internal error)\n"
unless defined $result;
my $return_frame = pop @{$self->{CALLSTACK}};
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
sub Try {
confess 'Usage: $result = $self->Try($rule, $input);'
unless @_ == 3;
my ($self, $rule, $input) = @_;
confess "Sorry, we're not parsing yet"
unless defined $self->{INPUT};
## make flat backup copies of important data structures and ensure they are restored upon return
## (this is not completely safe, but should undo most changes that a failed parse may have made)
my $back_param = [ @{$self->{PARAM}} ];
my $back_callstack = [ @{$self->{CALLSTACK}} ];
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
confess 'Usage: @results = $self->Apply($rule, @items);'
unless @_ >= 2;
my $self = shift;
my $rule = shift;
my $frame = {RULE => "APPLY",
INPUT => undef,
APPLY_ITEMS => [ @_ ],
APPLY_DONE => []};
push @{$self->{CALLSTACK}}, $frame;
## data structures for nested groups and result values must be restored on exit (in case of nested Apply())
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
complex parameter values within grammar rules, as the changes will affect the
global values in C<PARAM_DEFAULTS>. If complex values need to be changed
internally, the grammar rule should always update the parameter with
B<SetParam> and a deep copy of the previous parameter value.
=item INPUT
The current input string passed to the B<Parse> method. This variable is
mostly used to indicate whether the parser is currently active or not (e.g. in
order to avoid nested B<Parse> calls).
lib/CWB/CEQL/Parser.pm view on Meta::CPAN
Name of the grammar rule (i.e. Perl B<method>) invoked. When the shift-reduce
parser is called with B<Apply>, a special rule named C<APPLY> is pushed on the
stack.
=item INPUT
Input string for the grammar rule (which should be a constituent of the
respective type).
=item APPLY_ITEMS (optional, "APPLY" rule only)
Alt-Crypt-OpenSSL-PKCS12-Broadbean
view release on metacpan or search on metacpan
if ((RETVAL = PKCS12_new()) == NULL) {
croak("Couldn't create PKCS12_new() for class %" SVf "\n", SVfARG(class));
}
OUTPUT:
RETVAL
IV legacy_support(class)
SV *class;
if (legacy)
RETVAL = 1;
else
RETVAL = 0;
#endif
OUTPUT:
RETVAL
Crypt::OpenSSL::PKCS12
new_from_string(class, string)
SV *class
croak("%" SVf ": Couldn't create PKCS12 from d2i_PKCS12_BIO(): %s", SVfARG(class), ssl_error(aTHX));
}
BIO_free_all(bio);
OUTPUT:
RETVAL
# This is called at per-object destruction time.
void
DESTROY(pkcs12)
croak("i2d_PKCS12_bio: %s", ssl_error(aTHX));
}
RETVAL = extractBioString(aTHX_ bio);
OUTPUT:
RETVAL
SV*
mac_ok(pkcs12, pwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
croak("PKCS12_verify_mac: \n%s", ssl_error(aTHX));
}
RETVAL = (PKCS12_verify_mac(pkcs12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
OUTPUT:
RETVAL
SV*
changepass(pkcs12, oldpwd = "", newpwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
RETVAL = &PL_sv_no;
} else {
RETVAL = &PL_sv_yes;
}
OUTPUT:
RETVAL
SV*
create(pkcs12, cert_chain_pem = "", pk = "", pass = 0, file = 0, name = "PKCS12 Certificate")
char *cert_chain_pem
PKCS12_free(p12);
fclose(fp);
RETVAL = &PL_sv_yes;
OUTPUT:
RETVAL
SV*
create_as_string(pkcs12, cert_chain_pem = "", pk = "", pass = 0, name = "PKCS12 Certificate")
i2d_PKCS12_bio(bio, p12);
RETVAL = extractBioString(aTHX_ bio);
PKCS12_free(p12);
OUTPUT:
RETVAL
SV*
certificate(pkcs12, pwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
dump_certs_keys_p12(aTHX_ bio, pkcs12, pwd, strlen(pwd), CLCERTS|NOKEYS, NULL, NULL);
RETVAL = extractBioString(aTHX_ bio);
OUTPUT:
RETVAL
SV*
ca_certificate(pkcs12, pwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
dump_certs_keys_p12(aTHX_ bio, pkcs12, pwd, strlen(pwd), CACERTS|NOKEYS, NULL, NULL);
RETVAL = extractBioString(aTHX_ bio);
OUTPUT:
RETVAL
SV*
private_key(pkcs12, pwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
dump_certs_keys_p12(aTHX_ bio, pkcs12, pwd, strlen(pwd), NOCERTS, NULL, NULL);
RETVAL = extractBioString(aTHX_ bio);
OUTPUT:
RETVAL
HV* info_as_hash(pkcs12, pwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
char *pwd
warn("bio from info_as_hash should be zero length - report issue");
}
sv_2mortal((SV*)RETVAL);
OUTPUT:
RETVAL
SV*
info(pkcs12, pwd = "")
Crypt::OpenSSL::PKCS12 pkcs12
#endif
dump_certs_keys_p12(aTHX_ bio, pkcs12, pwd, strlen(pwd), INFO, NULL, NULL);
RETVAL = extractBioString(aTHX_ bio);
OUTPUT:
RETVAL
Alt-Devel-CallParser-ButWorking
view release on metacpan or search on metacpan
lib/Devel/CallParser.xs view on Meta::CPAN
DEFFN("void", "cv_get_call_parser", "gcp0",
"CV *, Perl_call_parser *, SV **", "cv, fp, op")
DEFFN("void", "cv_set_call_parser", "scp0",
"CV *, Perl_call_parser, SV *", "cv, f, o")
);
OUTPUT:
RETVAL
SV *
callparser1_h()
CODE:
lib/Devel/CallParser.xs view on Meta::CPAN
"CV *, Perl_call_parser, SV *", "cv, f, o")
);
#else /* !Q_PARSER_AVAILABLE */
croak("callparser1.h not available on this version of Perl");
#endif /* !Q_PARSER_AVAILABLE */
OUTPUT:
RETVAL
Alt-Devel-GlobalDestruction-XS-Inline
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
my $junk = "";
my $current = \$junk;
while (<TYPEMAP>) {
next if /^\s*\#/;
my $line_no = $. + 1;
if (/^INPUT\s*$/) {$mode = 'Input'; $current = \$junk; next}
if (/^OUTPUT\s*$/) {$mode = 'Output'; $current = \$junk; next}
if (/^TYPEMAP\s*$/) {$mode = 'Typemap'; $current = \$junk; next}
if ($mode eq 'Typemap') {
chomp;
my $line = $_;
TrimWhitespace($_);
inc/Inline/C.pm view on Meta::CPAN
I32* temp;
CODE:
temp = PL_markstack_ptr++;
RETVAL = $function($arg_name_list);
PL_markstack_ptr = temp;
OUTPUT:
RETVAL
END
}
}
$XS .= "\n";
inc/Inline/C.pm view on Meta::CPAN
#define Inline_Stack_Vars dXSARGS
#define Inline_Stack_Items items
#define Inline_Stack_Item(x) ST(x)
#define Inline_Stack_Reset sp = mark
#define Inline_Stack_Push(x) XPUSHs(x)
#define Inline_Stack_Done PUTBACK
#define Inline_Stack_Return(x) XSRETURN(x)
#define Inline_Stack_Void XSRETURN(0)
#define INLINE_STACK_VARS Inline_Stack_Vars
#define INLINE_STACK_ITEMS Inline_Stack_Items
inc/Inline/C.pm view on Meta::CPAN
sub build_error_message {
my ($o, $cmd, $output_file, $build_noisy) = @_;
my $build_dir = $o->{API}{build_dir};
my $output = '';
if (not $build_noisy and
open(OUTPUT, $output_file)
) {
local $/;
$output = <OUTPUT>;
close OUTPUT;
}
my $errcode = $? >> 8;
$output .= <<END;
Alt-Digest-MD5-OpenSSL
view release on metacpan or search on metacpan
MD5_CTX* T_MD5_CTX
INPUT
T_MD5_CTX
$var = get_md5_ctx(aTHX_ $arg)
Alt-Lexical-Var-ButSupportModernPerl
view release on metacpan or search on metacpan
SvREFCNT_dec(val);
}
if(char_attr[(U8)sigil] & CHAR_USEPAD)
setup_pad(compcv, SvPVX(key)+KEYPREFIXLEN);
}
PUTBACK;
}
#define unimport(base_sigil, vari_word) \
THX_unimport(aTHX_ base_sigil, vari_word)
static void THX_unimport(pTHX_ char base_sigil, char const *vari_word)
SV *
_variable_for_compilation(SV *classname, SV *name)
CODE:
PERL_UNUSED_VAR(classname);
RETVAL = lookup_for_compilation('N', "variable", name);
OUTPUT:
RETVAL
void
import(SV *classname, ...)
PPCODE:
SV *
_sub_for_compilation(SV *classname, SV *name)
CODE:
PERL_UNUSED_VAR(classname);
RETVAL = lookup_for_compilation('&', "subroutine", name);
OUTPUT:
RETVAL
void
import(SV *classname, ...)
PPCODE:
Alt-Math-Prime-FastSieve-Inline
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
my $junk = "";
my $current = \$junk;
while (<TYPEMAP>) {
next if /^\s*\#/;
my $line_no = $. + 1;
if (/^INPUT\s*$/) {$mode = 'Input'; $current = \$junk; next}
if (/^OUTPUT\s*$/) {$mode = 'Output'; $current = \$junk; next}
if (/^TYPEMAP\s*$/) {$mode = 'Typemap'; $current = \$junk; next}
if ($mode eq 'Typemap') {
chomp;
my $line = $_;
TrimWhitespace($_);
inc/Inline/C.pm view on Meta::CPAN
I32* temp;
CODE:
temp = PL_markstack_ptr++;
RETVAL = $function($arg_name_list);
PL_markstack_ptr = temp;
OUTPUT:
RETVAL
END
}
}
$XS .= "\n";
inc/Inline/C.pm view on Meta::CPAN
#define Inline_Stack_Vars dXSARGS
#define Inline_Stack_Items items
#define Inline_Stack_Item(x) ST(x)
#define Inline_Stack_Reset sp = mark
#define Inline_Stack_Push(x) XPUSHs(x)
#define Inline_Stack_Done PUTBACK
#define Inline_Stack_Return(x) XSRETURN(x)
#define Inline_Stack_Void XSRETURN(0)
#define INLINE_STACK_VARS Inline_Stack_Vars
#define INLINE_STACK_ITEMS Inline_Stack_Items
inc/Inline/C.pm view on Meta::CPAN
sub build_error_message {
my ($o, $cmd, $output_file, $build_noisy) = @_;
my $build_dir = $o->{API}{build_dir};
my $output = '';
if (not $build_noisy and
open(OUTPUT, $output_file)
) {
local $/;
$output = <OUTPUT>;
close OUTPUT;
}
my $errcode = $? >> 8;
$output .= <<END;
AltaVista-PerlSDK
view release on metacpan or search on metacpan
avs_addword(idx, pWords, loc, pNumWords)
avs_idxHdl_t idx
char *pWords
long loc
long &pNumWords
OUTPUT:
RETVAL
pNumWords
int
avs_buildmode(idx)
int
avs_compact(idx, bMore_p)
avs_idxHdl_t idx
int &bMore_p
OUTPUT:
RETVAL
bMore_p
int
avs_compactionneeded (idx)
int
avs_compact_minor(idx, bMore_p)
avs_idxHdl_t idx
int &bMore_p
OUTPUT:
RETVAL
bMore_p
int
avs_count(idx, pWordPrefix, pCountsHdl)
avs_idxHdl_t idx
char *pWordPrefix
avs_countsHdl_t &pCountsHdl = NO_INIT
OUTPUT:
pCountsHdl
RETVAL
int
avs_count_close(CountsHdl)
void
avs_default_options(pOptions)
avs_options_p_t pOptions
CODE:
avs_default_options(pOptions);
OUTPUT:
pOptions
int
avs_define_valtype(name, minval, maxval, valtype_p)
char * name
unsigned long minval
unsigned long maxval
avs_valtype_t valtype_p = NO_INIT
CODE:
RETVAL = avs_define_valtype(name, minval, maxval, NULL, &valtype_p);
OUTPUT:
RETVAL
valtype_p
int
avs_define_valtype_multiple(name, minval, maxval, numvalues, valtype_p)
unsigned long maxval
int numvalues
avs_valtype_t valtype_p = NO_INIT
CODE:
RETVAL = avs_define_valtype_multiple(name, minval, maxval, numvalues, NULL, &valtype_p);
OUTPUT:
RETVAL
valtype_p
int
avs_deletedocid(idx, pDocId, pCount)
avs_idxHdl_t idx
char *pDocId
int &pCount
OUTPUT:
RETVAL
pCount
int
avs_enddoc(idx)
int
avs_getmaxloc(idx, pMaxloc)
avs_idxHdl_t idx
long &pMaxloc
OUTPUT:
RETVAL
pMaxloc
int
avs_getsearchresults(searchHdl, resultNum)
RETVAL = avs_getsearchterms(psearchHdl, termNum, &p, &i);
if (RETVAL == 0) {
count = i;
term = strdup(p);
}
OUTPUT:
term
count
RETVAL
int
avs_getsearchversion(searchHdl, searchversion)
avs_searchHdl_t searchHdl
char * searchversion
OUTPUT:
searchversion
RETVAL
int
avs_licenseinfo(key, expDate, docLimit)
char *key
time_t &expDate
long &docLimit
OUTPUT:
RETVAL
expDate
docLimit
avs_valtype_t
avs_idxHdl_t idx = NO_INIT
PREINIT:
avs_parameters_t myparms = AVS_PARAMETERS_INIT;
CODE:
RETVAL = avs_open(parameters, path, mode, &idx);
OUTPUT:
idx
RETVAL
int
avs_querymode(idx)
avs_options_p_t pOptions
long &pDocsFound = NO_INIT;
long &pDocsReturned = NO_INIT;
long &pTermCount = NO_INIT;
avs_searchHdl_t &pSearchHdl = NO_INIT;
OUTPUT:
RETVAL
pDocsFound
pDocsReturned
pTermCount
pSearchHdl
char *searchsince
long &pDocsFound = NO_INIT;
long &pDocsReturned = NO_INIT;
long &pTermCount = NO_INIT;
avs_searchHdl_t &pSearchHdl = NO_INIT;
OUTPUT:
RETVAL
pDocsFound
pDocsReturned
pTermCount
pSearchHdl
CODE:
RETVAL = avs_search_genrank(idx, pBoolQuery, pRankTerms,
NULL, pOptions, searchsince,
&pDocsFound, &pDocsReturned,
&pSearchHdl);
OUTPUT:
pDocsFound
pDocsReturned
pSearchHdl
RETVAL
avs_search_getdate(psearchHdl, year, month, day)
avs_searchHdl_t psearchHdl
int &year
int &month
int &day
OUTPUT:
year
month
day
char *
PREINIT:
char *p;
CODE:
p = avs_search_getdocid(searchHdl);
RETVAL = strdup(p);
OUTPUT:
RETVAL
int
avs_search_getdocidlen(searchHdl)
avs_searchHdl_t searchHdl
float f;
CODE:
f = avs_search_getrelevance(psearchHdl);
sprintf(p, "%f", f);
RETVAL = strdup(p);
OUTPUT:
RETVAL
int
avs_setdocdata(idx, pDocData, len)
avs_idxHdl_t idx
char *pDocData
int len
CODE:
RETVAL = avs_setdocdata(idx, pDocData, len);
OUTPUT:
RETVAL
int
avs_setdocdate(idx, year, month, day)
avs_idxHdl_t idx
avs_startdoc(idx, pDocId, flags, pStartLoc)
avs_idxHdl_t idx
char *pDocId
int flags
long &pStartLoc
OUTPUT:
RETVAL
pStartLoc
void
avs_timer(current)
int
avs_total_docs(idx, pDoccount)
avs_idxHdl_t idx
long &pDoccount
OUTPUT:
RETVAL
pDoccount
AV *
avs_version(license_key)
while (*lines != 0) {
av_push(arr, newSVpv(strdup(*lines), 0));
lines++;
}
RETVAL = (AV *) arr;
OUTPUT:
RETVAL
avs_options_p_t
avs_create_options(limit, timeout, flags)
long limit
CODE:
RETVAL = malloc(sizeof(struct avs_options));
RETVAL->limit = limit;
RETVAL->timeout = timeout;
RETVAL->flags = flags;
OUTPUT:
RETVAL
avs_parameters_t *
avs_create_parameters(_interface_version, license, ignored_thresh, chars_before_wildcard, unlimited_wild_words, indexformat, cache_threshold, options, charset, ntiers, nbuckets)
char * _interface_version
RETVAL->cache_threshold = cache_threshold;
RETVAL->options = options;
RETVAL->charset = charset;
RETVAL->ntiers = ntiers;
RETVAL->nbuckets = nbuckets;
OUTPUT:
RETVAL
AltaVista-SDKLinguistics
view release on metacpan or search on metacpan
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_thesaurus_get(hdl, word, language, separator = ' ')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_thesaurus_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_phrase_get(hdl, word, language, separator = ':')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_phrase_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
void *
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_stem_get(hdl, word, language, separator = ' ')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_stem_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
void *
avsl_spell_init(config)
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_spellcheck_get(hdl, word, language, separator = ' ')
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
char *
avsl_spellcorrection_get(hdl, word, language, separator = ' ')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_spell_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
Alter
view release on metacpan or search on metacpan
CODE:
corona = ALT_corona(obj);
if (!corona)
XSRETURN_EMPTY;
RETVAL = newRV_inc((SV*)corona);
OUTPUT:
RETVAL
SV *alter(SV *obj, SV *val)
PROTOTYPE: $$
PREINIT:
if (!corona)
XSRETURN_EMPTY;
class = CopSTASHPV(PL_curcop);
hv_store(corona, class, strlen(class), SvREFCNT_inc(val), 0);
RETVAL = SvREFCNT_inc(obj); /* method chaining */
OUTPUT:
RETVAL
SV *ego(SV *obj, ...)
PROTOTYPE: $
CODE:
}
}
if (!ego)
XSRETURN_UNDEF;
RETVAL = SvREFCNT_inc(ego);
OUTPUT:
RETVAL
void _set_class_type(char *class, SV *spec)
CODE:
HV *type_tab = ALT_type_tab();
Alvis-Convert
view release on metacpan or search on metacpan
lib/Alvis/Convert.pm view on Meta::CPAN
$ERR_TYPE_SUFFIX,
$ERR_READ_HTML,
$ERR_READ_NEWS_XML,
$ERR_ALVIS_CONV,
$ERR_ALVIS_SUFFIX,
$ERR_NO_OUTPUT_ROOT_DIR,
$ERR_WRITING_OUTPUT,
$ERR_DIR_CONV,
$ERR_NO_HTML_F,
$ERR_META_F,
$ERR_HTML_F,
$ERR_NEWS_XML_F,
$ERR_DOC_ALVIS_CONV,
$ERR_NEWS_XML_PARSE,
$ERR_MULTIPLE_SUFFIX_MEANING,
$ERR_OUTPUT_ALVIS,
$ERR_OUTPUT_SET_OF_RECORDS,
$ERR_AINODUMP,
$ERR_OPEN_AINODUMP,
$ERR_AINODUMP_PROCESS,
$ERR_DOC_TYPE_WIZARD,
$ERR_TYPE_GUESS,
lib/Alvis/Convert.pm view on Meta::CPAN
$ERR_TYPE_SUFFIX=>"No suffix given for a type.",
$ERR_READ_HTML=>"Reading the HTML failed.",
$ERR_READ_NEWS_XML=>"Reading the news XML failed.",
$ERR_ALVIS_CONV=>"Conversion to Alvis format failed.",
$ERR_ALVIS_SUFFIX=>"No Alvis suffix defined.",
$ERR_NO_OUTPUT_ROOT_DIR=>"No output root directory.",
$ERR_WRITING_OUTPUT=>"Writing the output failed.",
$ERR_DIR_CONV=>"Converting a directory failed.",
$ERR_NO_HTML_F=>"No HTML file.",
$ERR_META_F=>"Opening the meta file failed.",
$ERR_HTML_F=>"Opening the HTML file failed.",
$ERR_NEWS_XML_F=>"Opening the news XML file failed.",
$ERR_DOC_ALVIS_CONV=>"Converting a document to Alvis format failed.",
$ERR_NEWS_XML_PARSE=>"Parsing the news XML failed.",
$ERR_MULTIPLE_SUFFIX_MEANING=>
"Multiple meanings for a single suffix.",
$ERR_OUTPUT_ALVIS=>"Outputting the Alvis records failed.",
$ERR_OUTPUT_SET_OF_RECORDS=>"Outputting a set of records to a " .
"file as a documentCollection failed.",
$ERR_AINODUMP=>"Instantiating Alvis::AinoDump failed.",
$ERR_OPEN_AINODUMP=>"Opening an ainodump file failed.",
$ERR_AINODUMP_PROCESS=>"Processing an ainodump file failed.",
$ERR_DOC_TYPE_WIZARD=>"Instantiating Alvis::Document::Type " .
lib/Alvis/Convert.pm view on Meta::CPAN
# _output_wikipedia_article($arg1,$arg2,...,
# $title,$output_format,
# $record_txt,$is_redir)
#
# where $output_format is a global defined in Alvis::Wikipedia::XMLDump
# as $OUTPUT_*
#
#
# progress_cb: [\&_wikipedia_progress,$arg1,$arg2,...] OPTIONAL
# will be called like this:
# _wikipedia_progress($arg1,$arg2,...,
lib/Alvis/Convert.pm view on Meta::CPAN
# namespaces ref to a list of namespace identifiers whose
# records to extract
# expandTemplates flag for true template expansion
# templateDumpF template dump file
# outputFormat format for result records
# ($Alvis::Wikipedia::XMLDump::OUTPUT_*)
# categoryWord category namespace identifier (changes with
# language)
# templateWord template namespace identifier (changes with
# language)
# rootCategory root category identifier (changes with
lib/Alvis/Convert.pm view on Meta::CPAN
$out_f=$base_name . "." . $self->{articleN} . '.' .
$self->{alvisSuffix};
$self->{articleN}++;
if (!$self->_output_set_of_records($alvis_record,$out_f))
{
$self->_set_err_state($ERR_OUTPUT_SET_OF_RECORDS);
return 0;
}
$self->{outputN}++;
print "$self->{outputN}\r";
}
else
{
if (!defined($self->{outputRootDir}))
{
$self->_set_err_state($ERR_NO_OUTPUT_ROOT_DIR);
return 0;
}
my $dir=$self->{outputRootDir} . '/' .
int($self->{outputN} / $self->{outputNPerSubdir});
if ($self->{outputN} % $self->{outputNPerSubdir}==0)
lib/Alvis/Convert.pm view on Meta::CPAN
$out_f=$dir . '/' . $self->{outputN} . '.' .
$self->{alvisSuffix};
if (!$self->_output_set_of_records($alvis_record,$out_f))
{
$self->_set_err_state($ERR_OUTPUT_SET_OF_RECORDS);
return 0;
}
$self->{outputN}++;
print "$self->{outputN}\r";
lib/Alvis/Convert.pm view on Meta::CPAN
return 0;
}
if (!$self->output_Alvis([$alvisXML],$base_name))
{
$self->_set_err_state($ERR_OUTPUT_ALVIS,
"Base name: \"$base_name\"");
return 0;
}
}
else
lib/Alvis/Convert.pm view on Meta::CPAN
my $set_of_records_txt=shift;
my $path=shift;
if (!defined(open(OUT,">:utf8",$path)))
{
$self->_set_err_state($ERR_WRITING_OUTPUT,"Output file: " .
"\"$path\"");
return 0;
}
print OUT "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
print OUT "<documentCollection xmlns=\"http://alvis.info/enriched/\">\n";
Alvis-NLPPlatform
view release on metacpan or search on metacpan
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
while(($j< scalar @cur_doc) && ($cur_doc[$j] !~ s/\@RENDER_TIME_NOT_SET\@/$render_time/)) {
$j++;
}
close(FILETMP_OUT);
if (!((exists $config->{"XML_OUTPUT"}->{"NO_STD_XML_OUTPUT"}) && ($config->{"XML_OUTPUT"}->{"NO_STD_XML_OUTPUT"} == 1))) {
if (scalar(@records) > 1) {
if ($i == 0){
pop @cur_doc;
} else {
shift @cur_doc;
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
print STDERR "\t" . $nlp_connection_vars{$var} . " : " . $config->{"NLP_connection"}->{$var} . "\n";
}
}
}
if (defined $config->{"XML_INPUT"}) {
print STDERR " Section Configuration of the XML INPUT\n";
my %xml_input_vars = ("PRESERVEWHITESPACE" => "Preserve XML White space?",
"LINGUISTIC_ANNOTATION_LOADING" => "Loading previous linguistic annotation?",
);
foreach $var (keys %xml_input_vars) {
if (defined $config->{"XML_INPUT"}->{$var}) {
print STDERR "\t" . $xml_input_vars{$var} . " : " . $config->{"XML_INPUT"}->{$var} . "\n";
}
}
}
if (defined $config->{"XML_OUTPUT"}) {
print STDERR " Section Configuration of the XML OUTPUT\n";
my %xml_output_vars = ("NO_STD_XML_OUTPUT" => "No printing standard XML output?",
);
foreach $var (keys %xml_output_vars) {
if (defined $config->{"XML_OUTPUT"}->{$var}) {
print STDERR "\t" . $xml_output_vars{$var} . " : " . $config->{"XML_OUTPUT"}->{$var} . "\n";
}
}
}
&compute_dependencies($config);
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
}
}
if (defined $config->{"CONVERTERS"}) {
print STDERR " Section INPUT CONVERTERS\n";
my %Converter_vars = ("SupplMagicFile" => "File for Additional Definition of Magic Number",
);
foreach $var (keys %Converter_vars) {
if (defined $config->{"CONVERTERS"}->{$var}) {
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
=over
=item * Global variables.
The two mandatory variables are C<ALVISTMP> and C<PRESERVEWHITESPACE>
(in the XML_INPUT section).
=over 8
=item *
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
C<RETRY_CONNECTION>: The number of times that
the clients attempts to connect to the server.
=back
=item * C<XML_INPUT>
=over 8
=item *
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
=back
=item *
C<XML_OUTPUT> (Not available yet)
=over 8
=item *
C<NO_STD_XML_OUTPUT>: The standard XML output is not printed. Default
value is false.
=item
FORM
Amazon-CloudFront-Thin
view release on metacpan or search on metacpan
lib/Amazon/CloudFront/Thin.pm view on Meta::CPAN
sub _default_ua {
require LWP::UserAgent;
my $ua = LWP::UserAgent->new(
keep_alive => 10,
# requests_redirectable => [qw(GET HEAD DELETE PUT)]
);
$ua->timeout(10);
$ua->env_proxy;
return $ua;
}
Amazon-DynamoDB
view release on metacpan or search on metacpan
lib/Amazon/DynamoDB/20120810.pm view on Meta::CPAN
Key => {
user_id => 2
},
AttributeUpdates => {
name => {
Action => 'PUT',
Value => "Rusty Conover-3",
},
favorite_color => {
Action => 'DELETE'
},
Amazon-S3-Thin
view release on metacpan or search on metacpan
lib/Amazon/S3/Thin.pm view on Meta::CPAN
sub _default_ua {
my $self = shift;
my $ua = LWP::UserAgent->new(
keep_alive => 10,
requests_redirectable => [qw(GET HEAD DELETE PUT)],
);
$ua->timeout(30);
$ua->env_proxy;
return $ua;
}
lib/Amazon/S3/Thin.pm view on Meta::CPAN
sub copy_object {
my ($self, $src_bucket, $src_key, $dst_bucket, $dst_key, $headers) = @_;
$headers ||= {};
$headers->{'x-amz-copy-source'} = $src_bucket . "/" . $src_key;
my $request = $self->_compose_request('PUT', $self->_resource($dst_bucket, $dst_key), $headers);
my $res = $self->_send($request);
# XXX: Since the COPY request might return error response in 200 OK, we'll rewrite the status code to 500 for convenience
# ref http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html
# ref https://github.com/boto/botocore/blob/4e9b4419ec018716ab1a3fe1587fbdc3cfef200e/botocore/handlers.py#L77-L120
lib/Amazon/S3/Thin.pm view on Meta::CPAN
if (ref($content)) {
# TODO
# I do not understand what it is :(
#
# return $self->_send_request_expect_nothing_probed('PUT',
# $self->_resource($bucket, $key), $headers, $content);
#
die "unable to handle reference";
}
else {
my $request = $self->_compose_request('PUT', $self->_resource($bucket, $key), $headers, $content);
return $self->_send($request);
}
}
sub list_objects {
lib/Amazon/S3/Thin.pm view on Meta::CPAN
$content = <<"EOT";
<CreateBucketConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">$location_constraint</CreateBucketConfiguration>
EOT
}
my $request = $self->_compose_request('PUT', $self->_resource($bucket), $headers, $content);
return $self->_send($request);
}
sub delete_bucket {
my ($self, $bucket) = @_;
lib/Amazon/S3/Thin.pm view on Meta::CPAN
B<Arguments>: a list with source (bucket, key) and destination (bucket, key), hashref with extra header information (B<optional>).
B<Returns>: an L<HTTP::Response> object for the request.
This method is a variation of the PUT operation as described by
Amazon's S3 API. It creates a copy of an object that is already stored
in Amazon S3. This "PUT copy" operation is the same as performing a GET
from the old bucket/key and then a PUT to the new bucket/key.
Note that the COPY request might return error response in 200 OK, but this method
will determine the error response and rewrite the status code to 500.
For more information, please refer to
lib/Amazon/S3/Thin.pm view on Meta::CPAN
=back
B<Returns>: an L<HTTP::Response> object for the request.
The PUT operation adds an object to a bucket. Amazon S3 never adds partial
objects; if you receive a success response, Amazon S3 added the entire
object to the bucket.
For more information, please refer to
L<< Amazon's documentation for PUT|http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html >>.
=head2 delete_multiple_objects( $bucket, @keys )
B<Arguments>: a string with the bucket name, and an array with all the keys
to be deleted.
Amazon-S3
view release on metacpan or search on metacpan
lib/Amazon/S3.pm view on Meta::CPAN
my ($self) = @_;
if ( $self->retry ) {
# In the field we are seeing issue of Amazon returning with a 400
# code in the case of timeout. From AWS S3 logs: REST.PUT.PART
# Backups/2017-05-04/<account>.tar.gz "PUT
# /Backups<path>?partNumber=27&uploadId=<id> - HTTP/1.1" 400
# RequestTimeout 360 20971520 20478 - "-" "libwww-perl/6.15"
my $http_codes_hr = $self->ua->codes_to_determinate();
$http_codes_hr->{$HTTP_BAD_REQUEST} = $TRUE;
}
lib/Amazon/S3.pm view on Meta::CPAN
my ($self) = @_;
if ( $self->retry ) {
# In the field we are seeing issue with Amazon returning a 400
# code in the case of timeout. From AWS S3 logs: REST.PUT.PART
# Backups/2017-05-04/<account>.tar.gz "PUT
# /Backups<path>?partNumber=27&uploadId=<id> - HTTP/1.1" 400
# RequestTimeout 360 20971520 20478 - "-" "libwww-perl/6.15"
my $http_codes_hr = $self->ua->codes_to_determinate();
delete $http_codes_hr->{$HTTP_BAD_REQUEST};
}
lib/Amazon/S3.pm view on Meta::CPAN
XML
my $data = defined $region ? sprintf $xml, $region : $EMPTY;
my $retval = $self->_send_request_expect_nothing(
{ method => 'PUT',
path => "$bucket/",
headers => { %header_ref, 'Content-Length' => length $data },
data => $data,
region => $region,
},
lib/Amazon/S3.pm view on Meta::CPAN
return $FALSE;
}
# Send a HEAD request first, to find out if we'll be hit with a 307 redirect.
# Since currently LWP does not have true support for 100 Continue, it simply
# slams the PUT body into the socket without waiting for any possible redirect.
# Thus when we're reading from a filehandle, when LWP goes to reissue the request
# having followed the redirect, the filehandle's already been closed from the
# first time we used it. Thus, we need to probe first to find out what's going on,
# before we start sending any actual data.
########################################################################
Amazon-S3Curl-PurePerl
view release on metacpan or search on metacpan
lib/Amazon/S3Curl/PurePerl.pm view on Meta::CPAN
#trailing slash for upload means curl will plop on the filename at the end, ruining the hash signature.
if ( $url =~ m|/$| ) {
my $file_name = ( File::Spec->splitpath( $self->local_file ) )[-1];
$url .= $file_name;
}
my $args = $self->_req('PUT',$url);
splice( @$args, $#$args, 0, "-T", $self->local_file );
return $args;
}
sub delete_cmd {
Amb
view release on metacpan or search on metacpan
cur_cv = cx->blk_sub.cv;
if (!cur_cv)
croak("Context has no CV!\n");
RETVAL = (SV*) newRV_inc( (SV*) cur_cv );
OUTPUT:
RETVAL
SV*
caller_op(context)
PERL_CONTEXT *cx = INT2PTR(PERL_CONTEXT*, SvIV(context));
OP *op = (OP*)cx->blk_oldcop;
SV *rv = newSV(0);
sv_setref_iv(rv, "B::COP", PTR2IV(op));
RETVAL = rv;
OUTPUT:
RETVAL
( run in 0.775 second using v1.01-cache-2.11-cpan-d6f9594c0a5 )