#! /usr/bin/env perl

# Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.

#

# Licensed under the OpenSSL license (the "License").  You may not use

# this file except in compliance with the License.  You can obtain a copy

# in the file LICENSE in the source distribution or at

# https://www.openssl.org/source/license.html

#

# generate a .def file

#

# It does this by parsing the header files and looking for the

# prototyped functions: it then prunes the output.

#

# Intermediary files are created, call libcrypto.num and libssl.num,

# The format of these files is:

#

#	routine-name	nnnn	vers	info

#

# The "nnnn" and "vers" fields are the numeric id and version for the symbol

# respectively. The "info" part is actually a colon-separated string of fields

# with the following meaning:

#

#	existence:platform:kind:algorithms

#

# - "existence" can be "EXIST" or "NOEXIST" depending on if the symbol is

#   found somewhere in the source,

# - "platforms" is empty if it exists on all platforms, otherwise it contains

#   comma-separated list of the platform, just as they are if the symbol exists

#   for those platforms, or prepended with a "!" if not.  This helps resolve

#   symbol name variants for platforms where the names are too long for the

#   compiler or linker, or if the systems is case insensitive and there is a

#   clash, or the symbol is implemented differently (see

#   EXPORT_VAR_AS_FUNCTION).  This script assumes renaming of symbols is found

#   in the file crypto/symhacks.h.

#   The semantics for the platforms is that every item is checked against the

#   environment.  For the negative items ("!FOO"), if any of them is false

#   (i.e. "FOO" is true) in the environment, the corresponding symbol can't be

#   used.  For the positive items, if all of them are false in the environment,

#   the corresponding symbol can't be used.  Any combination of positive and

#   negative items are possible, and of course leave room for some redundancy.

# - "kind" is "FUNCTION" or "VARIABLE".  The meaning of that is obvious.

# - "algorithms" is a comma-separated list of algorithm names.  This helps

#   exclude symbols that are part of an algorithm that some user wants to

#   exclude.

#

use lib ".";

use configdata;

use File::Spec::Functions;

use File::Basename;

use FindBin;

use lib "$FindBin::Bin/perl";

use OpenSSL::Glob;

# When building a "variant" shared library, with a custom SONAME, also customize

# all the symbol versions.  This produces a shared object that can coexist

# without conflict in the same address space as a default build, or an object

# with a different variant tag.

#

# For example, with a target definition that includes:

#

#         shlib_variant => "-opt",

#

# we build the following objects:

#

# $ perl -le '

#     for (@ARGV) {

#         if ($l = readlink) {

#             printf "%s -> %s\n", $_, $l

#         } else {

#             print

#         }

#     }' *.so*

# libcrypto-opt.so.1.1

# libcrypto.so -> libcrypto-opt.so.1.1

# libssl-opt.so.1.1

# libssl.so -> libssl-opt.so.1.1

#

# whose SONAMEs and dependencies are:

#

# $ for l in *.so; do

#     echo $l

#     readelf -d $l | egrep 'SONAME|NEEDED.*(ssl|crypto)'

#   done

# libcrypto.so

#  0x000000000000000e (SONAME)             Library soname: [libcrypto-opt.so.1.1]

# libssl.so

#  0x0000000000000001 (NEEDED)             Shared library: [libcrypto-opt.so.1.1]

#  0x000000000000000e (SONAME)             Library soname: [libssl-opt.so.1.1]

#

# We case-fold the variant tag to upper case and replace all non-alnum

# characters with "_".  This yields the following symbol versions:

#

# $ nm libcrypto.so | grep -w A

# 0000000000000000 A OPENSSL_OPT_1_1_0

# 0000000000000000 A OPENSSL_OPT_1_1_0a

# 0000000000000000 A OPENSSL_OPT_1_1_0c

# 0000000000000000 A OPENSSL_OPT_1_1_0d

# 0000000000000000 A OPENSSL_OPT_1_1_0f

# 0000000000000000 A OPENSSL_OPT_1_1_0g

# $ nm libssl.so | grep -w A

# 0000000000000000 A OPENSSL_OPT_1_1_0

# 0000000000000000 A OPENSSL_OPT_1_1_0d

#

(my $SO_VARIANT = qq{\U$target{"shlib_variant"}}) =~ s/\W/_/g;

