Result:
found more than 446 distributions - search limited to the first 2001 files matching your query
( run in 0.797 )
Clownfish-CFC
view release on metacpan or search on metacpan
charmonizer.c view on Meta::CPAN
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/FuncMacro.h"
/* Charmonizer/Probe/FuncMacro.h
*/
#ifndef H_CHAZ_FUNC_MACRO
#define H_CHAZ_FUNC_MACRO
#include <stdio.h>
/* Run the FuncMacro module.
*
* If __func__ successfully resolves, this will be defined:
*
* HAS_ISO_FUNC_MACRO
*
charmonizer.c view on Meta::CPAN
* following macro will be defined to "inline", otherwise it will be defined
* to nothing.
*
* INLINE
*/
void chaz_FuncMacro_run(void);
#endif /* H_CHAZ_FUNC_MACRO */
charmonizer.c view on Meta::CPAN
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/VariadicMacros.h"
/* Charmonizer/Probe/VariadicMacros.h
*/
#ifndef H_CHAZ_VARIADIC_MACROS
#define H_CHAZ_VARIADIC_MACROS
#include <stdio.h>
/* Run the VariadicMacros module.
*
* If your compiler supports ISO-style variadic macros, this will be defined:
*
* HAS_ISO_VARIADIC_MACROS
*
charmonizer.c view on Meta::CPAN
*
* If you have at least one of the above, this will be defined:
*
* HAS_VARIADIC_MACROS
*/
void chaz_VariadicMacros_run(void);
#endif /* H_CHAZ_VARIADIC_MACROS */
charmonizer.c view on Meta::CPAN
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/FuncMacro.c"
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/FuncMacro.h" */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/* Attempt to verify inline keyword. */
static int
chaz_FuncMacro_try_inline(const char *keyword) {
static const char inline_code[] = "static %s int f() { return 1; }";
char code[sizeof(inline_code) + 30];
sprintf(code, inline_code, keyword);
return chaz_CC_test_compile(code);
}
static void
chaz_FuncMacro_probe_inline(void) {
static const char* inline_options[] = {
"__inline",
"__inline__",
"inline"
};
charmonizer.c view on Meta::CPAN
int has_inline = false;
int i;
for (i = 0; i < num_inline_options; i++) {
const char *inline_option = inline_options[i];
if (chaz_FuncMacro_try_inline(inline_option)) {
has_inline = true;
chaz_ConfWriter_add_def("INLINE", inline_option);
break;
}
}
charmonizer.c view on Meta::CPAN
chaz_ConfWriter_add_def("INLINE", NULL);
}
}
void
chaz_FuncMacro_run(void) {
int has_funcmac = false;
int has_iso_funcmac = false;
int has_gnuc_funcmac = false;
chaz_ConfWriter_start_module("FuncMacro");
/* Check for func macros. */
if (chaz_CC_test_compile("const char *f() { return __func__; }")) {
has_funcmac = true;
has_iso_funcmac = true;
charmonizer.c view on Meta::CPAN
if (has_gnuc_funcmac) {
chaz_ConfWriter_add_def("HAS_GNUC_FUNC_MACRO", NULL);
}
/* Check for inline keyword. */
chaz_FuncMacro_probe_inline();
chaz_ConfWriter_end_module();
}
charmonizer.c view on Meta::CPAN
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/VariadicMacros.c"
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/VariadicMacros.h" */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/* Code for verifying ISO-style variadic macros. */
static const char chaz_VariadicMacros_iso_code[] =
CHAZ_QUOTE( #include <stdio.h> )
"#define ISO_TEST(fmt, ...) printf(fmt, __VA_ARGS__)\n"
CHAZ_QUOTE( void f() { ISO_TEST("%d %d", 1, 1); } );
/* Code for verifying GNU-style variadic macros. */
static const char chaz_VariadicMacros_gnuc_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( #define GNU_TEST(fmt, args...) printf(fmt, ##args) )
CHAZ_QUOTE( void f() { GNU_TEST("%d %d", 1, 1); } );
void
chaz_VariadicMacros_run(void) {
int has_varmacros = false;
chaz_ConfWriter_start_module("VariadicMacros");
/* Test for ISO-style variadic macros. */
if (chaz_CC_test_compile(chaz_VariadicMacros_iso_code)) {
has_varmacros = true;
chaz_ConfWriter_add_def("HAS_VARIADIC_MACROS", NULL);
chaz_ConfWriter_add_def("HAS_ISO_VARIADIC_MACROS", NULL);
}
/* Test for GNU-style variadic macros. */
if (chaz_CC_test_compile(chaz_VariadicMacros_gnuc_code)) {
if (has_varmacros == false) {
has_varmacros = true;
chaz_ConfWriter_add_def("HAS_VARIADIC_MACROS", NULL);
}
chaz_ConfWriter_add_def("HAS_GNUC_VARIADIC_MACROS", NULL);
charmonizer.c view on Meta::CPAN
/* Run probe modules. */
chaz_BuildEnv_run();
chaz_DirManip_run();
chaz_Headers_run();
chaz_FuncMacro_run();
chaz_Booleans_run();
chaz_Integers_run();
chaz_Strings_run();
chaz_Memory_run();
chaz_SymbolVisibility_run();
chaz_UnusedVars_run();
chaz_VariadicMacros_run();
if (chaz_CLI_defined(cli, "enable-makefile")) {
S_write_makefile(cli);
}
Clownfish
view release on metacpan or search on metacpan
cfcore/Clownfish/Err.cfh view on Meta::CPAN
#define CFISH_RETHROW(_error) \
cfish_Err_rethrow((cfish_Err*)_error, __FILE__, __LINE__, \
CFISH_ERR_FUNC_MACRO)
/** Macro version of cfish_Err_throw_at which inserts contextual information
* automatically, provided that the compiler supports the necessary features.
*/
#ifdef CFISH_HAS_VARIADIC_MACROS
#ifdef CFISH_HAS_ISO_VARIADIC_MACROS
#define CFISH_THROW(_class, ...) \
Comedi-Lib
view release on metacpan or search on metacpan
t/04-macros.t view on Meta::CPAN
use warnings;
use strict;
use Comedi::Lib;
# (Pseudo)-Macros
my @macros = qw(
CR_PACK
CR_PACK_FLAGS
CR_CHAN
CR_RANGE
Compress-Bzip2
view release on metacpan or search on metacpan
bzlib-src/bzlib_private.h view on Meta::CPAN
}
DState;
/*-- Macros for decompression. --*/
#define BZ_GET_FAST(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
s->tPos = s->tt[s->tPos]; \
Compress-Deflate7
view release on metacpan or search on metacpan
7zip/CPP/Windows/Control/CommandBar.h view on Meta::CPAN
{
_window = ::CommandBar_Create(hInst, hwndParent, idCmdBar);
return (_window != NULL);
}
// Macros
// void Destroy() { CommandBar_Destroy(_window); }
bool AddButtons(int iButton, UINT numButtons, LPTBBUTTON buttons) { return BOOLToBool(SendMessage(TB_ADDBUTTONS, (WPARAM)numButtons, (LPARAM)buttons)); }
bool InsertButton(int iButton, LPTBBUTTON button) { return BOOLToBool(SendMessage(TB_INSERTBUTTON, (WPARAM)iButton, (LPARAM)button)); }
BOOL AddToolTips(UINT numToolTips, LPTSTR toolTips) { return BOOLToBool(SendMessage(TB_SETTOOLTIPS, (WPARAM)numToolTips, (LPARAM)toolTips)); }
void AutoSize() { SendMessage(TB_AUTOSIZE, 0, 0); }
Compress-LZ4
view release on metacpan or search on metacpan
/*!
LZ4_compressBound() :
Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
This function is primarily useful for memory allocation purposes (destination buffer size).
Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
inputSize : max supported value is LZ4_MAX_INPUT_SIZE
return : maximum output size in a "worst case" scenario
or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
*/
Compress-LZ4Frame
view release on metacpan or search on metacpan
/*!
LZ4_compressBound() :
Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
This function is primarily useful for memory allocation purposes (destination buffer size).
Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
inputSize : max supported value is LZ4_MAX_INPUT_SIZE
return : maximum output size in a "worst case" scenario
or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
*/
Compress-Raw-Bzip2
view release on metacpan or search on metacpan
bzip2-src/bzlib_private.h view on Meta::CPAN
}
DState;
/*-- Macros for decompression. --*/
#define BZ_GET_FAST(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
s->tPos = s->tt[s->tPos]; \
Compress-Raw-Zlib
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
delete $WriteMakefileArgs{BUILD_REQUIRES}
unless eval { ExtUtils::MakeMaker->VERSION(6.55_03) } ;
WriteMakefile(%WriteMakefileArgs);
sub version_Macro
{
my $ver = shift ;
return [ "#if ZLIB_VERNUM >= 0x$ver\n", "#endif\n" ];
}
Makefile.PL view on Meta::CPAN
}
push @names, { name => 'ZLIB_VERSION', type => 'PV' };
push @names, map { { name => $_,
macro => version_Macro $verSpecificNames{$_}
}
}
keys %verSpecificNames ;
push @names, { name => 'Z_NULL', type => 'UV' };
Compress-Stream-Zstd
view release on metacpan or search on metacpan
ext/zstd/CONTRIBUTING.md view on Meta::CPAN
* Prefer positive actions
- `goBackward` rather than `notGoForward`
* Type names (`struct`, etc.) follow similar convention,
except that they are allowed and even invited to start by an Uppercase letter.
Example : `ZSTD_CCtx`, `ZSTD_CDict`
* Macro names are all Capital letters.
The same composition rules (`PREFIX_NAME_QUALIFIER`) apply.
* File names are all lowercase letters.
The convention is `snake_case`.
File names **must** be unique across the entire code base,
even when they stand in clearly separated directories.
Compress-Zstd
view release on metacpan or search on metacpan
ext/zstd/build/VS2010/datagen/datagen.vcxproj view on Meta::CPAN
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<RunCodeAnalysis>false</RunCodeAnalysis>
<IncludePath>$(IncludePath);$(SolutionDir)..\..\programs;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib\common;$(UniversalCRT_IncludePath);</IncludePath>
</PropertyGroup>
Config-Checker
view release on metacpan or search on metacpan
lib/Config/Checker.pm view on Meta::CPAN
use strict;
use warnings;
use Eval::LineNumbers qw(eval_line_numbers);
require Exporter;
require Config::YAMLMacros::YAML;
require Module::Load;
require Time::ParseDate;
require Carp;
use Config::YAMLMacros::YAML;
our @ISA = qw(Exporter);
our @EXPORT = qw(config_checker_source);
our @EXPORT_OK = (@EXPORT, qw(unique split_listify));
our $VERSION = 0.42;
lib/Config/Checker.pm view on Meta::CPAN
sub {
my ($config, $prototype_string, $where) = @_;
$prototype_string =~ s/^(\t+)/" " x length($1) * 8/e;
my $proto = ref($prototype_string)
? $prototype_string
: Config::YAMLMacros::YAML::Load($prototype_string);
my %checker;
my $error;
local(%Config::Checker::unique);
Config-Scoped
view release on metacpan or search on metacpan
lib/Config/Scoped.pm view on Meta::CPAN
my $name = $args{name};
my $value = $args{value};
# warnings for macros enabled?
if ( $thisparser->warnings_on( name => 'macro', ) ) {
Config::Scoped::Error::Validate::Macro->throw(
-file => $thisparser->_get_file(%args),
-line => $thisparser->_get_line(%args),
-text => "macro redefinition for '$name"
)
if exists $thisparser->{local}{macros}{$name};
Config-Simple-Conf
view release on metacpan or search on metacpan
lib/Config/Simple/Conf.pm view on Meta::CPAN
[section]
keyname = value
=head2 USING A MACRO
Macros are defined as square brakets with a B<section:key> entry between them. These are automatically resolved to other configuration sections and keys and that keys value is utilized.
# Define a value based on a macro
[section2]
key = [section:keyname]
=head2 NOTE
Macros may B<NOT> utilize list entries of duplicate macro keys.
=head2 SPECIAL MACROS
Currently there are two special macros which perform useful tasks
Config-UCL
view release on metacpan or search on metacpan
libucl-0.8.1/ChangeLog.md view on Meta::CPAN
- remove dangling expressions
- use std::set::emplace instead of std::set::insert
- not use std::move in return statement; considering copy elision
- C++ wrapper: fix compilation error and warnings (by Zhe Wang)
- C++ wrapper: fix iteration over objects in which the first value is `false` (by Zhe Wang)
- C++ wrapper: Macro helper functions (by Chris Meacham)
- C++ wrapper: Changing the duplicate strategy in the C++ API (by Chris Meacham)
- C++ wrapper: Added access functions for the size of a UCL_ARRAY (by Chris Meacham)
- Fix caseless comparison
- Fix include when EPERM is issued
- Fix Windows build
Convert-Binary-C
view release on metacpan or search on metacpan
lib/Convert/Binary/C.pm view on Meta::CPAN
Include
Define
Assert
HasCPPComments
HasMacroVAARGS
=head2 Supported pragma directives
Convert::Binary::C supports the C<pack> pragma to locally override
struct member alignment. The supported syntax is as follows:
lib/Convert/Binary/C.pm view on Meta::CPAN
'ShortSize' => 2,
'IntSize' => 4,
'StdCVersion' => 199901,
'HostedC' => 1,
'Alignment' => 1,
'HasMacroVAARGS' => 1,
'KeywordMap' => {},
'Define' => [
'DEBUGGING',
'FOO=123'
],
lib/Convert/Binary/C.pm view on Meta::CPAN
one = 4 / 4;
two = 2;
which is correct.
=item C<HasMacroVAARGS> =E<gt> 0 | 1
Use this option to turn the C<__VA_ARGS__> macro expansion
on or off. If this is enabled (which is the default), you can use
variable length argument lists in your preprocessor macros.
lib/Convert/Binary/C.pm view on Meta::CPAN
ENDC
for my $macro (qw( ADD DEFINED UNDEFINED )) {
my $not = $c->defined($macro) ? '' : ' not';
print "Macro '$macro' is$not defined.\n";
}
would print:
Macro 'ADD' is defined.
Macro 'DEFINED' is defined.
Macro 'UNDEFINED' is not defined.
You have to keep in mind that this works only as long as the preprocessor
is not reset. See L<"Preprocessor configuration"> for details.
=back
Convert-IBM390
view release on metacpan or search on metacpan
#define UNDEF_PTR &PL_sv_undef
#endif
/* 36KB may seem small, but on MVS most records are 32KB or less. */
#define OUTSTRING_MEM 36864
/* Macro: catenate a string to the end of an existing string
* and move the pointer up. */
#define memcat(target,offset,source,len) \
memcpy((target+offset), source, len); \
offset += len;
Convert-PEM
view release on metacpan or search on metacpan
lib/Convert/PEM.pm view on Meta::CPAN
$pem->{ASN} = $param{ASN} if exists $param{ASN};
$pem->{Cipher} = $param{Cipher} if exists $param{Cipher};
}
if (exists $pem->{ASN}) {
$pem->{Macro} = $param{Macro};
my $asn = $pem->{_asn} = Convert::ASN1->new;
$asn->prepare( $pem->{ASN} ) or
return (ref $pem)->error("ASN prepare failed: $asn->{error}");
}
lib/Convert/PEM.pm view on Meta::CPAN
sub asn {
my $pem = shift;
my $asn = $pem->{_asn} || return;
my %prm = @_;
my $m = $prm{Macro} || $pem->{Macro};
$m ? $asn->find($m) : $asn;
}
sub ASN { $_[0]->{ASN} }
sub name { $_[0]->{Name} }
sub cipher { $_[0]->{Cipher} }
sub inform { $_[0]->{InForm} }
sub outform { $_[0]->{OutForm} }
sub macro { $_[0]->{Macro} }
sub read {
my $pem = shift;
my %param = @_;
lib/Convert/PEM.pm view on Meta::CPAN
# should always be unencrypted at this point
my $obj;
if (exists $pem->{ASN}) {
my $asn = $pem->asn;
if (my $macro = ($param{Macro} || $pem->{Macro})) {
$asn = $asn->find($macro) or
return $pem->error("Can't find Macro $macro");
}
$obj = $asn->decode( $param{DER} ) or
return $pem->error("ASN encode failed: $asn->{error}");
}
else {
lib/Convert/PEM.pm view on Meta::CPAN
my %param = @_;
my $buf;
if (exists $pem->{ASN}) {
my $asn = $pem->asn;
if (my $macro = ($param{Macro} || $pem->{Macro})) {
$asn = $asn->find($macro) or
return $pem->error("Can't find Macro $macro");
}
$buf = $asn->encode( $param{Content} ) or
return $pem->error("ASN encode failed: $asn->{error}");
}
else {
lib/Convert/PEM.pm view on Meta::CPAN
=head1 SYNOPSIS
use Convert::PEM;
my $pem = Convert::PEM->new(
Name => "DSA PRIVATE KEY",
Macro => "DSAPrivateKey",
ASN => qq(
DSAPrivateKey SEQUENCE {
version INTEGER,
p INTEGER,
q INTEGER,
lib/Convert/PEM.pm view on Meta::CPAN
An ASN.1 description of the content to be either encoded or decoded.
I<ASN> is an optional argument.
=item * Macro
If your ASN.1 description (in the I<ASN> parameter) includes more than
one ASN.1 macro definition, you will want to use the I<Macro> parameter
to specify which definition to use when encoding/decoding objects.
For example, if your ASN.1 description looks like this:
Foo ::= SEQUENCE {
x INTEGER,
lib/Convert/PEM.pm view on Meta::CPAN
}
Bar ::= INTEGER
If you want to encode/decode a C<Foo> object, you will need to tell
I<Convert::PEM> to use the C<Foo> macro definition by using the I<Macro>
parameter and setting the value to C<Foo>.
I<Macro> is an optional argument when an ASN.1 description is provided.
=item * InForm
Specify what type of file to expect when using the I<read> method. Value
may be either B<PEM> or B<DER>. Default is "PEM".
lib/Convert/PEM.pm view on Meta::CPAN
Binary string to convert to an object.
This option is required.
=item * Macro
If the object has an ASN definition, a Macro may be specified. If specified,
it will override the object's Macro if one exists.
Macro is an optional argument.
=back
=head2 $pem->to_der(%args)
lib/Convert/PEM.pm view on Meta::CPAN
=item * Content
An object to be ASN.1 encoded to a binary string.
=item * Macro
If the object has an ASN definition, a Macro may be specified. If specified,
it will override the object's Macro if one exists.
Macro is an optional argument.
=back
=head2 $pem->errstr
Convert-TBX-Basic
view release on metacpan or search on metacpan
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Every macrolanguage code element has a normative correspondence to the individual language code elements representing the individual languages encompassed by the macrolanguage.</descrip>
<admin type="source">ISO 00639-3 : 2007</admin>
<descrip type="context">Macrolanguages are distinguished from language collections in that the individual languages that correspond to a macrolanguage must be very closely related, and there must be some domain in which only a single lang...
<admin type="source">ISO 00639-3 : 2007</admin>
<descrip type="context">In some cases, a macrolanguage may have the same name as one of the individual languages that falls within its scope.</descrip>
<admin type="source">ISO 00639-3 : 2007</admin>
</tig>
</langSet>
Convert-Translit
view release on metacpan or search on metacpan
lib/Convert/rfc1345 view on Meta::CPAN
Exclamation mark ! Grave
Apostrophe ' Acute accent
Greater-Than sign > Circumflex accent
Question Mark ? tilde
Hyphen-Minus - Macron
Left parenthesis ( Breve
Full Stop . Dot Above
Colon : Diaeresis
Comma , Cedilla
Underline _ Underline
Convert-UUlib
view release on metacpan or search on metacpan
uulib/uuscan.c view on Meta::CPAN
char *uuscan_sdbhds1;
char *uuscan_sdbhds2;
char *uuscan_spline;
/*
* Macro: print cancellation message in UUScanPart
*/
#define SPCANCEL() {UUMessage(uuscan_id,__LINE__,UUMSG_NOTE,uustring(S_SCAN_CANCEL));*errcode=UURET_CANCEL;goto ScanPartEmergency;}
/*
Courier-Filter
view release on metacpan or search on metacpan
lib/Courier/Filter/Module/SPFout.pm view on Meta::CPAN
use base 'Courier::Filter::Module';
use Error ':try';
use Mail::SPF;
use Mail::SPF::MacroString;
use Mail::SPF::Util;
use Net::Address::IP::Local;
use Courier::Filter::Util qw(
ipv4_address_pattern
lib/Courier/Filter/Module/SPFout.pm view on Meta::CPAN
default_authority_explanation => $options{default_response},
%$spf_options
);
if (defined($options{force_response})) {
$options{force_response} = Mail::SPF::MacroString->new(
text => $options{force_response},
is_explanation => TRUE
);
}
Crypt-Bear
view release on metacpan or search on metacpan
src/hash/ghash_pwr8.c view on Meta::CPAN
#define BSW 8
#define XBSW 40
/*
* Macro to initialise the constants.
*/
#define INIT \
vxor(HB0, HB0, HB0) \
vspltisb(HB1, 1) \
vspltisb(HB2, 2) \
Crypt-DSA-GMP
view release on metacpan or search on metacpan
lib/Crypt/DSA/GMP/Key/PEM.pm view on Meta::CPAN
my %param = @_;
my $pem = $key->_pem;
my $pkey = $pem->decode( Content => $param{Content},
Password => $param{Password},
Macro => 'DSAPrivateKey' );
return unless $pkey;
for my $m (qw( p q g pub_key priv_key )) {
$key->$m( $pkey->{$m} );
}
lib/Crypt/DSA/GMP/Key/PEM.pm view on Meta::CPAN
my %param = @_;
my $pem = $key->_pem;
my $pkey = $pem->decode( Content => $param{Content},
Password => $param{Password},
Macro => 'DSAPublicKey',
Name => 'PUBLIC KEY' );
return unless $pkey;
my $asn = $pem->asn->find('DSAPubKeyInner');
my $num = $asn->decode($pkey->{pub_key}[0]) or croak $asn->{error};
lib/Crypt/DSA/GMP/Key/PEM.pm view on Meta::CPAN
my $pem = $key->_pem;
my $buf = $pem->encode(
Content => $pkey,
Password => $param{Password},
Name => 'DSA PRIVATE KEY',
Macro => 'DSAPrivateKey',
) or croak $pem->errstr;
$buf;
}
sub _serialize_pubkey {
lib/Crypt/DSA/GMP/Key/PEM.pm view on Meta::CPAN
};
my $buf = $pem->encode(
Content => $pkey,
Password => $param{Password},
Name => 'PUBLIC KEY',
Macro => 'DSAPublicKey',
) or return $key->error($pem->errstr);
$buf;
}
sub _pem {
Crypt-DSA
view release on metacpan or search on metacpan
lib/Crypt/DSA/Key/PEM.pm view on Meta::CPAN
my %param = @_;
my $pem = $key->_pem;
my $pkey = $pem->decode( Content => $param{Content},
Password => $param{Password},
Macro => 'DSAPrivateKey' );
return unless $pkey;
for my $m (qw( p q g pub_key priv_key )) {
$key->$m( $pkey->{$m} );
}
lib/Crypt/DSA/Key/PEM.pm view on Meta::CPAN
my %param = @_;
my $pem = $key->_pem;
my $pkey = $pem->decode( Content => $param{Content},
Password => $param{Password},
Macro => 'DSAPublicKey',
Name => 'PUBLIC KEY' );
return unless $pkey;
my $asn = $pem->asn->find('DSAPubKeyInner');
my $num = $asn->decode($pkey->{pub_key}[0]) or croak $asn->{error};
lib/Crypt/DSA/Key/PEM.pm view on Meta::CPAN
my $pem = $key->_pem;
my $buf = $pem->encode(
Content => $pkey,
Password => $param{Password},
Name => 'DSA PRIVATE KEY',
Macro => 'DSAPrivateKey',
) or croak $pem->errstr;
$buf;
}
sub _serialize_pubkey {
lib/Crypt/DSA/Key/PEM.pm view on Meta::CPAN
};
my $buf = $pem->encode(
Content => $pkey,
Password => $param{Password},
Name => 'PUBLIC KEY',
Macro => 'DSAPublicKey',
) or return $key->error($pem->errstr);
$buf;
}
sub _pem {
Crypt-HC128
view release on metacpan or search on metacpan
hc128_wrap.c view on Meta::CPAN
#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
/* SWIG Perl macros */
/* Macro to declare an XS function */
#ifndef XSPROTO
# define XSPROTO(name) void name(pTHX_ CV* cv)
#endif
/* Macro to call an XS function */
#ifdef PERL_OBJECT
# define SWIG_CALLXS(_name) _name(cv,pPerl)
#else
# ifndef MULTIPLICITY
# define SWIG_CALLXS(_name) _name(cv)
hc128_wrap.c view on Meta::CPAN
}
return SWIG_OK;
}
/* Macros for low-level exception handling */
#define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
typedef XSPROTO(SwigPerlWrapper);
typedef SwigPerlWrapper *SwigPerlWrapperPtr;
Crypt-Komihash
view release on metacpan or search on metacpan
lib/Crypt/komihash.h view on Meta::CPAN
#endif // defined( __BIG_ENDIAN__ )
#endif // !defined( KOMIHASH_LITTLE_ENDIAN )
/**
* @def KOMIHASH_GCC_BUILTINS
* @brief Macro that denotes availability of GCC-style built-in functions.
*/
#if defined( __GNUC__ ) || defined( __clang__ ) || \
defined( __IBMC__ ) || defined( __IBMCPP__ ) || defined( __COMPCERT__ )
lib/Crypt/komihash.h view on Meta::CPAN
#endif // GCC built-ins check
/**
* @def KOMIHASH_EC32( v )
* @brief Macro that appies 32-bit byte-swapping, for endianness-correction.
* @param v Value to byte-swap.
*/
/**
* @def KOMIHASH_EC64( v )
* @brief Macro that appies 64-bit byte-swapping, for endianness-correction.
* @param v Value to byte-swap.
*/
#if KOMIHASH_LITTLE_ENDIAN
lib/Crypt/komihash.h view on Meta::CPAN
#define KOMIHASH_PREFETCH_2( a ) KOMIHASH_PREFETCH( a )
#endif // defined( __clang__ )
/**
* @def KOMIHASH_INLINE
* @brief Macro to force code inlining.
*/
#if defined( KOMIHASH_GCC_BUILTINS )
#define KOMIHASH_INLINE inline __attribute__((always_inline))
lib/Crypt/komihash.h view on Meta::CPAN
* 128-bit result.
*/
/**
* @def KOMIHASH_EMULU( u, v )
* @brief Macro for 32-bit by 32-bit unsigned multiplication with 64-bit
* result.
* @param u Multiplier 1.
* @param v Multiplier 2.
*/
lib/Crypt/komihash.h view on Meta::CPAN
#endif // defined( __IBMC__ )
/**
* @def KOMIHASH_HASHROUND()
* @brief Macro for a common hashing round without input.
*
* The three instructions in this macro (multiply, add, and XOR) represent the
* simplest constantless PRNG, scalable to any even-sized state variables,
* with the `Seed1` being the PRNG output (2^64 PRNG period). It passes
* `PractRand` tests with rare non-systematic "unusual" evaluations.
lib/Crypt/komihash.h view on Meta::CPAN
kh_m128( Seed1, Seed5, &Seed1, &Seed5 ); \
Seed1 ^= Seed5;
/**
* @def KOMIHASH_HASH16( m )
* @brief Macro for a common hashing round with 16-byte input.
* @param m Message pointer, alignment is unimportant.
*/
#define KOMIHASH_HASH16( m ) \
kh_m128( Seed1 ^ kh_lu64ec( m ), \
Seed5 ^ kh_lu64ec( m + 8 ), &Seed1, &Seed5 ); \
Seed1 ^= Seed5;
/**
* @def KOMIHASH_HASHFIN()
* @brief Macro for common hashing finalization round.
*
* The final hashing input is expected in the `r1h` and `r2h` temporary
* variables. The macro inserts the function return instruction.
*/
lib/Crypt/komihash.h view on Meta::CPAN
KOMIHASH_HASHROUND(); \
return( Seed1 );
/**
* @def KOMIHASH_HASHLOOP64()
* @brief Macro for a common 64-byte full-performance hashing loop.
*
* Expects `Msg` and `MsgLen` values (greater than 63), requires initialized
* `Seed1-8` values.
*
* The "shifting" arrangement of `Seed1-4` XORs (below) does not increase
Crypt-Noekeon
view release on metacpan or search on metacpan
* modifications brought by Michael Peeters
*
* References : [NESSIE] see http://cryptonessie.org/ for information about
* interface conventions and definition of portable C.
*
* Description: Macro definitions useful for portability
* Data structures used for NOEKEON
*
* Modif. : Minor bugs in U8TO32_BIG & U8TO32_LITTLE,
* data structures for Noekeon
****************************************************************************/
Crypt-OpenSSL-Blowfish
view release on metacpan or search on metacpan
Blowfish.xs view on Meta::CPAN
#include "hexdump.xs"
#endif
/*==================================================*/
/* */
/* Macro to swap from little endian to big endian */
/* */
/*==================================================*/
# undef n2l
# define n2l(c,l) (l =((unsigned long)(*((c)++)))<<24L, \
l|=((unsigned long)(*((c)++)))<<16L, \
l|=((unsigned long)(*((c)++)))<< 8L, \
l|=((unsigned long)(*((c)++))))
/*==================================================*/
/* */
/* Macro to swap from big endian to little endian */
/* */
/*==================================================*/
# undef l2n
# define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \
*((c)++)=(unsigned char)(((l)>>16L)&0xff), \
( run in 0.797 second using v1.01-cache-2.11-cpan-1236ad508bc )