eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'

if $running_under_some_shell;

use strict;

use Config;

use File::Path qw(mkpath);

use Getopt::Std;

if (defined umask && (umask() & 0444)) {

umask (umask() & ~0444);

}

getopts('Dd:rlhaQe');

use vars qw($opt_D $opt_d $opt_r $opt_l $opt_h $opt_a $opt_Q $opt_e);

die "-r and -a options are mutually exclusive\n" if ($opt_r and $opt_a);

my @inc_dirs = inc_dirs() if $opt_a;

my $Exit = 0;

my $Dest_dir = $opt_d || $Config{installsitearch};

die "Destination directory $Dest_dir doesn't exist or isn't a directory\n"

unless -d $Dest_dir;

my @isatype = qw(

);

my %isatype;

@isatype{@isatype} = (1) x @isatype;

my $inif = 0;

my %Is_converted;

my %bad_file = ();

@ARGV = ('-') unless @ARGV;

build_preamble_if_necessary();

sub reindent($) {

my($text) = shift;

$text =~ s/\n/\n /g;

$text =~ s/ /\t/g;

$text;

}

my ($t, $tab, %curargs, $new, $eval_index, $dir, $name, $args, $outfile);

my ($incl, $incl_type, $next);

while (defined (my $file = next_file())) {

if (-l $file and -d $file) {

link_if_possible($file) if ($opt_l);

next;

}

# Recover from header files with unbalanced cpp directives

$t = '';

$tab = 0;

# $eval_index goes into ``#line'' directives, to help locate syntax errors:

$eval_index = 1;

if ($file eq '-') {

open(IN, "-");

open(OUT, ">-");

} else {

($outfile = $file) =~ s/\.h$/.ph/ || next;

print "$file -> $outfile\n" unless $opt_Q;

if ($file =~ m|^(.*)/|) {

$dir = $1;

mkpath "$Dest_dir/$dir";

}

if ($opt_a) { # automagic mode: locate header file in @inc_dirs

foreach (@inc_dirs) {

chdir $_;

last if -f $file;

}

}

open(IN,"$file") || (($Exit = 1),(warn "Can't open $file: $!\n"),next);

open(OUT,">$Dest_dir/$outfile") || die "Can't create $outfile: $!\n";

}

print OUT

"require '_h2ph_pre.ph';\n\n",

"no warnings 'redefine';\n\n";

while (defined (local $_ = next_line($file))) {

if (s/^\s*\#\s*//) {

if (s/^define\s+(\w+)//) {

$name = $1;

$new = '';

s/\s+$//;

s/\(\w+\s*\(\*\)\s*\(\w*\)\)\s*(-?\d+)/$1/; # (int (*)(foo_t))0

if (s/^\(([\w,\s]*)\)//) {

$args = $1;

my $proto = '() ';

if ($args ne '') {

$proto = '';

foreach my $arg (split(/,\s*/,$args)) {

$arg =~ s/^\s*([^\s].*[^\s])\s*$/$1/;

$curargs{$arg} = 1;

}

$args =~ s/\b(\w)/\$$1/g;

$args = "my($args) = \@_;\n$t ";

}

s/^\s+//;

expr();

$new =~ s/(["\\])/\\$1/g; #"]);

EMIT:

$new = reindent($new);

$args = reindent($args);

if ($t ne '') {

$new =~ s/(['\\])/\\$1/g; #']);

if ($opt_h) {

print OUT $t,

"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";

$eval_index++;

} else {

print OUT $t,

"eval 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";

}

} else {

print OUT "unless(defined(\&$name)) {\n sub $name $proto\{\n\t${args}eval q($new);\n }\n}\n";

}

%curargs = ();

} else {

s/^\s+//;

expr();

$new = 1 if $new eq '';

$new = reindent($new);

$args = reindent($args);

if ($t ne '') {

$new =~ s/(['\\])/\\$1/g; #']);

if ($opt_h) {

print OUT $t,"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name () {",$new,";}' unless defined(\&$name);\n";

$eval_index++;

} else {

print OUT $t,"eval 'sub $name () {",$new,";}' unless defined(\&$name);\n";

}

} else {

# Shunt around such directives as `#define FOO FOO':

next if " \&$name" eq $new;

print OUT $t,"unless(defined(\&$name)) {\n sub $name () {\t",$new,";}\n}\n";

}

}

} elsif (/^(include|import|include_next)\s*[<\"](.*)[>\"]/) {

$incl_type = $1;

$incl = $2;

if (($incl_type eq 'include_next') ||

($opt_e && exists($bad_file{$incl}))) {

$incl =~ s/\.h$/.ph/;

print OUT ($t,

"eval {\n");

$tab += 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

print OUT ($t, "my(\@REM);\n");

if ($incl_type eq 'include_next') {

print OUT ($t,

"my(\%INCD) = map { \$INC{\$_} => 1 } ",

"(grep { \$_ eq \"$incl\" } ",

"keys(\%INC));\n");

print OUT ($t,

"\@REM = map { \"\$_/$incl\" } ",

"(grep { not exists(\$INCD{\"\$_/$incl\"})",

" and -f \"\$_/$incl\" } \@INC);\n");

} else {

print OUT ($t,

"\@REM = map { \"\$_/$incl\" } ",

"(grep {-r \"\$_/$incl\" } \@INC);\n");

}

print OUT ($t,

"require \"\$REM[0]\" if \@REM;\n");

$tab -= 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

print OUT ($t,

"};\n");

print OUT ($t,

"warn(\$\@) if \$\@;\n");

} else {

$incl =~ s/\.h$/.ph/;

print OUT $t,"require '$incl';\n";

}

} elsif (/^ifdef\s+(\w+)/) {

print OUT $t,"if(defined(&$1)) {\n";

$tab += 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

} elsif (/^ifndef\s+(\w+)/) {

print OUT $t,"unless(defined(&$1)) {\n";

$tab += 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

} elsif (s/^if\s+//) {

$new = '';

$inif = 1;

expr();

$inif = 0;

print OUT $t,"if($new) {\n";

$tab += 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

} elsif (s/^elif\s+//) {

$new = '';

$inif = 1;

expr();

$inif = 0;

$tab -= 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

print OUT $t,"}\n elsif($new) {\n";

$tab += 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

} elsif (/^else/) {

$tab -= 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

print OUT $t,"} else {\n";

$tab += 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

} elsif (/^endif/) {

$tab -= 4;

$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);

print OUT $t,"}\n";

} elsif(/^undef\s+(\w+)/) {

print OUT $t, "undef(&$1) if defined(&$1);\n";

} elsif(/^error\s+(".*")/) {

print OUT $t, "die($1);\n";

} elsif(/^error\s+(.*)/) {

print OUT $t, "die(\"", quotemeta($1), "\");\n";

} elsif(/^warning\s+(.*)/) {

print OUT $t, "warn(\"", quotemeta($1), "\");\n";

} elsif(/^ident\s+(.*)/) {

print OUT $t, "# $1\n";

}

} elsif (/^\s*(typedef\s*)?enum\s*(\s+[a-zA-Z_]\w*\s*)?/) { # { for vi

until(/\{[^}]*\}.*;/ || /;/) {

last unless defined ($next = next_line($file));

chomp $next;

# drop "#define FOO FOO" in enums

$next =~ s/^\s*#\s*define\s+(\w+)\s+\1\s*$//;

# #defines in enums (aliases)

$next =~ s/^\s*#\s*define\s+(\w+)\s+(\w+)\s*$/$1 = $2,/;

$_ .= $next;

print OUT "# $next\n" if $opt_D;

}

s/#\s*if.*?#\s*endif//g; # drop #ifdefs

s@/\*.*?\*/@@g;

s/\s+/ /g;

next unless /^\s?(typedef\s?)?enum\s?([a-zA-Z_]\w*)?\s?\{(.*)\}\s?([a-zA-Z_]\w*)?\s?;/;

(my $enum_subs = $3) =~ s/\s//g;

my @enum_subs = split(/,/, $enum_subs);

my $enum_val = -1;

foreach my $enum (@enum_subs) {

my ($enum_name, $enum_value) = $enum =~ /^([a-zA-Z_]\w*)(=.+)?$/;

$enum_name or next;

$enum_value =~ s/^=//;

$enum_val = (length($enum_value) ? $enum_value : $enum_val + 1);

if ($opt_h) {

print OUT ($t,

"eval(\"\\n#line $eval_index $outfile\\n",

"sub $enum_name () \{ $enum_val; \}\") ",

"unless defined(\&$enum_name);\n");

++ $eval_index;

} else {

print OUT ($t,

"eval(\"sub $enum_name () \{ $enum_val; \}\") ",

"unless defined(\&$enum_name);\n");

}

}

} elsif (/^(?:__extension__\s+)?(?:extern|static)\s+(?:__)?inline(?:__)?\s+/

and !/;\s*$/ and !/{\s*}\s*$/)

last unless defined ($next = next_line($file));

chomp $next;

undef $_, last if $next =~ /__THROW\s*;/

or $next =~ /^(__extension__|extern|static)\b/;

$_ .= " $next";

print OUT "# $next\n" if $opt_D;

last if $next =~ /^}|^{.*}\s*$/;

}