my $debug=0;

my $trace=0;

my $verbose=0;

my $crypto_num= catfile($config{sourcedir},"util","libcrypto.num");

my $ssl_num=    catfile($config{sourcedir},"util","libssl.num");

my $libname;

my $do_update = 0;

my $do_rewrite = 1;

my $do_crypto = 0;

my $do_ssl = 0;

my $do_ctest = 0;

my $do_ctestall = 0;

my $do_checkexist = 0;

my $VMS=0;

my $W32=0;

my $NT=0;

my $UNIX=0;

my $linux=0;

my $aix=0;

# Set this to make typesafe STACK definitions appear in DEF

my $safe_stack_def = 0;

my @known_platforms = ( "__FreeBSD__", "PERL5",

			"EXPORT_VAR_AS_FUNCTION", "ZLIB", "_WIN32"

			);

my @known_ossl_platforms = ( "UNIX", "VMS", "WIN32", "WINNT", "OS2" );

my @known_algorithms = ( # These are algorithms we know are guarded in relevant

			 # header files, but aren't actually disablable.

			 # Without these, this script will warn a lot.

			 "RSA", "MD5",

			 # @disablables comes from configdata.pm

			 map { (my $x = uc $_) =~ s|-|_|g; $x; } @disablables,

			 # Deprecated functions.  Not really algorithmss, but

			 # treated as such here for the sake of simplicity

			 "DEPRECATEDIN_0_9_8",

			 "DEPRECATEDIN_1_0_0",

			 "DEPRECATEDIN_1_1_0",

			 "DEPRECATEDIN_1_2_0",

                     );

# %disabled comes from configdata.pm

my %disabled_algorithms =

    map { (my $x = uc $_) =~ s|-|_|g; $x => 1; } keys %disabled;

my $apiv = sprintf "%x%02x%02x", split(/\./, $config{api});

foreach (@known_algorithms) {

	if (/^DEPRECATEDIN_(\d+)_(\d+)_(\d+)$/) {

		my $depv = sprintf "%x%02x%02x", $1, $2, $3;

		$disabled_algorithms{$_} = 1 if $apiv ge $depv;

	}

}

my $zlib;

foreach (@ARGV, split(/ /, $config{options}))

	{

	$debug=1 if $_ eq "debug";

	$trace=1 if $_ eq "trace";

	$verbose=1 if $_ eq "verbose";

	$W32=1 if $_ eq "32";

	die "win16 not supported" if $_ eq "16";

	if($_ eq "NT") {

		$W32 = 1;

		$NT = 1;

	} elsif ($_ eq "linux") {

		$linux=1;

		$UNIX=1;

	} elsif ($_ eq "aix") {

		$aix=1;

		$UNIX=1;

	} elsif ($_ eq "VMS") {

		$VMS=1;

	}

	if ($_ eq "zlib" || $_ eq "enable-zlib" || $_ eq "zlib-dynamic"

			 || $_ eq "enable-zlib-dynamic") {

		$zlib = 1;

	}

	$do_crypto=1 if $_ eq "libcrypto" || $_ eq "crypto";

	$do_ssl=1 if $_ eq "libssl" || $_ eq "ssl";

	$do_update=1 if $_ eq "update";

	$do_rewrite=1 if $_ eq "rewrite";

	$do_ctest=1 if $_ eq "ctest";

	$do_ctestall=1 if $_ eq "ctestall";

	$do_checkexist=1 if $_ eq "exist";

	}

$libname = $unified_info{sharednames}->{libcrypto} if $do_crypto;

$libname = $unified_info{sharednames}->{libssl} if $do_ssl;

if (!$libname) {

	if ($do_ssl) {

		$libname="LIBSSL";

	}

	if ($do_crypto) {

		$libname="LIBCRYPTO";

	}

}

# If no platform is given, assume WIN32

if ($W32 + $VMS + $linux + $aix == 0) {

	$W32 = 1;

}

die "Please, only one platform at a time"

    if ($W32 + $VMS + $linux + $aix > 1);

if (!$do_ssl && !$do_crypto)

	{

	print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT | OS2 | linux | VMS ]\n";

	exit(1);

	}

%ssl_list=&load_numbers($ssl_num);

$max_ssl = $max_num;

%crypto_list=&load_numbers($crypto_num);

