package ExtUtils::Constant;
use vars qw (@ISA $VERSION %XS_Constant %XS_TypeSet @EXPORT_OK %EXPORT_TAGS);
-$VERSION = '0.10';
+$VERSION = '0.12';
=head1 NAME
WriteConstants(
NAME => 'Foo',
NAMES => [qw(FOO BAR BAZ)],
- C_FILE => 'constants.c',
- XS_FILE => 'constants.xs',
);
# Generates wrapper code to make the values of the constants FOO BAR BAZ
# available to perl
Generally one only needs to call the C<WriteConstants> function, and then
- #include "constants.c"
+ #include "const-c.inc"
in the C section of C<Foo.xs>
- INCLUDE constants.xs
+ INCLUDE const-xs.inc
in the XS section of C<Foo.xs>.
@EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+# '' is used as a flag to indicate non-ascii macro names, and hence the need
+# to pass in the utf8 on/off flag.
%XS_Constant = (
+ '' => '',
IV => 'PUSHi(iv)',
UV => 'PUSHu((UV)iv)',
NV => 'PUSHn(nv)',
=item C_stringify NAME
-A function which returns a correctly \ escaped version of the string passed
-suitable for C's "" or ''. It will also be valid as a perl "" string.
+A function which returns a 7 bit ASCII correctly \ escaped version of the
+string passed suitable for C's "" or ''. It will die if passed Unicode
+characters.
=cut
sub C_stringify {
local $_ = shift;
return unless defined $_;
+ confess "Wide character in '$_' intended as a C identifier" if tr/\0-\377//c;
s/\\/\\\\/g;
s/([\"\'])/\\$1/g; # Grr. fix perl mode.
s/\n/\\n/g; # Ensure newlines don't end up in octal
s/\t/\\t/g;
s/\f/\\f/g;
s/\a/\\a/g;
+ s/([^\0-\177])/sprintf "\\%03o", ord $1/ge;
unless ($] < 5.006) {
- # This will elict a warning on 5.005_03 about [: :] being reserved unless
+ # This will elicit a warning on 5.005_03 about [: :] being reserved unless
+ # I cheat
+ my $cheat = '([[:^print:]])';
+ s/$cheat/sprintf "\\%03o", ord $1/ge;
+ } else {
+ require POSIX;
+ s/([^A-Za-z0-9_])/POSIX::isprint($1) ? $1 : sprintf "\\%03o", ord $1/ge;
+ }
+ $_;
+}
+
+=item perl_stringify NAME
+
+A function which returns a 7 bit ASCII correctly \ escaped version of the
+string passed suitable for a perl "" string.
+
+=cut
+
+# Hopefully make a happy perl identifier.
+sub perl_stringify {
+ local $_ = shift;
+ return unless defined $_;
+ s/\\/\\\\/g;
+ s/([\"\'])/\\$1/g; # Grr. fix perl mode.
+ s/\n/\\n/g; # Ensure newlines don't end up in octal
+ s/\r/\\r/g;
+ s/\t/\\t/g;
+ s/\f/\\f/g;
+ s/\a/\\a/g;
+ s/([^\0-\177])/sprintf "\\x{%X}", ord $1/ge;
+ unless ($] < 5.006) {
+ # This will elicit a warning on 5.005_03 about [: :] being reserved unless
# I cheat
my $cheat = '([[:^print:]])';
s/$cheat/sprintf "\\%03o", ord $1/ge;
push @lines, "#define PERL_constant_NOTFOUND\t$start\n"; $start++;
push @lines, "#define PERL_constant_NOTDEF\t$start\n"; $start++;
foreach (sort keys %XS_Constant) {
+ next if $_ eq '';
push @lines, "#define PERL_constant_IS$_\t$start\n"; $start++;
}
push @lines, << 'EOT';
A function to return a suitable assignment clause. If I<TYPE> is aggregate
(eg I<PVN> expects both pointer and length) then there should be multiple
I<VALUE>s for the components. I<PRE> and I<POST> if defined give snippets
-of C code to preceed and follow the assignment. I<PRE> will be at the start
+of C code to proceed and follow the assignment. I<PRE> will be at the start
of a block, so variables may be defined in it.
=cut
$close = "$indent}\n";
$indent .= " ";
}
- die "Can't generate code for type $type" unless exists $XS_TypeSet{$type};
+ confess "undef \$type" unless defined $type;
+ confess "Can't generate code for type $type" unless exists $XS_TypeSet{$type};
my $typeset = $XS_TypeSet{$type};
if (ref $typeset) {
die "Type $type is aggregate, but only single value given"
=item return_clause
-return_clause VALUE, TYPE, INDENT, MACRO, DEFAULT, PRE, POST, PRE, POST
+return_clause ITEM, INDENT
-A function to return a suitable C<#ifdef> clause. I<MACRO> defaults to
-I<VALUE> when not defined. If I<TYPE> is aggregate (eg I<PVN> expects both
-pointer and length) then I<VALUE> should be a reference to an array of
-values in the order expected by the type. C<C_constant> will always call
-this function with I<MACRO> defined, defaulting to the constant's name.
-I<DEFAULT> if defined is an array reference giving default type and and
-value(s) if the clause generated by I<MACRO> doesn't evaluate to true.
-The two pairs I<PRE> and I<POST> if defined give C code snippets to proceed
-and follow the value, and the default value.
+A function to return a suitable C<#ifdef> clause. I<ITEM> is a hashref
+(as passed to C<C_constant> and C<match_clause>. I<INDENT> is the number
+of spaces to indent, defaulting to 6.
=cut
-sub return_clause ($$$$$$$$$) {
+sub return_clause ($$) {
##ifdef thingy
# *iv_return = thingy;
# return PERL_constant_ISIV;
##else
# return PERL_constant_NOTDEF;
##endif
- my ($value, $type, $indent, $macro, $default, $pre, $post,
- $def_pre, $def_post) = @_;
+ my ($item, $indent) = @_;
+
+ my ($name, $value, $macro, $default, $pre, $post, $def_pre, $def_post, $type)
+ = @$item{qw (name value macro default pre post def_pre def_post type)};
+ $value = $name unless defined $value;
+ $macro = $name unless defined $macro;
+
$macro = $value unless defined $macro;
$indent = ' ' x ($indent || 6);
+ unless ($type) {
+ # use Data::Dumper; print STDERR Dumper ($item);
+ confess "undef \$type";
+ }
my $clause;
$clause .= "#endif\n";
}
}
- return $clause
+ return $clause;
+}
+
+=pod
+
+XXX document me
+
+=cut
+
+sub match_clause {
+ # $offset defined if we have checked an offset.
+ my ($item, $offset, $indent) = @_;
+ $indent = ' ' x ($indent || 4);
+ my $body = '';
+ my ($no, $yes, $either, $name, $inner_indent);
+ if (ref $item eq 'ARRAY') {
+ ($yes, $no) = @$item;
+ $either = $yes || $no;
+ confess "$item is $either expecting hashref in [0] || [1]"
+ unless ref $either eq 'HASH';
+ $name = $either->{name};
+ } else {
+ confess "$item->{name} has utf8 flag '$item->{utf8}', should be false"
+ if $item->{utf8};
+ $name = $item->{name};
+ $inner_indent = $indent;
+ }
+
+ $body .= memEQ_clause ($name, $offset, length $indent);
+ if ($yes) {
+ $body .= $indent . " if (utf8) {\n";
+ } elsif ($no) {
+ $body .= $indent . " if (!utf8) {\n";
+ }
+ if ($either) {
+ $body .= return_clause ($either, 4 + length $indent);
+ if ($yes and $no) {
+ $body .= $indent . " } else {\n";
+ $body .= return_clause ($no, 4 + length $indent);
+ }
+ $body .= $indent . " }";
+ } else {
+ $body .= return_clause ($item, 2 + length $indent);
+ }
+ $body .= $indent . "}\n";
}
=item switch_clause INDENT, NAMELEN, ITEMHASH, ITEM...
$body = wrap ($leader, $follower, $comment) . "\n";
$leader = $follower;
}
- $body .= wrap ($leader, $follower, join (" ", @names) . " */") . "\n";
+ my @safe_names = @names;
+ foreach (@safe_names) {
+ next unless tr/A-Za-z0-9_//c;
+ $_ = '"' . perl_stringify ($_) . '"';
+ # Ensure that the enclosing C comment doesn't end
+ # by turning */ into *" . "/
+ s!\*\/!\*"."/!gs;
+ # gcc -Wall doesn't like finding /* inside a comment
+ s!\/\*!/"."\*!gs;
+ }
+ $body .= wrap ($leader, $follower, join (" ", @safe_names) . " */") . "\n";
# Figure out what to switch on.
# (RMS, Spread of jump table, Position, Hashref)
my @best = (1e38, ~0);
$body .= $indent . "case '" . C_stringify ($char) . "':\n";
foreach my $name (sort @{$best->{$char}}) {
my $thisone = $items->{$name};
- my ($value, $macro, $default, $pre, $post, $def_pre, $def_post)
- = @$thisone{qw (value macro default pre post def_pre def_post)};
- $value = $name unless defined $value;
- $macro = $name unless defined $macro;
-
- # We have checked this offset.
- $body .= memEQ_clause ($name, $offset, 2 + length $indent);
- $body .= return_clause ($value, $thisone->{type}, 4 + length $indent,
- $macro, $default, $pre, $post,
- $def_pre, $def_post);
- $body .= $indent . " }\n";
+ # warn "You are here";
+ $body .= match_clause ($thisone, $offset, 2 + length $indent);
}
$body .= $indent . " break;\n";
}
warn "ExtUtils::Constant doesn't know how to handle values of type $_" unless defined $XS_Constant{$_};
}
my $params = {};
+ $params->{''} = 1 if $what->{''};
$params->{IV} = 1 if $what->{IV} || $what->{UV} || $what->{PVN};
$params->{NV} = 1 if $what->{NV};
$params->{PV} = 1 if $what->{PV} || $what->{PVN};
my $type;
if (ref $_) {
$type = $_->{type} || $default_type;
+ if ($_->{utf8}) {
+ # For simplicity always skip the bytes case, and reconstitute this entry
+ # from its utf8 twin.
+ next if $_->{utf8} eq 'no';
+ # Copy the hashref, as we don't want to mess with the caller's hashref.
+ $_ = {%$_};
+ utf8::decode ($_->{name});
+ delete $_->{utf8};
+ }
} else {
$_ = {name=>$_};
$type = $default_type;
$indent . " ", join (" ", sort @simple) . ")");
if (@complex) {
foreach my $item (sort {$a->{name} cmp $b->{name}} @complex) {
- my $name = C_stringify $item->{name};
+ my $name = perl_stringify $item->{name};
my $line = ",\n$indent {name=>\"$name\"";
$line .= ", type=>\"$item->{type}\"" if defined $item->{type};
foreach my $thing (qw (macro value default pre post def_pre def_post)) {
if (defined $value) {
if (ref $value) {
$line .= ", $thing=>[\""
- . join ('", "', map {C_stringify $_} @$value) . '"]';
+ . join ('", "', map {perl_stringify $_} @$value) . '"]';
} else {
- $line .= ", $thing=>\"" . C_stringify($value) . "\"";
+ $line .= ", $thing=>\"" . perl_stringify($value) . "\"";
}
}
}
print constant_types(); # macro defs
EOT
- $package = C_stringify($package);
+ $package = perl_stringify($package);
$result .=
"foreach (C_constant (\"$package\", '$subname', '$default_type', \$types, ";
# The form of the indent parameter isn't defined. (Yet)
Equivalents of I<pre> and I<post> for the default value.
+=item utf8
+
+Generated internally. Is zero or undefined if name is 7 bit ASCII,
+"no" if the name is 8 bit (and so should only match if SvUTF8() is false),
+"yes" if the name is utf8 encoded.
+
+The internals automatically clone any name with characters 128-255 but none
+256+ (ie one that could be either in bytes or utf8) into a second entry
+which is utf8 encoded.
+
=back
I<PACKAGE> is the name of the package, and is only used in comments inside the
# Figure out what types we're dealing with, and assign all unknowns to the
# default type
}
- foreach (@items) {
- my $name;
- if (ref $_) {
- my $orig = $_;
+ my @new_items;
+ foreach my $orig (@items) {
+ my ($name, $item);
+ if (ref $orig) {
# Make a copy which is a normalised version of the ref passed in.
- $name = $_->{name};
- my ($type, $macro, $value) = @$_{qw (type macro value)};
+ $name = $orig->{name};
+ my ($type, $macro, $value) = @$orig{qw (type macro value)};
$type ||= $default_type;
$what->{$type} = 1;
- $_ = {name=>$name, type=>$type};
+ $item = {name=>$name, type=>$type};
undef $macro if defined $macro and $macro eq $name;
- $_->{macro} = $macro if defined $macro;
+ $item->{macro} = $macro if defined $macro;
undef $value if defined $value and $value eq $name;
- $_->{value} = $value if defined $value;
+ $item->{value} = $value if defined $value;
foreach my $key (qw(default pre post def_pre def_post)) {
my $value = $orig->{$key};
- $_->{$key} = $value if defined $value;
+ $item->{$key} = $value if defined $value;
# warn "$key $value";
}
} else {
- $name = $_;
- $_ = {name=>$_, type=>$default_type};
+ $name = $orig;
+ $item = {name=>$name, type=>$default_type};
$what->{$default_type} = 1;
}
- warn "ExtUtils::Constant doesn't know how to handle values of type $_ used in macro $name" unless defined $XS_Constant{$_->{type}};
- if (exists $items->{$name}) {
- die "Multiple definitions for macro $name";
+ warn "ExtUtils::Constant doesn't know how to handle values of type $_ used in macro $name" unless defined $XS_Constant{$item->{type}};
+ if ($name !~ tr/\0-\177//c) {
+ # No characters outside 7 bit ASCII.
+ if (exists $items->{$name}) {
+ die "Multiple definitions for macro $name";
+ }
+ $items->{$name} = $item;
+ } else {
+ # No characters outside 8 bit. This is hardest.
+ if (exists $items->{$name} and ref $items->{$name} ne 'ARRAY') {
+ confess "Unexpected ASCII definition for macro $name";
+ }
+ if ($name !~ tr/\0-\377//c) {
+ $item->{utf8} = 'no';
+ $items->{$name}[1] = $item;
+ push @new_items, $item;
+ # Copy item, to create the utf8 variant.
+ $item = {%$item};
+ }
+ # Encode the name as utf8 bytes.
+ utf8::encode($name);
+ if ($items->{$name}[0]) {
+ die "Multiple definitions for macro $name";
+ }
+ $item->{utf8} = 'yes';
+ $item->{name} = $name;
+ $items->{$name}[0] = $item;
+ # We have need for the utf8 flag.
+ $what->{''} = 1;
}
- $items->{$name} = $_;
+ push @new_items, $item;
}
+ @items = @new_items;
+ # use Data::Dumper; print Dumper @items;
}
my $params = params ($what);
my ($body, @subs) = "static int\n$subname (pTHX_ const char *name";
$body .= ", STRLEN len" unless defined $namelen;
+ $body .= ", int utf8" if $params->{''};
$body .= ", IV *iv_return" if $params->{IV};
$body .= ", NV *nv_return" if $params->{NV};
$body .= ", const char **pv_return" if $params->{PV};
next unless $by_length[$i]; # None of this length
$body .= " case $i:\n";
if (@{$by_length[$i]} == 1) {
- my $thisone = $by_length[$i]->[0];
- my ($name, $value, $macro, $default, $pre, $post, $def_pre, $def_post)
- = @$thisone{qw (name value macro default pre post def_pre def_post)};
- $value = $name unless defined $value;
- $macro = $name unless defined $macro;
-
- $body .= memEQ_clause ($name);
- $body .= return_clause ($value, $thisone->{type}, undef, $macro,
- $default, $pre, $post, $def_pre, $def_post);
- $body .= " }\n";
+ $body .= match_clause ($by_length[$i]->[0]);
} elsif (@{$by_length[$i]} < $breakout) {
$body .= switch_clause (4, '', $i, $items, @{$by_length[$i]});
} else {
my $what = {};
foreach (@{$by_length[$i]}) {
$what->{$_->{type}} = 1;
+ $what->{''} = 1 if $_->{utf8};
}
$params = params ($what);
push @subs, C_constant ($package, "${subname}_$i", $default_type, $what,
$indent, [$i, $items], @{$by_length[$i]});
$body .= " return ${subname}_$i (aTHX_ name";
+ $body .= ", utf8" if $params->{''};
$body .= ", iv_return" if $params->{IV};
$body .= ", nv_return" if $params->{NV};
$body .= ", pv_return" if $params->{PV};
the number of parameters passed to the C function C<constant>]
You can call the perl visible subroutine something other than C<constant> if
-you give the parameter I<SUBNAME>. The C subroutine it calls defaults to the
+you give the parameter I<SUBNAME>. The C subroutine it calls defaults to
the name of the perl visible subroutine, unless you give the parameter
I<C_SUBNAME>.
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
+EOT
+ if ($params->{''}) {
+ $xs .= << 'EOT';
+ INPUT:
+ int utf8 = SvUTF8(sv);
+EOT
+ }
+ $xs .= << 'EOT';
PPCODE:
EOT
EOT
}
$xs .= " type = $C_subname(aTHX_ s, len";
+ $xs .= ', utf8' if $params->{''};
$xs .= ', &iv' if $params->{IV};
$xs .= ', &nv' if $params->{NV};
$xs .= ', &pv' if $params->{PV};
EOT
foreach $type (sort keys %XS_Constant) {
+ # '' marks utf8 flag needed.
+ next if $type eq '';
$xs .= "\t/* Uncomment this if you need to return ${type}s\n"
unless $what->{$type};
$xs .= " case PERL_constant_IS$type:\n";
WriteMakefileSnippet ATTRIBUTE =E<gt> VALUE [, ...]
-An function to generate perl code for Makefile.PL that will regenerate
+A function to generate perl code for Makefile.PL that will regenerate
the constant subroutines. Parameters are named as passed to C<WriteConstants>,
with the addition of C<INDENT> to specify the number of leading spaces
(default 2).
=item C_FILE
The name of the file to write containing the C code. The default is
-C<constants.c>.
+C<const-c.inc>. The C<-> in the name ensures that the file can't be
+mistaken for anything related to a legitimate perl package name, and
+not naming the file C<.c> avoids having to override Makefile.PL's
+C<.xs> to C<.c> rules.
=item XS_FILE
The name of the file to write containing the XS code. The default is
-C<constants.xs>.
+C<const-xs.inc>.
=item SUBNAME
sub WriteConstants {
my %ARGS =
( # defaults
- C_FILE => 'constants.c',
- XS_FILE => 'constants.xs',
+ C_FILE => 'const-c.inc',
+ XS_FILE => 'const-xs.inc',
SUBNAME => 'constant',
DEFAULT_TYPE => 'IV',
@_);
projects / p5sagit/p5-mst-13.2.git / blobdiff