next if not defined; # because it's only a prototype

s/\b(__extension__|extern|static|(?:__)?inline(?:__)?)\b//g;

# violently drop #ifdefs

s/#\s*if.*?#\s*endif//g

and print OUT "# some #ifdef were dropped here -- fill in the blanks\n";

if (s/^(?:\w|\s|\*)*\s(\w+)\s*//) {

$name = $1;

} else {

warn "name not found"; next; # shouldn't occur...

}

my @args;

if (s/^\(([^()]*)\)\s*(\w+\s*)*//) {

for my $arg (split /,/, $1) {

if ($arg =~ /(\w+)\s*$/) {

$curargs{$1} = 1;

push @args, $1;

}

}

}

$args = (

@args

? "my(" . (join ',', map "\$$_", @args) . ") = \@_;\n$t "

: ""

);

my $proto = @args ? '' : '() ';

$new = '';

s/\breturn\b//g; # "return" doesn't occur in macros usually...

expr();

# try to find and perlify local C variables

our @local_variables = (); # needs to be a our(): (?{...}) bug workaround

{

use re "eval";

my $typelist = join '|', keys %isatype;

$new =~ s['

[my \$$1]gx;

$new =~ s['

[my \$$1;]gx;

}

$new =~ s/&$_\b/\$$_/g for @local_variables;

$new =~ s/(["\\])/\\$1/g; #"]);

# now that's almost like a macro (we hope)

goto EMIT;

}

}