$max_crypto = $max_num;

my $ssl="include/openssl/ssl.h";

$ssl.=" include/openssl/sslerr.h";

$ssl.=" include/openssl/tls1.h";

$ssl.=" include/openssl/srtp.h";

# When scanning include/openssl, skip all SSL files and some internal ones.

my %skipthese;

foreach my $f ( split(/\s+/, $ssl) ) {

    $skipthese{$f} = 1;

}

$skipthese{'include/openssl/conf_api.h'} = 1;

$skipthese{'include/openssl/ebcdic.h'} = 1;

$skipthese{'include/openssl/opensslconf.h'} = 1;

# We use headers found in include/openssl and include/internal only.

# The latter is needed so libssl.so/.dll/.exe can link properly.

my $crypto ="include/internal/dso.h";

$crypto.=" include/internal/o_dir.h";

$crypto.=" include/internal/o_str.h";

$crypto.=" include/internal/err.h";

$crypto.=" include/internal/sslconf.h";

foreach my $f ( glob(catfile($config{sourcedir},'include/openssl/*.h')) ) {

    my $fn = "include/openssl/" . basename($f);

    $crypto .= " $fn" if !defined $skipthese{$fn};

}

my $symhacks="include/openssl/symhacks.h";

my @ssl_symbols = &do_defs("LIBSSL", $ssl, $symhacks);

my @crypto_symbols = &do_defs("LIBCRYPTO", $crypto, $symhacks);

