xsubpp revision 7c478bd95313f5f23a4c958a745db2134aa03244
#!./miniperl
B<xsubpp> [B<-v>] [B<-C++>] [B<-except>] [B<-s pattern>] [B<-prototypes>] [B<-noversioncheck>] [B<-nolinenumbers>] [B<-nooptimize>] [B<-typemap typemap>] ... file.xs
=over 5
=item B<-C++>
=item B<-v>
=item B<-prototypes>
=item B<-noversioncheck>
=item B<-nolinenumbers>
=item B<-nooptimize>
Disable recognition of C<IN>, C<OUT_LIST> and C<INOUT_LIST> declarations.
=item B<-noargtypes>
Disable recognition of ANSI-like descriptions of function signature.
=back
See the file F<changes.pod>.
=cut
require 5.002;
use Cwd;
use Config;
sub Q ;
# Global Constants
$Is_VMS = 1;
# Establish set of global symbols with max length 28, since xsubpp
# will later add the 'XS_' prefix.
}
$usage = "Usage: xsubpp [-v] [-C++] [-except] [-prototypes] [-noversioncheck] [-nolinenumbers] [-nooptimize] [-noinout] [-noargtypes] [-s pattern] [-typemap typemap]... file.xs\n";
# mjn
$WantPrototypes = -1 ;
$WantVersionChk = 1 ;
$ProtoUsed = 0 ;
$WantLineNumbers = 1 ;
$WantOptimize = 1 ;
my $process_inout = 1;
my $process_argtypes = 1;
$flag =~ s/^-// ;
# XXX left this in for compat
}
if ($WantPrototypes == -1)
{ $WantPrototypes = 0}
else
{ $ProtoUsed = 1 }
++ $IncludedFiles{$ARGV[0]} ;
sub TrimWhitespace
{
$_[0] =~ s/^\s+|\s+$//go ;
}
sub TidyType
{
local ($_) = @_ ;
# rationalise any '*' by joining them into bunches and removing whitespace
s#\s*(\*+)\s*#$1#g;
s#(\*+)# $1 #g ;
# change multiple whitespace into a single space
s/\s+/ /g ;
# trim leading & trailing whitespace
$_ ;
}
}
# skip directories, binary files etc.
next if /^\s*#/;
my $line_no = $. + 1;
my $line = $_ ;
# skip blank lines and comment lines
next if /^$/ or /^#/ ;
$type_kind{$type} = $kind ;
# prototype defaults to '$'
}
elsif (/^\s/) {
$$current .= $_;
}
s/\s+$//;
$current = \$input_expr{$_};
}
else {
s/\s+$//;
$current = \$output_expr{$_};
}
}
}
$input_expr{$key} =~ s/\n+$//;
}
($output_expr{$key} =~
\) \s* ; \s* $
]x);
$targetable{$key} = [$t, $with_size, $arg, $sarg] if $t;
}
# Match an XS keyword
# Input: ($_, @line) == unparsed input.
# Output: ($_, @line) == (rest of line, following lines).
# Return: the matched keyword if found, otherwise 0
sub check_keyword {
s/^(\s*)($_[0])\s*:\s*(?:#.*)?/$1/s && $2;
}
# Group in C (no support for comments or literals)
$C_group_rex = qr/ [({\[]
[)}\]] /x ;
# Chunk in C without comma at toplevel (no comments):
| (??{ $C_group_rex })
| " (?: (?> [^\\"]+ )
| \\.
)* " # String literal
| ' (?: (?> [^\\']+ ) | \\. )* ' # Char literal
)* /xs;
{
sub TIEHANDLE {
$line_no = 1;
}
sub PRINT {
my $self = shift;
for (@_) {
$$self .= $_;
my $line = $1;
++ $line_no;
}
}
}
sub PRINTF {
my $self = shift;
my $fmt = shift;
}
sub DESTROY {
# Not necessary if we're careful to end with a "\n"
my $self = shift;
}
}
select PSEUDO_STDOUT;
}
sub print_section {
# the "do" is required for right semantics
if $WantLineNumbers && !/^\s*#\s*line\b/ && !/^#if XSubPPtmp/;
print "$_\n";
}
}
sub merge_section {
}
}
return $in;
}
sub process_keyword($)
{
my $kwd ;
&{"${kwd}_handler"}()
}
sub CASE_handler {
$cond = $_;
TrimWhitespace($cond);
$_ = '' ;
}
sub INPUT_handler {
for (; !/^$BLOCK_re/o; $_ = shift(@line)) {
last if /^\s*NOT_IMPLEMENTED_YET/;
next unless /\S/; # skip blank lines
TrimWhitespace($_) ;
my $line = $_ ;
# remove trailing semicolon if no initialisation
s/\s*;$//g unless /[=;+].*\S/ ;
# check for optional initialisation code
my $var_init = '' ;
$var_init = $1 if s/\s*([=;+].*)$//s ;
s/\s+/ /g;
# Check for duplicate definitions
or defined $arg_types{$var_name} and not $processing_arg_with_types;
# XXXX This check is a safeguard against the unfinished conversion of
# generate_init(). When generate_init() is fixed,
# one can use 2-args map_type() unconditionally.
if ($var_type =~ / \( \s* \* \s* \) /x) {
# Function pointers are not yet supported with &output_init!
$name_printed = 1;
} else {
$name_printed = 0;
}
$proto_arg[$var_num] = ProtoString($var_type)
if $var_num ;
$func_args =~ s/\b($var_name)\b/&$1/ if $var_addr;
if ($var_init =~ /^[=;]\s*NO_INIT\s*;?\s*$/
and $var_init !~ /\S/) {
if ($name_printed) {
print ";\n";
} else {
}
} elsif ($var_init =~ /\S/) {
&output_init($var_type, $var_num, $var_name, $var_init, $name_printed);
} elsif ($var_num) {
# generate initialization code
&generate_init($var_type, $var_num, $var_name, $name_printed);
} else {
print ";\n";
}
}
}
sub OUTPUT_handler {
for (; !/^$BLOCK_re/o; $_ = shift(@line)) {
next unless /\S/;
if (/^\s*SETMAGIC\s*:\s*(ENABLE|DISABLE)\s*/) {
next;
}
if (!$gotRETVAL and $outarg eq 'RETVAL') {
# deal with RETVAL last
$RETVAL_code = $outcode ;
$gotRETVAL = 1 ;
next ;
}
unless defined($args_match{$outarg});
unless defined $var_types{$outarg} ;
if ($outcode) {
} else {
&generate_output($var_types{$outarg}, $var_num, $outarg, $DoSetMagic);
}
}
}
sub C_ARGS_handler() {
my $in = merge_section();
TrimWhitespace($in);
$func_args = $in;
}
sub INTERFACE_MACRO_handler() {
my $in = merge_section();
TrimWhitespace($in);
if ($in =~ /\s/) { # two
($interface_macro, $interface_macro_set) = split ' ', $in;
} else {
$interface_macro_set = 'UNKNOWN_CVT'; # catch later
}
$interface = 1; # local
$Interfaces = 1; # global
}
sub INTERFACE_handler() {
my $in = merge_section();
TrimWhitespace($in);
foreach (split /[\s,]+/, $in) {
$Interfaces{$_} = $_;
}
# XSFUNCTION = $interface_macro($ret_type,cv,XSANY.any_dptr);
EOF
$interface = 1; # local
$Interfaces = 1; # global
}
sub CLEANUP_handler() { print_section() }
sub PREINIT_handler() { print_section() }
sub POSTCALL_handler() { print_section() }
sub INIT_handler() { print_section() }
sub GetAliases
{
my ($line) = @_ ;
my ($alias) ;
my ($value) ;
# Parse alias definitions
# format is
# alias = value alias = value ...
while ($line =~ s/^\s*([\w:]+)\s*=\s*(\w+)\s*//) {
$alias = $1 ;
$orig_alias = $alias ;
$value = $2 ;
# check for optional package definition in the alias
$alias = $Packprefix . $alias if $alias !~ /::/ ;
# check for duplicate alias name & duplicate value
if defined $XsubAliases{$alias} ;
if $XsubAliasValues{$value} ;
$XsubAliases = 1;
$XsubAliases{$alias} = $value ;
}
if $line ;
}
sub ATTRS_handler ()
{
for (; !/^$BLOCK_re/o; $_ = shift(@line)) {
next unless /\S/;
TrimWhitespace($_) ;
push @Attributes, $_;
}
}
sub ALIAS_handler ()
{
for (; !/^$BLOCK_re/o; $_ = shift(@line)) {
next unless /\S/;
TrimWhitespace($_) ;
GetAliases($_) if $_ ;
}
}
sub REQUIRE_handler ()
{
# the rest of the current line should contain a version number
my ($Ver) = $_ ;
TrimWhitespace($Ver) ;
unless $Ver ;
# check that the version number is of the form n.n
unless $Ver =~ /^\d+(\.\d*)?/ ;
unless $XSUBPP_version >= $Ver ;
}
sub VERSIONCHECK_handler ()
{
# the rest of the current line should contain either ENABLE or
# DISABLE
TrimWhitespace($_) ;
unless /^(ENABLE|DISABLE)/i ;
$WantVersionChk = 1 if $1 eq 'ENABLE' ;
$WantVersionChk = 0 if $1 eq 'DISABLE' ;
}
sub PROTOTYPE_handler ()
{
my $specified ;
if $proto_in_this_xsub ++ ;
for (; !/^$BLOCK_re/o; $_ = shift(@line)) {
next unless /\S/;
$specified = 1 ;
TrimWhitespace($_) ;
if ($_ eq 'DISABLE') {
$ProtoThisXSUB = 0
}
elsif ($_ eq 'ENABLE') {
$ProtoThisXSUB = 1
}
else {
# remove any whitespace
s/\s+//g ;
unless ValidProtoString($_) ;
$ProtoThisXSUB = C_string($_) ;
}
}
# If no prototype specified, then assume empty prototype ""
$ProtoThisXSUB = 2 unless $specified ;
$ProtoUsed = 1 ;
}
sub SCOPE_handler ()
{
if $scope_in_this_xsub ++ ;
for (; !/^$BLOCK_re/o; $_ = shift(@line)) {
next unless /\S/;
TrimWhitespace($_) ;
if ($_ =~ /^DISABLE/i) {
$ScopeThisXSUB = 0
}
elsif ($_ =~ /^ENABLE/i) {
$ScopeThisXSUB = 1
}
}
}
sub PROTOTYPES_handler ()
{
# the rest of the current line should contain either ENABLE or
# DISABLE
TrimWhitespace($_) ;
unless /^(ENABLE|DISABLE)/i ;
$WantPrototypes = 1 if $1 eq 'ENABLE' ;
$WantPrototypes = 0 if $1 eq 'DISABLE' ;
$ProtoUsed = 1 ;
}
sub INCLUDE_handler ()
{
# the rest of the current line should contain a valid filename
TrimWhitespace($_) ;
unless $_ ;
if /^\s*\|/ ;
# simple minded recursion detector
if $IncludedFiles{$_} ;
++ $IncludedFiles{$_} unless /\|\s*$/ ;
# Save the current file context.
push(@XSStack, {
type => 'file',
LastLine => $lastline,
LastLineNo => $lastline_no,
Line => \@line,
LineNo => \@line_no,
Filename => $filename,
Handle => $FH,
}) ;
++ $FH ;
# open the new file
#
#/* INCLUDE: Including '$_' from '$filename' */
#
EOF
$filename = $_ ;
# Prime the pump by reading the first
# non-blank line
# skip leading blank lines
while (<$FH>) {
last unless /^\s*$/ ;
}
$lastline = $_ ;
$lastline_no = $. ;
}
sub PopFile()
{
return 0 unless $XSStack[-1]{type} eq 'file' ;
my $data = pop @XSStack ;
unless $isPipe ;
close $FH ;
$lastline_no = $data->{LastLineNo} ;
@line = @{ $data->{Line} } ;
@line_no = @{ $data->{LineNo} } ;
if ($isPipe and $? ) {
-- $lastline_no ;
exit 1 ;
}
#
#
EOF
return 1 ;
}
sub ValidProtoString ($)
{
my($string) = @_ ;
return $string ;
}
return 0 ;
}
sub C_string ($)
{
my($string) = @_ ;
$string =~ s[\\][\\\\]g ;
$string ;
}
sub ProtoString ($)
{
my ($type) = @_ ;
}
sub check_cpp {
my @cpp = grep(/^\#\s*(?:if|e\w+)/, @line);
if (@cpp) {
for $cpp (@cpp) {
if ($cpp =~ /^\#\s*if/) {
$cpplevel++;
} elsif (!$cpplevel) {
print STDERR " (precede it with a blank line if the matching #if is outside the function)\n"
return;
$cpplevel--;
}
}
}
}
sub Q {
$text =~ s/^#//gm;
$text =~ s/\[\[/{/g;
$text =~ s/\]\]/}/g;
}
# Identify the version of xsubpp used
print <<EOM ;
/*
* This file was generated automatically by xsubpp version $XSUBPP_version from the
* contents of $filename. Do not edit this file, edit $filename instead.
*
* ANY CHANGES MADE HERE WILL BE LOST!
*
*/
EOM
if $WantLineNumbers;
if (/^=/) {
my $podstartline = $.;
do {
print("/* Skipped embedded POD. */\n");
if $WantLineNumbers;
next firstmodule
}
# At this point $. is at end of file so die won't state the start
# of the problem, and as we haven't yet read any lines &death won't
# show the correct line in the message either.
}
s/#if(?:def\s|\s+defined)\s*(\(__cplusplus\)|__cplusplus)/#if defined(__cplusplus) && !defined(PERL_OBJECT)/;
}
print $_;
}
$lastline = $_;
$lastline_no = $.;
# Read next xsub into @line from ($lastline, <$FH>).
sub fetch_para {
# parse paragraph
if ($lastline =~
$Module = $1;
}
for(;;) {
# Skip embedded PODs
}
$lastline =~ s/^\s+$//;
}
# CPP directives:
# ANSI: if ifdef ifndef elif else endif define undef
# line error pragma
# gcc: warning include_next
# obj-c: import
# others: ident (gcc notes that some cpps have this one)
$lastline =~ /^#[ \t]*(?:(?:if|ifn?def|elif|else|endif|define|undef|pragma|error|warning|line\s+\d+|ident)\b|(?:include(?:_next)?|import)\s*["<].*[>"])/) {
}
# Read next line and continuation lines
$lastline_no = $.;
my $tmp_line;
$lastline =~ s/^\s+$//;
}
1;
}
# Print initial preprocessor statements and blank lines
my $statement = $+;
$XSS_work_idx = @XSStack;
} else {
if $XSStack[-1]{type} ne 'if';
if ($XSStack[-1]{varname}) {
push(@InitFileCode, "#endif\n");
}
# Hide the functions defined in other #if branches, and reset.
} else {
0 while (--$XSS_work_idx
# Keep all new defined functions
}
}
}
# We are inside an #if, but have not yet #defined its xsubpp variable.
}
." (maybe last function was ended by a blank line "
." followed by a a statement on column one?)")
if $line[0] =~ /^\s/;
# initialize info arrays
$ScopeThisXSUB = 0;
$xsreturn = 0;
&{"${kwd}_handler"}() ;
}
if $WantLineNumbers && $line[0] !~ /^\s*#\s*line\b/;
next PARAGRAPH ;
}
# extract return type, function name and arguments
$RETVAL_no_return = 1 if $ret_type =~ s/^NO_OUTPUT\s+//;
# Allow one-line ANSI-like declaration
# a function definition needs at least 2 lines
# Check for duplicate function definition
next unless defined $tmp->{functions}{$Full_func_name};
last;
}
$DoSetMagic = 1;
$orig_args =~ s/\\\s*/ /g; # process line continuations
my %only_outlist;
s/^\s+//;
s/\s+$//;
my $arg = $_;
my $default;
my $out_type;
my $inout_var;
my $type = $1;
}
if (/\W/) { # Has a type
# warn "pushing '$arg'\n";
$arg_types{$name} = $arg;
}
}
} else {
}
} else {
my $out_type = $1;
}
}
}
? "CLASS" : "THIS");
}
my $extra_args = 0;
$num_args = 0;
$elipsis = 1;
last;
}
}
} else {
}
$extra_args++;
$args[$i] = $1;
}
}
$report_args =~ s/^,\s+//;
s/^/&/ if $in_out{$_};
}
@args_match{@args} = @args_num;
# Detect CODE: blocks which use ST(n)= or XST_m*(n,v)
# to set explicit return values.
$EXPLICIT_RETURN = ($CODE &&
$xsreturn = 1 if $EXPLICIT_RETURN;
# print function header
print Q<<"EOF";
#XS(XS_${Full_func_name})
#[[
# dXSARGS;
# dXSI32;
# dXSFUNCTION($ret_type);
}
}
else {
}
# char errbuf[1024];
# *errbuf = '\0';
# if ($cond)
# Perl_croak(aTHX_ "Usage: %s($report_args)", GvNAME(CvGV(cv)));
else
# if ($cond)
# Perl_croak(aTHX_ "Usage: $pname($report_args)");
# SP -= items;
# Now do a block of some sort.
$condnum = 0;
$_ = '';
print Q<<"EOF";
# $except [[
# do initialization of input variables
$thisdone = 0;
$retvaldone = 0;
$gotRETVAL = 0;
# ENTER;
# [[
print "\tchar *";
}
else {
}
}
# do code
$_ = '' ;
} else {
if !$retvaldone;
print "\tdXSTARG;\n"
}
unshift @line, @arg_with_types, $_;
$_ = "";
}
print $deferred;
print "\tPUTBACK;\n\treturn;\n";
print "\n\t";
print "delete THIS;\n";
} else {
print "\n\t";
print "RETVAL = ";
$wantRETVAL = 1;
}
} else {
print "${class}::";
}
} else {
print "THIS->";
}
}
}
}
# do output variables
$gotRETVAL = 0; # 1 if RETVAL seen in OUTPUT section;
undef $RETVAL_code ; # code to set RETVAL (from OUTPUT section);
# $wantRETVAL set if 'RETVAL =' autogenerated
&generate_output($var_types{$_}, $args_match{$_}, $_, $DoSetMagic)
# all OUTPUT done, so now push the return value on the stack
my $t = $WantOptimize && $targetable{$type_kind{$ret_type}};
# 0: type, 1: with_size, 2: how, 3: how_size
# PUSHp corresponds to setpvn. Treate setpv directly
warn $@ if $@;
$prepush_done = 1;
}
elsif ($t) {
warn $@ if $@;
my $size = $t->[3];
warn $@ if $@;
$prepush_done = 1;
}
else {
# RETVAL almost never needs SvSETMAGIC()
}
}
my $c = @outlist;
print "\tEXTEND(SP,$c);\n" if $c;
$xsreturn += $c;
# do cleanup
# ]]
# LEAVE;
# print function trailer
print Q<<EOF;
# ]]
EOF
print Q<<EOF if $except;
# BEGHANDLERS
# CATCHALL
# sprintf(errbuf, "%s: %s\\tpropagated", Xname, Xreason);
# ENDHANDLERS
EOF
unless $condnum;
$_ = "CASE: $_"; # Restore CASE: label
next;
}
last if $_ eq "$END:";
}
print Q<<EOF if $except;
# if (errbuf[0])
# Perl_croak(aTHX_ errbuf);
EOF
if ($xsreturn) {
print Q<<EOF unless $PPCODE;
# XSRETURN($xsreturn);
EOF
} else {
print Q<<EOF unless $PPCODE;
# XSRETURN_EMPTY;
EOF
}
print Q<<EOF;
#]]
#
EOF
my $proto = "" ;
# Build the prototype string for the xsub
if ($ProtoThisXSUB) {
if ($ProtoThisXSUB eq 2) {
# User has specified empty prototype
$proto = ', ""' ;
}
elsif ($ProtoThisXSUB ne 1) {
# User has specified a prototype
}
else {
my $s = ';';
$s = '';
}
push @proto_arg, "$s\@"
if $elipsis ;
}
}
if (%XsubAliases) {
$XsubAliases{$pname} = 0
unless defined $XsubAliases{$pname} ;
# cv = newXS(\"$name\", XS_$Full_func_name, file);
EOF
# sv_setpv((SV*)cv$proto) ;
EOF
}
}
elsif (@Attributes) {
# cv = newXS(\"$pname\", XS_$Full_func_name, file);
EOF
}
elsif ($interface) {
# cv = newXS(\"$name\", XS_$Full_func_name, file);
# $interface_macro_set(cv,$value) ;
EOF
# sv_setpv((SV*)cv$proto) ;
EOF
}
}
else {
push(@InitFileCode,
}
}
# print initialization routine
##ifdef __cplusplus
#extern "C"
##endif
EOF
#XS(boot_$Module_cname)
EOF
#[[
# dXSARGS;
# char* file = __FILE__;
#
EOF
# XS_VERSION_BOOTCHECK ;
#
EOF
# {
# CV * cv ;
#
EOF
print @InitFileCode;
# }
EOF
if (@BootCode)
{
@line = @BootCode;
print_section();
}
# XSRETURN_YES;
#]]
#
EOF
unless $ProtoUsed ;
&Exit;
sub output_init {
local($type, $num, $var, $init, $name_printed) = @_;
if( $init =~ /^=/ ) {
if ($name_printed) {
} else {
}
warn $@ if $@;
} else {
&generate_init($type, $num, $var, $name_printed);
} elsif ($name_printed) {
print ";\n";
$init =~ s/^;//;
} else {
warn $@ if $@;
$init =~ s/^;//;
}
warn $@ if $@;
}
}
sub Warn
{
# work out the line number
}
sub blurt
{
Warn @_ ;
$errors ++
}
sub death
{
Warn @_ ;
exit 1 ;
}
sub generate_init {
local($ntype);
local($tk);
unless defined($type_kind{$type});
$tk = $type_kind{$type};
$tk =~ s/OBJ$/REF/ if $func_name =~ /DESTROY$/;
$type =~ tr/:/_/;
unless defined $input_expr{$tk} ;
$expr = $input_expr{$tk};
if ($expr =~ /DO_ARRAY_ELEM/) {
unless defined($type_kind{$subtype});
blurt("Error: No INPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return
unless defined $input_expr{$type_kind{$subtype}} ;
$subexpr =~ s/\n\t/\n\t\t/g;
$expr =~ s/DO_ARRAY_ELEM/$subexpr/;
}
$ScopeThisXSUB = 1;
}
$expr =~ s/(\t+)/$1 /g;
$expr =~ s/ /\t/g;
if ($name_printed) {
print ";\n";
} else {
warn $@ if $@;
}
} else {
$deferred .= eval qq/"\\n\\tif (items < $num)\\n\\t $var = $defaults{$var};\\n\\telse {\\n$expr;\\n\\t}\\n"/;
}
warn $@ if $@;
} elsif ($ScopeThisXSUB or $expr !~ /^\t\$var =/) {
if ($name_printed) {
print ";\n";
} else {
warn $@ if $@;
}
warn $@ if $@;
} else {
if $name_printed;
warn $@ if $@;
}
}
sub generate_output {
local($type, $num, $var, $do_setmagic, $do_push) = @_;
local($ntype);
if ($type =~ /^array\(([^,]*),(.*)\)/) {
} else {
unless defined($type_kind{$type});
unless defined $output_expr{$type_kind{$type}} ;
$ntype =~ s/\(\)//g;
$expr = $output_expr{$type_kind{$type}};
if ($expr =~ /DO_ARRAY_ELEM/) {
unless defined($type_kind{$subtype});
blurt("Error: No OUTPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return
unless defined $output_expr{$type_kind{$subtype}} ;
$subexpr =~ s/\n\t/\n\t\t/g;
$expr =~ s/DO_ARRAY_ELEM\n/$subexpr/;
warn $@ if $@;
}
elsif ($var eq 'RETVAL') {
if ($expr =~ /^\t\$arg = new/) {
# We expect that $arg has refcnt 1, so we need to
# mortalize it.
warn $@ if $@;
}
elsif ($expr =~ /^\s*\$arg\s*=/) {
# We expect that $arg has refcnt >=1, so we need
# to mortalize it!
warn $@ if $@;
}
else {
# Just hope that the entry would safely write it
# over an already mortalized value. By
# coincidence, something like $arg = &sv_undef
# works too.
warn $@ if $@;
# new mortals don't have set magic
}
}
elsif ($do_push) {
warn $@ if $@;
}
elsif ($arg =~ /^ST\(\d+\)$/) {
warn $@ if $@;
}
}
}
sub map_type {
$type =~ tr/:/_/;
$type =~ s/^array\(([^,]*),(.*)\).*/$1 */s;
if ($varname) {
} else {
}
}
}
sub Exit {
# If this is VMS, the exit status has meaning to the shell, so we
# arbitrary number.
exit ($errors ? 1 : 0);
}