$Is_converted{$file} = 1;

if ($opt_e && exists($bad_file{$file})) {

unlink($Dest_dir . '/' . $outfile);

$next = '';

} else {

print OUT "1;\n";

queue_includes_from($file) if $opt_a;

}

}

if ($opt_e && (scalar(keys %bad_file) > 0)) {

warn "Was unable to convert the following files:\n";

warn "\t" . join("\n\t",sort(keys %bad_file)) . "\n";

}

exit $Exit;

sub expr {

$new = '"(assembly code)"' and return if /\b__asm__\b/; # freak out.

my $joined_args;

if(keys(%curargs)) {

$joined_args = join('|', keys(%curargs));

}

while ($_ ne '') {

s/^\&\&// && do { $new .= " &&"; next;}; # handle && operator

s/^\&([\(a-z\)]+)/$1/i; # hack for things that take the address of

s/^(\s+)// && do {$new .= ' '; next;};

s/^0X([0-9A-F]+)[UL]*//i

&& do {my $hex = $1;

$hex =~ s/^0+//;

if (length $hex > 8 && !$Config{use64bitint}) {

# Croak if nv_preserves_uv_bits < 64 ?

$new .= hex(substr($hex, -8)) +

2**32 * hex(substr($hex, 0, -8));

# The above will produce "errorneus" code

# if the hex constant was e.g. inside UINT64_C

# macro, but then again, h2ph is an approximation.

} else {

$new .= lc("0x$hex");

}

next;};

s/^(-?\d+\.\d+E[-+]?\d+)[FL]?//i && do {$new .= $1; next;};

s/^(\d+)\s*[LU]*//i && do {$new .= $1; next;};

s/^("(\\"|[^"])*")// && do {$new .= $1; next;};

s/^'((\\"|[^"])*)'// && do {

if ($curargs{$1}) {

$new .= "ord('\$$1')";

} else {

$new .= "ord('$1')";

}

next;

};

# replace "sizeof(foo)" with "{foo}"

# also, remove * (C dereference operator) to avoid perl syntax

# problems. Where the %sizeof array comes from is anyone's

# guess (c2ph?), but this at least avoids fatal syntax errors.

# Behavior is undefined if sizeof() delimiters are unbalanced.

# This code was modified to able to handle constructs like this:

# sizeof(*(p)), which appear in the HP-UX 10.01 header files.

s/^sizeof\s*\(// && do {

$new .= '$sizeof';

my $lvl = 1; # already saw one open paren

# tack { on the front, and skip it in the loop

$_ = "{" . "$_";

my $index = 1;

# find balanced closing paren

while ($index <= length($_) && $lvl > 0) {

$lvl++ if substr($_, $index, 1) eq "(";

$lvl-- if substr($_, $index, 1) eq ")";

$index++;

}

# tack } on the end, replacing )

substr($_, $index - 1, 1) = "}";

# remove pesky * operators within the sizeof argument

substr($_, 0, $index - 1) =~ s/\*//g;

next;

};

# Eliminate typedefs

/\(([\w\s]+)[\*\s]*\)\s*[\w\(]/ && do {

my $doit = 1;

foreach (split /\s+/, $1) { # Make sure all the words are types,

unless($isatype{$_} or $_ eq 'struct' or $_ eq 'union'){

$doit = 0;

last;

}

}

if( $doit ){

s/\([\w\s]+[\*\s]*\)// && next; # then eliminate them.

}

};

# struct/union member, including arrays:

s/^([_A-Z]\w*(\[[^\]]+\])?((\.|->)[_A-Z]\w*(\[[^\]]+\])?)+)//i && do {

my $id = $1;

$id =~ s/(\.|(->))([^\.\-]*)/->\{$3\}/g;

$id =~ s/\b([^\$])($joined_args)/$1\$$2/g if length($joined_args);

while($id =~ /\[\s*([^\$\&\d\]]+)\]/) {

my($index) = $1;

$index =~ s/\s//g;

if(exists($curargs{$index})) {

$index = "\$$index";

} else {

$index = "&$index";

}

$id =~ s/\[\s*([^\$\&\d\]]+)\]/[$index]/;

}