if ($do_update) {

if ($do_ssl == 1) {

	&maybe_add_info("LIBSSL",*ssl_list,@ssl_symbols);

	if ($do_rewrite == 1) {

		open(OUT, ">$ssl_num");

		&rewrite_numbers(*OUT,"LIBSSL",*ssl_list,@ssl_symbols);

	} else {

		open(OUT, ">>$ssl_num");

	}

	&update_numbers(*OUT,"LIBSSL",*ssl_list,$max_ssl,@ssl_symbols);

	close OUT;

}

if($do_crypto == 1) {

	&maybe_add_info("LIBCRYPTO",*crypto_list,@crypto_symbols);

	if ($do_rewrite == 1) {

		open(OUT, ">$crypto_num");

		&rewrite_numbers(*OUT,"LIBCRYPTO",*crypto_list,@crypto_symbols);

	} else {

		open(OUT, ">>$crypto_num");

	}

	&update_numbers(*OUT,"LIBCRYPTO",*crypto_list,$max_crypto,@crypto_symbols);

	close OUT;

}

} elsif ($do_checkexist) {

	&check_existing(*ssl_list, @ssl_symbols)

		if $do_ssl == 1;

	&check_existing(*crypto_list, @crypto_symbols)

		if $do_crypto == 1;

} elsif ($do_ctest || $do_ctestall) {

	print <<"EOF";

/* Test file to check all DEF file symbols are present by trying

 * to link to all of them. This is *not* intended to be run!

 */

int main()

{

EOF

	&print_test_file(*STDOUT,"LIBSSL",*ssl_list,$do_ctestall,@ssl_symbols)

		if $do_ssl == 1;

	&print_test_file(*STDOUT,"LIBCRYPTO",*crypto_list,$do_ctestall,@crypto_symbols)

		if $do_crypto == 1;

	print "}\n";

} else {

	&print_def_file(*STDOUT,$libname,*ssl_list,@ssl_symbols)

		if $do_ssl == 1;

	&print_def_file(*STDOUT,$libname,*crypto_list,@crypto_symbols)

		if $do_crypto == 1;

}

sub do_defs

{

	my($name,$files,$symhacksfile)=@_;

	my $file;

	my @ret;

	my %syms;

	my %platform;		# For anything undefined, we assume ""

	my %kind;		# For anything undefined, we assume "FUNCTION"

	my %algorithm;		# For anything undefined, we assume ""

	my %variant;

	my %variant_cnt;	# To be able to allocate "name{n}" if "name"

				# is the same name as the original.

	my $cpp;

	my %unknown_algorithms = ();

	my $parens = 0;

	foreach $file (split(/\s+/,$symhacksfile." ".$files))

		{

		my $fn = catfile($config{sourcedir},$file);

		print STDERR "DEBUG: starting on $fn:\n" if $debug;

		print STDERR "TRACE: start reading $fn\n" if $trace;

		open(IN,"<$fn") || die "Can't open $fn, $!,";

		my $line = "", my $def= "";

		my %tag = (

			(map { $_ => 0 } @known_platforms),

			(map { "OPENSSL_SYS_".$_ => 0 } @known_ossl_platforms),

			(map { "OPENSSL_NO_".$_ => 0 } @known_algorithms),

			(map { "OPENSSL_USE_".$_ => 0 } @known_algorithms),

			(grep /^DEPRECATED_/, @known_algorithms),

			NOPROTO		=> 0,

			PERL5		=> 0,

			_WINDLL		=> 0,

			CONST_STRICT	=> 0,

			TRUE		=> 1,

		);

		my $symhacking = $file eq $symhacksfile;

		my @current_platforms = ();

		my @current_algorithms = ();

		# params: symbol, alias, platforms, kind

		# The reason to put this subroutine in a variable is that

		# it will otherwise create its own, unshared, version of

		# %tag and %variant...

		my $make_variant = sub

		{

			my ($s, $a, $p, $k) = @_;

			my ($a1, $a2);

			print STDERR "DEBUG: make_variant: Entered with ",$s,", ",$a,", ",(defined($p)?$p:""),", ",(defined($k)?$k:""),"\n" if $debug;

			if (defined($p))

			{

				$a1 = join(",",$p,

					   grep(!/^$/,

						map { $tag{$_} == 1 ? $_ : "" }

						@known_platforms));

			}

			else

			{

				$a1 = join(",",

					   grep(!/^$/,

						map { $tag{$_} == 1 ? $_ : "" }

						@known_platforms));

			}

			$a2 = join(",",

				   grep(!/^$/,

					map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ : "" }

					@known_ossl_platforms));

			print STDERR "DEBUG: make_variant: a1 = $a1; a2 = $a2\n" if $debug;

			if ($a1 eq "") { $a1 = $a2; }

			elsif ($a1 ne "" && $a2 ne "") { $a1 .= ",".$a2; }

			if ($a eq $s)

			{

				if (!defined($variant_cnt{$s}))

				{

					$variant_cnt{$s} = 0;

				}

				$variant_cnt{$s}++;

				$a .= "{$variant_cnt{$s}}";

			}

			my $toadd = $a.":".$a1.(defined($k)?":".$k:"");

			my $togrep = $s.'(\{[0-9]+\})?:'.$a1.(defined($k)?":".$k:"");

			if (!grep(/^$togrep$/,

				  split(/;/, defined($variant{$s})?$variant{$s}:""))) {

				if (defined($variant{$s})) { $variant{$s} .= ";"; }

				$variant{$s} .= $toadd;

			}

			print STDERR "DEBUG: make_variant: Exit with variant of ",$s," = ",$variant{$s},"\n" if $debug;

		};

		print STDERR "DEBUG: parsing ----------\n" if $debug;

		while(<IN>) {

			s|\R$||; # Better chomp

			if($parens > 0) {

				#Inside a DEPRECATEDIN

				$stored_multiline .= $_;

				print STDERR "DEBUG: Continuing multiline DEPRECATEDIN: $stored_multiline\n" if $debug;

				$parens = count_parens($stored_multiline);

				if ($parens == 0) {

					$def .= do_deprecated($stored_multiline,

							\@current_platforms,

							\@current_algorithms);

				}

				next;

			}

			if (/\/\* Error codes for the \w+ functions\. \*\//)

				{

				undef @tag;

				last;

				}

			if ($line ne '') {

				$_ = $line . $_;

				$line = '';

			}

			if (/\\$/) {

				$line = $`; # keep what was before the backslash

				next;

			}

			if(/\/\*/) {

				if (not /\*\//) {	# multi-line comment...

					$line = $_;	# ... just accumulate

					next;

				} else {

					s/\/\*.*?\*\///gs;# wipe it

				}

			}

			if ($cpp) {

				$cpp++ if /^#\s*if/;

				$cpp-- if /^#\s*endif/;

				next;

			}

			if (/^#.*ifdef.*cplusplus/) {

				$cpp = 1;

				next;

			}

			s/{[^{}]*}//gs;                      # ignore {} blocks

			print STDERR "DEBUG: \$def=\"$def\"\n" if $debug && $def ne "";

			print STDERR "DEBUG: \$_=\"$_\"\n" if $debug;

			if (/^\#\s*if\s+OPENSSL_API_COMPAT\s*(\S)\s*(0x[0-9a-fA-F]{8})L\s*$/) {

				my $op = $1;

				my $v = hex($2);

				if ($op ne '<' && $op ne '>=') {

				    die "$file unacceptable operator $op: $_\n";

				}

				my ($one, $major, $minor) =

				    ( ($v >> 28) & 0xf,

				      ($v >> 20) & 0xff,

				      ($v >> 12) & 0xff );

				my $t = "DEPRECATEDIN_${one}_${major}_${minor}";

				push(@tag,"-");

				push(@tag,$t);

				$tag{$t}=($op eq '<' ? 1 : -1);

				print STDERR "DEBUG: $file: found tag $t = $tag{$t}\n" if $debug;

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

				push(@tag,"-");

				push(@tag,$1);

				$tag{$1}=-1;

				print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;

			} elsif (/^\#\s*if\s+!defined\s*\(([^\)]+)\)/) {

				push(@tag,"-");

				if (/^\#\s*if\s+(!defined\s*\(([^\)]+)\)(\s+\&\&\s+!defined\s*\(([^\)]+)\))*)$/) {

					my $tmp_1 = $1;

					my $tmp_;

					foreach $tmp_ (split '\&\&',$tmp_1) {

						$tmp_ =~ /!defined\s*\(([^\)]+)\)/;

						print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;

						push(@tag,$1);

						$tag{$1}=-1;

					}

				} else {

					print STDERR "Warning: $file: taking only '!defined($1)' of complicated expression: $_" if $verbose; # because it is O...

					print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;

					push(@tag,$1);

					$tag{$1}=-1;

				}

			} elsif (/^\#\s*ifdef\s+(\S*)/) {

				push(@tag,"-");

				push(@tag,$1);

				$tag{$1}=1;

				print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;

			} elsif (/^\#\s*if\s+defined\s*\(([^\)]+)\)/) {

				push(@tag,"-");

				if (/^\#\s*if\s+(defined\s*\(([^\)]+)\)(\s+\|\|\s+defined\s*\(([^\)]+)\))*)$/) {

					my $tmp_1 = $1;

					my $tmp_;

					foreach $tmp_ (split '\|\|',$tmp_1) {

						$tmp_ =~ /defined\s*\(([^\)]+)\)/;

						print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;

						push(@tag,$1);

						$tag{$1}=1;

					}

				} else {

					print STDERR "Warning: $file: taking only 'defined($1)' of complicated expression: $_\n" if $verbose; # because it is O...

					print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;

					push(@tag,$1);

					$tag{$1}=1;

				}

			} elsif (/^\#\s*error\s+(\w+) is disabled\./) {

				my $tag_i = $#tag;

				while($tag[$tag_i] ne "-") {

					if ($tag[$tag_i] eq "OPENSSL_NO_".$1) {

						$tag{$tag[$tag_i]}=2;

						print STDERR "DEBUG: $file: changed tag $1 = 2\n" if $debug;

					}

					$tag_i--;

				}

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

				my $tag_i = $#tag;

				while($tag_i > 0 && $tag[$tag_i] ne "-") {

					my $t=$tag[$tag_i];

					print STDERR "DEBUG: \$t=\"$t\"\n" if $debug;

					if ($tag{$t}==2) {

						$tag{$t}=-1;

					} else {

						$tag{$t}=0;

					}

					print STDERR "DEBUG: $file: changed tag ",$t," = ",$tag{$t},"\n" if $debug;

					pop(@tag);

					if ($t =~ /^OPENSSL_NO_([A-Z0-9_]+)$/) {

						$t=$1;

					} elsif($t =~ /^OPENSSL_USE_([A-Z0-9_]+)$/) {

						$t=$1;

					} else {

						$t="";

					}

					if ($t ne ""

					    && !grep(/^$t$/, @known_algorithms)) {

						$unknown_algorithms{$t} = 1;

						#print STDERR "DEBUG: Added as unknown algorithm: $t\n" if $debug;

					}

					$tag_i--;

				}

				pop(@tag);

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

				my $tag_i = $#tag;

				die "$file unmatched else\n" if $tag_i < 0;

				while($tag[$tag_i] ne "-") {

					my $t=$tag[$tag_i];

					$tag{$t}= -$tag{$t};

					print STDERR "DEBUG: $file: changed tag ",$t," = ",$tag{$t},"\n" if $debug;

					$tag_i--;

				}

			} elsif (/^\#\s*if\s+1/) {

				push(@tag,"-");

				# Dummy tag

				push(@tag,"TRUE");

				$tag{"TRUE"}=1;

				print STDERR "DEBUG: $file: found 1\n" if $debug;

			} elsif (/^\#\s*if\s+0/) {

				push(@tag,"-");

				# Dummy tag

				push(@tag,"TRUE");

				$tag{"TRUE"}=-1;

				print STDERR "DEBUG: $file: found 0\n" if $debug;

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

				#Some other unrecognized "if" style

				push(@tag,"-");

				print STDERR "Warning: $file: ignoring unrecognized expression: $_\n" if $verbose; # because it is O...

			} elsif (/^\#\s*define\s+(\w+)\s+(\w+)/

				 && $symhacking && $tag{'TRUE'} != -1) {

				# This is for aliasing.  When we find an alias,

				# we have to invert

				&$make_variant($1,$2);

				print STDERR "DEBUG: $file: defined $1 = $2\n" if $debug;

			}

			if (/^\#/) {

				@current_platforms =

				    grep(!/^$/,

					 map { $tag{$_} == 1 ? $_ :

						   $tag{$_} == -1 ? "!".$_  : "" }

					 @known_platforms);

				push @current_platforms

				    , grep(!/^$/,

					   map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ :

						     $tag{"OPENSSL_SYS_".$_} == -1 ? "!".$_  : "" }

					   @known_ossl_platforms);

				@current_algorithms = ();

				@current_algorithms =

				    grep(!/^$/,

					 map { $tag{"OPENSSL_NO_".$_} == -1 ? $_ : "" }

					 @known_algorithms);

				push @current_algorithms

				    , grep(!/^$/,

					 map { $tag{"OPENSSL_USE_".$_} == 1 ? $_ : "" }

					 @known_algorithms);

				push @current_algorithms,

				    grep { /^DEPRECATEDIN_/ && $tag{$_} == 1 }

				    @known_algorithms;

				$def .=

				    "#INFO:"

					.join(',',@current_platforms).":"

					    .join(',',@current_algorithms).";";

				next;

			}

			if ($tag{'TRUE'} != -1) {

				if (/^\s*DEFINE_STACK_OF\s*\(\s*(\w*)\s*\)/

						|| /^\s*DEFINE_STACK_OF_CONST\s*\(\s*(\w*)\s*\)/) {

					next;

				} elsif (/^\s*DECLARE_ASN1_ENCODE_FUNCTIONS\s*\(\s*(\w*)\s*,\s*(\w*)\s*,\s*(\w*)\s*\)/) {

					$def .= "int d2i_$3(void);";

					$def .= "int i2d_$3(void);";

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int $2_it;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("$2_it","$2_it",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

					next;

				} elsif (/^\s*DECLARE_ASN1_FUNCTIONS_fname\s*\(\s*(\w*)\s*,\s*(\w*)\s*,\s*(\w*)\s*\)/) {

					$def .= "int d2i_$3(void);";

					$def .= "int i2d_$3(void);";

					$def .= "int $3_free(void);";

					$def .= "int $3_new(void);";

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int $2_it;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("$2_it","$2_it",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

					next;

				} elsif (/^\s*DECLARE_ASN1_FUNCTIONS\s*\(\s*(\w*)\s*\)/ ||

					 /^\s*DECLARE_ASN1_FUNCTIONS_const\s*\(\s*(\w*)\s*\)/) {

					$def .= "int d2i_$1(void);";

					$def .= "int i2d_$1(void);";

					$def .= "int $1_free(void);";

					$def .= "int $1_new(void);";

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int $1_it;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("$1_it","$1_it",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

					next;

				} elsif (/^\s*DECLARE_ASN1_ENCODE_FUNCTIONS_const\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {

					$def .= "int d2i_$2(void);";

					$def .= "int i2d_$2(void);";

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int $2_it;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("$2_it","$2_it",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

					next;

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

					$def .= "int $1_free(void);";

					$def .= "int $1_new(void);";

					next;

				} elsif (/^\s*DECLARE_ASN1_FUNCTIONS_name\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {

					$def .= "int d2i_$2(void);";

					$def .= "int i2d_$2(void);";

					$def .= "int $2_free(void);";

					$def .= "int $2_new(void);";

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int $2_it;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("$2_it","$2_it",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

					next;

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

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int $1_it;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("$1_it","$1_it",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

					next;

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

					$def .= "int i2d_$1_NDEF(void);";

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

					next;

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

					$def .= "int $1_print_ctx(void);";

					next;

				} elsif (/^\s*DECLARE_ASN1_PRINT_FUNCTION_name\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {

					$def .= "int $2_print_ctx(void);";

					next;

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

					next;

				} elsif (/^DECLARE_PEM_rw\s*\(\s*(\w*)\s*,/ ||

					 /^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ ||

					 /^DECLARE_PEM_rw_const\s*\(\s*(\w*)\s*,/ ) {

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',"STDIO",@current_algorithms).";";

					$def .= "int PEM_read_$1(void);";

					$def .= "int PEM_write_$1(void);";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Things that are everywhere

					$def .= "int PEM_read_bio_$1(void);";

					$def .= "int PEM_write_bio_$1(void);";

					next;

				} elsif (/^DECLARE_PEM_write\s*\(\s*(\w*)\s*,/ ||

					/^DECLARE_PEM_write_const\s*\(\s*(\w*)\s*,/ ||

					 /^DECLARE_PEM_write_cb\s*\(\s*(\w*)\s*,/ ) {

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',"STDIO",@current_algorithms).";";

					$def .= "int PEM_write_$1(void);";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Things that are everywhere

					$def .= "int PEM_write_bio_$1(void);";

					next;

				} elsif (/^DECLARE_PEM_read\s*\(\s*(\w*)\s*,/ ||

					 /^DECLARE_PEM_read_cb\s*\(\s*(\w*)\s*,/ ) {

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',"STDIO",@current_algorithms).";";

					$def .= "int PEM_read_$1(void);";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',"STDIO",@current_algorithms).";";

					# Things that are everywhere

					$def .= "int PEM_read_bio_$1(void);";

					next;

				} elsif (/^OPENSSL_DECLARE_GLOBAL\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {

					# Variant for platforms that do not

					# have to access global variables

					# in shared libraries through functions

					$def .=

					    "#INFO:"

						.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"

						    .join(',',@current_algorithms).";";

					$def .= "OPENSSL_EXTERN int _shadow_$2;";

					$def .=

					    "#INFO:"

						.join(',',@current_platforms).":"

						    .join(',',@current_algorithms).";";

					# Variant for platforms that have to

					# access global variables in shared

					# libraries through functions

					&$make_variant("_shadow_$2","_shadow_$2",

						      "EXPORT_VAR_AS_FUNCTION",

						      "FUNCTION");

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

					$parens = count_parens($_);

					if ($parens == 0) {

						$def .= do_deprecated($_,

							\@current_platforms,

							\@current_algorithms);

					} else {

						$stored_multiline = $_;

						print STDERR "DEBUG: Found multiline DEPRECATEDIN starting with: $stored_multiline\n" if $debug;

						next;

					}

				} elsif ($tag{'CONST_STRICT'} != 1) {

					if (/\{|\/\*|\([^\)]*$/) {

						$line = $_;

					} else {

						$def .= $_;

					}

				}

			}

		}

		close(IN);

		die "$file: Unmatched tags\n" if $#tag >= 0;

		my $algs;

		my $plays;

		print STDERR "DEBUG: postprocessing ----------\n" if $debug;

		foreach (split /;/, $def) {

			my $s; my $k = "FUNCTION"; my $p; my $a;

			s/^[\n\s]*//g;

			s/[\n\s]*$//g;

			next if(/\#undef/);

			next if(/typedef\W/);

			next if(/\#define/);

			print STDERR "TRACE: processing $_\n" if $trace && !/^\#INFO:/;

			# Reduce argument lists to empty ()

			# fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}

			my $nsubst = 1; # prevent infinite loop, e.g., on  int fn()

			while($nsubst && /\(.*\)/s) {