$new .= " (\$$id)";

};

s/^([_a-zA-Z]\w*)// && do {

my $id = $1;

if ($id eq 'struct' || $id eq 'union') {

s/^\s+(\w+)//;

$id .= ' ' . $1;

$isatype{$id} = 1;

} elsif ($id =~ /^((un)?signed)|(long)|(short)$/) {

while (s/^\s+(\w+)//) { $id .= ' ' . $1; }

$isatype{$id} = 1;

}

if ($curargs{$id}) {

$new .= "\$$id";

$new .= '->' if /^[\[\{]/;

} elsif ($id eq 'defined') {

$new .= 'defined';

} elsif (/^\s*\(/) {

s/^\s*\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i; # cheat

$new .= " &$id";

} elsif ($isatype{$id}) {

if ($new =~ /{\s*$/) {

$new .= "'$id'";

} elsif ($new =~ /\(\s*$/ && /^[\s*]*\)/) {

$new =~ s/\(\s*$//;

s/^[\s*]*\)//;

} else {

$new .= q(').$id.q(');

}

} else {

if ($inif && $new !~ /defined\s*\($/) {

$new .= '(defined(&' . $id . ') ? &' . $id . ' : 0)';

} elsif (/^\[/) {

$new .= " \$$id";

} else {

$new .= ' &' . $id;

}

}

next;

};

s/^(.)// && do { if ($1 ne '#') { $new .= $1; } next;};

}

}

sub next_line

{

my $file = shift;

my ($in, $out);

my $pre_sub_tri_graphs = 1;

READ: while (not eof IN) {

$in .= <IN>;

chomp $in;

next unless length $in;

while (length $in) {

if ($pre_sub_tri_graphs) {

# Preprocess all tri-graphs

# including things stuck in quoted string constants.

$in =~ s/\?\?=/#/g; # | ??=| #|

$in =~ s/\?\?\!/|/g; # | ??!| ||

$in =~ s/\?\?'/^/g; # | ??'| ^|

$in =~ s/\?\?\(/[/g; # | ??(| [|

$in =~ s/\?\?\)/]/g; # | ??)| ]|

$in =~ s/\?\?\-/~/g; # | ??-| ~|

$in =~ s/\?\?\//\\/g; # | ??/| \|

$in =~ s/\?\?</{/g; # | ??<| {|

$in =~ s/\?\?>/}/g; # | ??>| }|

}

if ($in =~ /^\#ifdef __LANGUAGE_PASCAL__/) {

# Tru64 disassembler.h evilness: mixed C and Pascal.

while (<IN>) {

last if /^\#endif/;

}

$in = "";

next READ;

}

if ($in =~ /^extern inline / && # Inlined assembler.

$^O eq 'linux' && $file =~ m!(?:^|/)asm/[^/]+\.h$!) {

while (<IN>) {

last if /^}/;

}

$in = "";

next READ;

}

if ($in =~ s/\\$//) { # \-newline

$out .= ' ';

next READ;

} elsif ($in =~ s/^([^"'\\\/]+)//) { # Passthrough

$out .= $1;

} elsif ($in =~ s/^(\\.)//) { # \...

$out .= $1;

} elsif ($in =~ /^'/) { # '...

if ($in =~ s/^('(\\.|[^'\\])*')//) {

$out .= $1;

} else {

next READ;

}

} elsif ($in =~ /^"/) { # "...

if ($in =~ s/^("(\\.|[^"\\])*")//) {

$out .= $1;

} else {

next READ;

}

} elsif ($in =~ s/^\/\/.*//) { # //...

# fall through

} elsif ($in =~ m/^\/\*/) { # /*...

# C comment removal adapted from perlfaq6:

if ($in =~ s/^\/\*[^*]*\*+([^\/*][^*]*\*+)*\///) {

$out .= ' ';

} else { # Incomplete /* */

next READ;

}

} elsif ($in =~ s/^(\/)//) { # /...

$out .= $1;

} elsif ($in =~ s/^([^\'\"\\\/]+)//) {

$out .= $1;

} elsif ($^O eq 'linux' &&

$file =~ m!(?:^|/)linux/byteorder/pdp_endian\.h$! &&

$in =~ s!\'T KNOW!!) {

$out =~ s!I DON$!I_DO_NOT_KNOW!;

} else {

if ($opt_e) {

warn "Cannot parse $file:\n$in\n";

$bad_file{$file} = 1;

$in = '';

$out = undef;

last READ;

} else {

die "Cannot parse:\n$in\n";

}

}

}

last READ if $out =~ /\S/;

}

return $out;

}

sub next_file

{

my $file;

while (@ARGV) {

$file = shift @ARGV;

if ($file eq '-' or -f $file or -l $file) {

return $file;

} elsif (-d $file) {

if ($opt_r) {

expand_glob($file);

} else {

print STDERR "Skipping directory `$file'\n";

}

} elsif ($opt_a) {

return $file;

} else {

print STDERR "Skipping `$file': not a file or directory\n";

}

}

return undef;

}

sub expand_glob

{

my ($directory) = @_;

$directory =~ s:/$::;

opendir DIR, $directory;

foreach (readdir DIR) {

next if ($_ eq '.' or $_ eq '..');

# expand_glob() is going to be called until $ARGV[0] isn't a

# directory; so push directories, and unshift everything else.

if (-d "$directory/$_") { push @ARGV, "$directory/$_" }

else { unshift @ARGV, "$directory/$_" }

}

closedir DIR;

}

sub link_if_possible

{

my ($dirlink) = @_;

my $target = eval 'readlink($dirlink)';

if ($target =~ m:^\.\./: or $target =~ m:^/:) {

# The target of a parent or absolute link could leave the $Dest_dir

# hierarchy, so let's put all of the contents of $dirlink (actually,

# the contents of $target) into @ARGV; as a side effect down the

# line, $dirlink will get created as an _actual_ directory.

expand_glob($dirlink);

} else {

if (-l "$Dest_dir/$dirlink") {

unlink "$Dest_dir/$dirlink" or

print STDERR "Could not remove link $Dest_dir/$dirlink: $!\n";

}

if (eval 'symlink($target, "$Dest_dir/$dirlink")') {

print "Linking $target -> $Dest_dir/$dirlink\n";

# Make sure that the link _links_ to something:

if (! -e "$Dest_dir/$target") {

mkpath("$Dest_dir/$target", 0755) or

print STDERR "Could not create $Dest_dir/$target/\n";

}

} else {

print STDERR "Could not symlink $target -> $Dest_dir/$dirlink: $!\n";

}

}

}

sub queue_includes_from

{

my ($file) = @_;

my $line;

return if ($file eq "-");

open HEADER, $file or return;

while (defined($line = <HEADER>)) {

while (/\\$/) { # Handle continuation lines

chop $line;

$line .= <HEADER>;

}

if ($line =~ /^#\s*include\s+<(.*?)>/) {

push(@ARGV, $1) unless $Is_converted{$1};

}

}

close HEADER;

}

sub inc_dirs

{

my $from_gcc = `LC_ALL=C $Config{cc} -v 2>&1`;

if( !( $from_gcc =~ s:^Reading specs from (.*?)/specs\b.*:$1/include:s ) )

{ # gcc-4+ :

$from_gcc = `LC_ALL=C $Config{cc} -print-search-dirs 2>&1`;

if ( !($from_gcc =~ s/^install:\s*([^\s]+[^\s\/])([\s\/]*).*$/$1\/include/s) )

{

$from_gcc = '';

};

};

length($from_gcc) ? ($from_gcc, $Config{usrinc}) : ($Config{usrinc});

}

sub build_preamble_if_necessary

{

# Increment $VERSION every time this function is modified:

my $VERSION = 2;

my $preamble = "$Dest_dir/_h2ph_pre.ph";

# Can we skip building the preamble file?

if (-r $preamble) {

# Extract version number from first line of preamble:

open PREAMBLE, $preamble or die "Cannot open $preamble: $!";

my $line = <PREAMBLE>;

$line =~ /(\b\d+\b)/;

close PREAMBLE or die "Cannot close $preamble: $!";

# Don't build preamble if a compatible preamble exists:

return if $1 == $VERSION;

}

my (%define) = _extract_cc_defines();

open PREAMBLE, ">$preamble" or die "Cannot open $preamble: $!";

print PREAMBLE "# This file was created by h2ph version $VERSION\n";

foreach (sort keys %define) {

if ($opt_D) {

print PREAMBLE "# $_=$define{$_}\n";

}

if ($define{$_} =~ /^(\d+)U?L{0,2}$/i) {

print PREAMBLE

"unless (defined &$_) { sub $_() { $1 } }\n\n";

} elsif ($define{$_} =~ /^\w+$/) {

print PREAMBLE

"unless (defined &$_) { sub $_() { &$define{$_} } }\n\n";

} else {

print PREAMBLE

"unless (defined &$_) { sub $_() { \"",

quotemeta($define{$_}), "\" } }\n\n";

}

}

close PREAMBLE or die "Cannot close $preamble: $!";

}

sub _extract_cc_defines

{

my %define;

my $allsymbols = join " ",

@Config{'ccsymbols', 'cppsymbols', 'cppccsymbols'};

# Split compiler pre-definitions into `key=value' pairs:

foreach (split /\s+/, $allsymbols) {

/(.+?)=(.+)/ and $define{$1} = $2;

if ($opt_D) {

print STDERR "$_: $1 -> $2\n";

}

}

return %define;

}

1;