wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
openssl/util/mkdef.pl

1429 lines
42 KiB
Perl
Raw Normal View History

Use the same path to perl in all #! lines in util.
1999-06-07 22:48:50 +00:00
#!/usr/local/bin/perl -w
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
#
# generate a .def file
#
# It does this by parsing the header files and looking for the
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
# prototyped functions: it then prunes the output.
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
#
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# Intermediary files are created, call libeay.num and ssleay.num,...
# Previously, they had the following format:
#
# routine-name nnnn
#
# But that isn't enough for a number of reasons, the first on being that
# this format is (needlessly) very Win32-centric, and even then...
# One of the biggest problems is that there's no information about what
# routines should actually be used, which varies with what crypto algorithms
# are disabled. Also, some operating systems (for example VMS with VAX C)
# need to keep track of the global variables as well as the functions.
#
# So, a remake of this script is done so as to include information on the
# kind of symbol it is (function or variable) and what algorithms they're
# part of. This will allow easy translating to .def files or the corresponding
# file in other operating systems (a .opt file for VMS, possibly with a .mar
# file).
#
# The format now becomes:
#
# routine-name nnnn info
#
# and 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
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# symbol name variants for platforms where the names are too long for the
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# compiler or linker, or if the systems is case insensitive and there is a
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# 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
Minor typos Submitted by: jufi@nerdnet.de Reviewed by: PR: 138
2002-07-10 17:34:54 +00:00
# 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
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# used. For the positive itms, 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.
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# - "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.
#
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
my $debug=0;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $crypto_num= "util/libeay.num";
my $ssl_num= "util/ssleay.num";
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
my $libname;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
my $do_update = 0;
When doing rewrites on ssleay.num, the file was prematurely closed. Make rewrites the default, since it works, and people get confused if changed information doesn't get rewritten automagically.
2001-05-13 04:48:07 +00:00
my $do_rewrite = 1;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
my $do_crypto = 0;
my $do_ssl = 0;
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $do_ctest = 0;
New option 'ctestall' for mkdef.pl, that makes it not only generate existing functions, but really all functions that exist in libeay.num and ssleay.num. This is a good check on how much we should actually clean up the number files.
2000-08-17 21:26:22 +00:00
my $do_ctestall = 0;
Various updates to mkdef.pl to cope with new aes and ASN1 code.
2001-02-09 13:16:21 +00:00
my $do_checkexist = 0;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $VMSVAX=0;
my $VMSAlpha=0;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $VMS=0;
my $W32=0;
my $W16=0;
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $NT=0;
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
my $OS2=0;
Add some utilities to support SXNet extension also add support in DEF files generator to typesafe stacks.
1999-04-14 23:44:41 +00:00
# Set this to make typesafe STACK definitions appear in DEF
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
my $safe_stack_def = 0;
mk1mf.pl and mkdef.pl read OPTIONS from toplevel Makefile. Configure no longer changes files in place.
1999-05-13 10:28:14 +00:00
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my @known_platforms = ( "__FreeBSD__", "PERL5", "NeXT",
"EXPORT_VAR_AS_FUNCTION" );
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
my @known_ossl_platforms = ( "VMS", "WIN16", "WIN32", "WINNT", "OS2" );
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my @known_algorithms = ( "RC2", "RC4", "RC5", "IDEA", "DES", "BF",
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
"CAST", "MD2", "MD4", "MD5", "SHA", "SHA0", "SHA1",
Add SHA256 and SHA512 algorithms to mkdef.pl. Fix mkdef.pl script to avoid infinite loop when parsing sha.h.
2004-05-19 17:03:59 +00:00
"SHA256", "SHA512", "RIPEMD",
Add ECDH support. Additional changes: - use EC_GROUP_get_degree() in apps/req.c - add ECDSA and ECDH to apps/speed.c - adds support for EC curves over binary fields to ECDSA - new function EC_KEY_up_ref() in crypto/ec/ec_key.c - reorganize crypto/ecdsa/ecdsatest.c - add engine support for ECDH - fix a few bugs in ECDSA engine support Submitted by: Douglas Stebila <douglas.stebila@sun.com>
2002-08-09 08:43:04 +00:00
"MDC2", "RSA", "DSA", "DH", "EC", "ECDH", "ECDSA", "HMAC", "AES",
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
# Envelope "algorithms"
"EVP", "X509", "ASN1_TYPEDEFS",
# Helper "algorithms"
"BIO", "COMP", "BUFFER", "LHASH", "STACK", "ERR",
"LOCKING",
# External "algorithms"
let mkdef.pl know about OPENSSL_NO_DGRAM (which appears in the new file crypto/bio/bss_dgram.c)
2005-04-26 18:21:25 +00:00
"FP_API", "STDIO", "SOCK", "KRB5", "DGRAM",
For the mkdef.pl to recognise if the "external" engines are inserted into libcrypto, we need the "algorithm" STATIC_ENGINE.
2002-10-24 19:09:03 +00:00
# Engines
New "algorithm define" OPENSSL_NO_GMP. Update mkdef.pl and Configure script to use it.
2005-04-19 13:24:44 +00:00
"STATIC_ENGINE", "ENGINE", "HW", "GMP",
Hmm, Geoff's change made things quite interesting. We can now give users the option of disabling deprecated functions, which should of course be reflected in libeay.num and .def files. Quite nice, actually.
2002-12-09 02:18:16 +00:00
# Deprecated functions
"DEPRECATED" );
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $options="";
Makefile.ssl -> Makefile
2005-04-13 19:09:43 +00:00
open(IN,"<Makefile") || die "unable to open Makefile!\n";
mk1mf.pl and mkdef.pl read OPTIONS from toplevel Makefile. Configure no longer changes files in place.
1999-05-13 10:28:14 +00:00
while(<IN>) {
$options=$1 if (/^OPTIONS=(.*)$/);
}
Oops. Close the file.
1999-05-13 17:24:35 +00:00
close(IN);
mk1mf.pl and mkdef.pl read OPTIONS from toplevel Makefile. Configure no longer changes files in place.
1999-05-13 10:28:14 +00:00
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
# The following ciphers may be excluded (by Configure). This means functions
# defined with ifndef(NO_XXX) are not included in the .def file, and everything
# in directory xxx is ignored.
my $no_rc2; my $no_rc4; my $no_rc5; my $no_idea; my $no_des; my $no_bf;
MD4 implemented. Assar Westerlund provided the digest code itself and the test utility, I added the bits to get a EVP interface, the command line utility and the speed test
2000-08-14 14:05:53 +00:00
my $no_cast;
my $no_md2; my $no_md4; my $no_md5; my $no_sha; my $no_ripemd; my $no_mdc2;
Various Win32 related fixed. Make no-krb5 work in mkdef.pl . Fix warning in apps/engine.c Remove definitions of deleted functions. Add missing definition of X509_VAL.
2001-02-09 18:16:12 +00:00
my $no_rsa; my $no_dsa; my $no_dh; my $no_hmac=0; my $no_aes; my $no_krb5;
The util scripts need to handled no-hw. PR: 327
2003-01-30 20:03:45 +00:00
my $no_ec; my $no_ecdsa; my $no_ecdh; my $no_engine; my $no_hw;
New "algorithm define" OPENSSL_NO_GMP. Update mkdef.pl and Configure script to use it.
2005-04-19 13:24:44 +00:00
my $no_fp_api; my $no_static_engine; my $no_gmp; my $no_deprecated;
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
mk1mf.pl and mkdef.pl read OPTIONS from toplevel Makefile. Configure no longer changes files in place.
1999-05-13 10:28:14 +00:00
foreach (@ARGV, split(/ /, $options))
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
{
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$debug=1 if $_ eq "debug";
Fix the Win32 compile environment and add various changes so it will now compile under Win32 (9X and NT) again. Note: some signed/unsigned changes recently checked in were killing the Win32 compile.
1999-03-03 02:01:26 +00:00
$W32=1 if $_ eq "32";
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$W16=1 if $_ eq "16";
Fix the Win32 compile environment and add various changes so it will now compile under Win32 (9X and NT) again. Note: some signed/unsigned changes recently checked in were killing the Win32 compile.
1999-03-03 02:01:26 +00:00
if($_ eq "NT") {
$W32 = 1;
$NT = 1;
}
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if ($_ eq "VMS-VAX") {
$VMS=1;
$VMSVAX=1;
}
if ($_ eq "VMS-Alpha") {
$VMS=1;
$VMSAlpha=1;
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$VMS=1 if $_ eq "VMS";
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
$OS2=1 if $_ eq "OS2";
mkdef.pl still needed better logic. Also, the semantics of the platforms list is clarified (it's however not quite followed in the RSAREF case...). RSAREF is also checked now.
2000-09-11 20:04:58 +00:00
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$do_ssl=1 if $_ eq "ssleay";
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if ($_ eq "ssl") {
$do_ssl=1;
$libname=$_
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$do_crypto=1 if $_ eq "libeay";
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if ($_ eq "crypto") {
$do_crypto=1;
$libname=$_;
}
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
$do_update=1 if $_ eq "update";
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$do_rewrite=1 if $_ eq "rewrite";
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
$do_ctest=1 if $_ eq "ctest";
New option 'ctestall' for mkdef.pl, that makes it not only generate existing functions, but really all functions that exist in libeay.num and ssleay.num. This is a good check on how much we should actually clean up the number files.
2000-08-17 21:26:22 +00:00
$do_ctestall=1 if $_ eq "ctestall";
Various updates to mkdef.pl to cope with new aes and ASN1 code.
2001-02-09 13:16:21 +00:00
$do_checkexist=1 if $_ eq "exist";
First of all, with the current macros, we should never get any type-specific stack function. Second, even when we don't build any of those functions, DECLARE_STACK_OF lines should not find themselves into $def.
2000-06-18 14:06:40 +00:00
#$safe_stack_def=1 if $_ eq "-DDEBUG_SAFESTACK";
no-xxx option to exclude ciphers.
1999-05-08 10:42:06 +00:00
if (/^no-rc2$/) { $no_rc2=1; }
elsif (/^no-rc4$/) { $no_rc4=1; }
elsif (/^no-rc5$/) { $no_rc5=1; }
elsif (/^no-idea$/) { $no_idea=1; }
When creating a .def file, be a bit more selective so disabled algorithms do not get in...
2000-09-25 10:21:23 +00:00
elsif (/^no-des$/) { $no_des=1; $no_mdc2=1; }
no-xxx option to exclude ciphers.
1999-05-08 10:42:06 +00:00
elsif (/^no-bf$/) { $no_bf=1; }
elsif (/^no-cast$/) { $no_cast=1; }
elsif (/^no-md2$/) { $no_md2=1; }
MD4 implemented. Assar Westerlund provided the digest code itself and the test utility, I added the bits to get a EVP interface, the command line utility and the speed test
2000-08-14 14:05:53 +00:00
elsif (/^no-md4$/) { $no_md4=1; }
no-xxx option to exclude ciphers.
1999-05-08 10:42:06 +00:00
elsif (/^no-md5$/) { $no_md5=1; }
elsif (/^no-sha$/) { $no_sha=1; }
elsif (/^no-ripemd$/) { $no_ripemd=1; }
elsif (/^no-mdc2$/) { $no_mdc2=1; }
elsif (/^no-rsa$/) { $no_rsa=1; }
elsif (/^no-dsa$/) { $no_dsa=1; }
elsif (/^no-dh$/) { $no_dh=1; }
Add the 'ec' directory to mkdef.pl and mkfiles.pl so the Windows build can see it. Fixup mkdef.pl so it doesn't mess up with function names longer than 39 characters in length.
2001-03-10 01:56:48 +00:00
elsif (/^no-ec$/) { $no_ec=1; }
ECDSA support Submitted by: Nils Larsch <nla@trustcenter.de>
2002-02-13 18:21:51 +00:00
elsif (/^no-ecdsa$/) { $no_ecdsa=1; }
Add ECDH support. Additional changes: - use EC_GROUP_get_degree() in apps/req.c - add ECDSA and ECDH to apps/speed.c - adds support for EC curves over binary fields to ECDSA - new function EC_KEY_up_ref() in crypto/ec/ec_key.c - reorganize crypto/ecdsa/ecdsatest.c - add engine support for ECDH - fix a few bugs in ECDSA engine support Submitted by: Douglas Stebila <douglas.stebila@sun.com>
2002-08-09 08:43:04 +00:00
elsif (/^no-ecdh$/) { $no_ecdh=1; }
no-xxx option to exclude ciphers.
1999-05-08 10:42:06 +00:00
elsif (/^no-hmac$/) { $no_hmac=1; }
Various updates to mkdef.pl to cope with new aes and ASN1 code.
2001-02-09 13:16:21 +00:00
elsif (/^no-aes$/) { $no_aes=1; }
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
elsif (/^no-evp$/) { $no_evp=1; }
elsif (/^no-lhash$/) { $no_lhash=1; }
elsif (/^no-stack$/) { $no_stack=1; }
elsif (/^no-err$/) { $no_err=1; }
elsif (/^no-buffer$/) { $no_buffer=1; }
elsif (/^no-bio$/) { $no_bio=1; }
#elsif (/^no-locking$/) { $no_locking=1; }
elsif (/^no-comp$/) { $no_comp=1; }
elsif (/^no-dso$/) { $no_dso=1; }
Various Win32 related fixed. Make no-krb5 work in mkdef.pl . Fix warning in apps/engine.c Remove definitions of deleted functions. Add missing definition of X509_VAL.
2001-02-09 18:16:12 +00:00
elsif (/^no-krb5$/) { $no_krb5=1; }
Add the possibility to build without the ENGINE framework. PR: 287
2003-01-30 17:39:26 +00:00
elsif (/^no-engine$/) { $no_engine=1; }
The util scripts need to handled no-hw. PR: 327
2003-01-30 20:03:45 +00:00
elsif (/^no-hw$/) { $no_hw=1; }
New "algorithm define" OPENSSL_NO_GMP. Update mkdef.pl and Configure script to use it.
2005-04-19 13:24:44 +00:00
elsif (/^no-gmp$/) { $no_gmp=1; }
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if (!$libname) {
if ($do_ssl) {
$libname="SSLEAY";
}
if ($do_crypto) {
$libname="LIBEAY";
}
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# If no platform is given, assume WIN32
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if ($W32 + $W16 + $VMS + $OS2 == 0) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$W32 = 1;
}
# Add extra knowledge
if ($W16) {
$no_fp_api=1;
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
if (!$do_ssl && !$do_crypto)
{
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT | OS2 ]\n";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
exit(1);
}
%ssl_list=&load_numbers($ssl_num);
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
$max_ssl = $max_num;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
%crypto_list=&load_numbers($crypto_num);
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
$max_crypto = $max_num;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $ssl="ssl/ssl.h";
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
$ssl.=" ssl/kssl.h";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $crypto ="crypto/crypto.h";
Because it's one of our libraries calling new functions in the other, we need to have them among the symbols that should appear in the transfer table, at least on VMS (and it wouldn't surprise me if Windows would whine as well).
2004-07-12 11:24:55 +00:00
$crypto.=" crypto/o_dir.h";
Due to an increasing number of clashes between modern OpenSSL and libdes (which is still used out there) or other des implementations, the OpenSSL DES functions are renamed to begin with DES_ instead of des_. Compatibility routines are provided and declared by including openssl/des_old.h. Those declarations are the same as were in des.h when the OpenSSL project started, which is exactly how libdes looked at that time, and hopefully still looks today. The compatibility functions will be removed in some future release, at the latest in version 1.0.
2001-10-24 21:21:12 +00:00
$crypto.=" crypto/des/des.h crypto/des/des_old.h" ; # unless $no_des;
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/idea/idea.h" ; # unless $no_idea;
$crypto.=" crypto/rc4/rc4.h" ; # unless $no_rc4;
$crypto.=" crypto/rc5/rc5.h" ; # unless $no_rc5;
$crypto.=" crypto/rc2/rc2.h" ; # unless $no_rc2;
$crypto.=" crypto/bf/blowfish.h" ; # unless $no_bf;
$crypto.=" crypto/cast/cast.h" ; # unless $no_cast;
$crypto.=" crypto/md2/md2.h" ; # unless $no_md2;
$crypto.=" crypto/md4/md4.h" ; # unless $no_md4;
$crypto.=" crypto/md5/md5.h" ; # unless $no_md5;
$crypto.=" crypto/mdc2/mdc2.h" ; # unless $no_mdc2;
$crypto.=" crypto/sha/sha.h" ; # unless $no_sha;
$crypto.=" crypto/ripemd/ripemd.h" ; # unless $no_ripemd;
Because Rijndael is more known as AES, use crypto/aes instead of crypto/rijndael. Additionally, I applied the AES integration patch from Stephen Sprunk <stephen@sprunk.org> and fiddled it to work properly with the normal EVP constructs (and incidently work the same way as all other symmetric cipher implementations). This results in an API that looks a lot like the rest of the OpenSSL cipher suite.
2002-01-02 16:55:35 +00:00
$crypto.=" crypto/aes/aes.h" ; # unless $no_aes;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/bn/bn.h";
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/rsa/rsa.h" ; # unless $no_rsa;
$crypto.=" crypto/dsa/dsa.h" ; # unless $no_dsa;
$crypto.=" crypto/dh/dh.h" ; # unless $no_dh;
$crypto.=" crypto/ec/ec.h" ; # unless $no_ec;
ECDSA support Submitted by: Nils Larsch <nla@trustcenter.de>
2002-02-13 18:21:51 +00:00
$crypto.=" crypto/ecdsa/ecdsa.h" ; # unless $no_ecdsa;
Add ECDH support. Additional changes: - use EC_GROUP_get_degree() in apps/req.c - add ECDSA and ECDH to apps/speed.c - adds support for EC curves over binary fields to ECDSA - new function EC_KEY_up_ref() in crypto/ec/ec_key.c - reorganize crypto/ecdsa/ecdsatest.c - add engine support for ECDH - fix a few bugs in ECDSA engine support Submitted by: Douglas Stebila <douglas.stebila@sun.com>
2002-08-09 08:43:04 +00:00
$crypto.=" crypto/ecdh/ecdh.h" ; # unless $no_ecdh;
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/hmac/hmac.h" ; # unless $no_hmac;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Add the possibility to build without the ENGINE framework. PR: 287
2003-01-30 17:39:26 +00:00
$crypto.=" crypto/engine/engine.h"; # unless $no_engine;
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/stack/stack.h" ; # unless $no_stack;
$crypto.=" crypto/buffer/buffer.h" ; # unless $no_buffer;
$crypto.=" crypto/bio/bio.h" ; # unless $no_bio;
$crypto.=" crypto/dso/dso.h" ; # unless $no_dso;
$crypto.=" crypto/lhash/lhash.h" ; # unless $no_lhash;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/conf/conf.h";
$crypto.=" crypto/txt_db/txt_db.h";
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/evp/evp.h" ; # unless $no_evp;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/objects/objects.h";
$crypto.=" crypto/pem/pem.h";
#$crypto.=" crypto/meth/meth.h";
$crypto.=" crypto/asn1/asn1.h";
Make mkdef.pl parse some ASN1 IMPLEMENT macros. Initial support for variables in DEF files.
2000-12-16 01:19:24 +00:00
$crypto.=" crypto/asn1/asn1t.h";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/asn1/asn1_mac.h";
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/err/err.h" ; # unless $no_err;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/pkcs7/pkcs7.h";
Include pkcs12 program as part of openssl. This completes most of the PKCS#12 integration.
1999-03-29 17:50:26 +00:00
$crypto.=" crypto/pkcs12/pkcs12.h";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/x509/x509.h";
$crypto.=" crypto/x509/x509_vfy.h";
Update STATUS, modify ssl.h so mkdef.pl will pick up prototypes and add x509v3.h to mkdef.pl list of include files.
1999-01-30 17:35:01 +00:00
$crypto.=" crypto/x509v3/x509v3.h";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
$crypto.=" crypto/rand/rand.h";
We shouldn't skip over header files to avoid functions of disabled algorithms. The selection is done in a different way
2001-04-26 12:01:12 +00:00
$crypto.=" crypto/comp/comp.h" ; # unless $no_comp;
The majority of the OCSP code from CertCo.
2000-10-27 11:05:35 +00:00
$crypto.=" crypto/ocsp/ocsp.h";
When doing rewrites on ssleay.num, the file was prematurely closed. Make rewrites the default, since it works, and people get confused if changed information doesn't get rewritten automagically.
2001-05-13 04:48:07 +00:00
$crypto.=" crypto/ui/ui.h crypto/ui/ui_compat.h";
Make sure crypto/krb5/krb5_asn.h becomes part of libeay.num.
2001-07-11 15:14:22 +00:00
$crypto.=" crypto/krb5/krb5_asn.h";
Import of old SSLeay release: SSLeay 0.9.1b (unreleased)
1998-12-21 11:00:56 +00:00
$crypto.=" crypto/tmdiff.h";
Define a STORE type. For documentation, read the entry in CHANGES, crypto/store/README, crypto/store/store.h and crypto/store/str_locl.h.
2003-05-01 03:53:12 +00:00
$crypto.=" crypto/store/store.h";
Lots of Win32 fixes for DTLS. 1. "unsigned long long" isn't portable changed: to BN_ULLONG. 2. The LL prefix isn't allowed in VC++ but it isn't needed where it is used. 2. Avoid lots of compiler warnings about signed/unsigned mismatches. 3. Include new library directory pqueue in mk1mf build system. 4. Update symbols.
2005-04-27 16:27:14 +00:00
$crypto.=" crypto/pqueue/pqueue.h";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $symhacks="crypto/symhacks.h";
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my @ssl_symbols = &do_defs("SSLEAY", $ssl, $symhacks);
my @crypto_symbols = &do_defs("LIBEAY", $crypto, $symhacks);
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
if ($do_update) {
if ($do_ssl == 1) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
&maybe_add_info("SSLEAY",*ssl_list,@ssl_symbols);
if ($do_rewrite == 1) {
open(OUT, ">$ssl_num");
&rewrite_numbers(*OUT,"SSLEAY",*ssl_list,@ssl_symbols);
} else {
open(OUT, ">>$ssl_num");
}
&update_numbers(*OUT,"SSLEAY",*ssl_list,$max_ssl,@ssl_symbols);
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
close OUT;
}
if($do_crypto == 1) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
&maybe_add_info("LIBEAY",*crypto_list,@crypto_symbols);
if ($do_rewrite == 1) {
open(OUT, ">$crypto_num");
&rewrite_numbers(*OUT,"LIBEAY",*crypto_list,@crypto_symbols);
} else {
open(OUT, ">>$crypto_num");
}
&update_numbers(*OUT,"LIBEAY",*crypto_list,$max_crypto,@crypto_symbols);
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
close OUT;
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
}
Various updates to mkdef.pl to cope with new aes and ASN1 code.
2001-02-09 13:16:21 +00:00
} elsif ($do_checkexist) {
&check_existing(*ssl_list, @ssl_symbols)
if $do_ssl == 1;
&check_existing(*crypto_list, @crypto_symbols)
if $do_crypto == 1;
New option 'ctestall' for mkdef.pl, that makes it not only generate existing functions, but really all functions that exist in libeay.num and ssleay.num. This is a good check on how much we should actually clean up the number files.
2000-08-17 21:26:22 +00:00
} elsif ($do_ctest || $do_ctestall) {
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
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
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
&print_test_file(*STDOUT,"SSLEAY",*ssl_list,$do_ctestall,@ssl_symbols)
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
if $do_ssl == 1;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
&print_test_file(*STDOUT,"LIBEAY",*crypto_list,$do_ctestall,@crypto_symbols)
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
if $do_crypto == 1;
print "}\n";
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
} else {
no-xxx option to exclude ciphers.
1999-05-08 10:42:06 +00:00
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
&print_def_file(*STDOUT,$libname,*ssl_list,@ssl_symbols)
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
if $do_ssl == 1;
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
&print_def_file(*STDOUT,$libname,*crypto_list,@crypto_symbols)
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
if $do_crypto == 1;
no-xxx option to exclude ciphers.
1999-05-08 10:42:06 +00:00
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
sub do_defs
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
{
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my($name,$files,$symhacksfile)=@_;
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $file;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
my @ret;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my %syms;
my %platform; # For anything undefined, we assume ""
my %kind; # For anything undefined, we assume "FUNCTION"
my %algorithm; # For anything undefined, we assume ""
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my %variant;
my %variant_cnt; # To be able to allocate "name{n}" if "name"
# is the same name as the original.
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $cpp;
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
my %unknown_algorithms = ();
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
foreach $file (split(/\s+/,$symhacksfile." ".$files))
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
{
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
print STDERR "DEBUG: starting on $file:\n" if $debug;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
open(IN,"<$file") || die "unable to open $file:$!\n";
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $line = "", my $def= "";
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
my %tag = (
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
(map { $_ => 0 } @known_platforms),
(map { "OPENSSL_SYS_".$_ => 0 } @known_ossl_platforms),
Make all configuration macros available for application by making sure they are available in opensslconf.h, by giving them names starting with "OPENSSL_" to avoid conflicts with other packages and by making sure e_os2.h will cover all platform-specific cases together with opensslconf.h. I've checked fairly well that nothing breaks with this (apart from external software that will adapt if they have used something like NO_KRB5), but I can't guarantee it completely, so a review of this change would be a good thing.
2001-02-19 16:06:34 +00:00
(map { "OPENSSL_NO_".$_ => 0 } @known_algorithms),
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
NOPROTO => 0,
PERL5 => 0,
_WINDLL => 0,
CONST_STRICT => 0,
TRUE => 1,
);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $symhacking = $file eq $symhacksfile;
Do not insert things in syms{} and kind{} when parsing the header files. Instead, insert proper information in the $def string, which will be properly munged later on.
2001-02-19 13:33:04 +00:00
my @current_platforms = ();
my @current_algorithms = ();
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# params: symbol, alias, platforms, kind
# The reason to put this subroutine in a variable is that
# it will otherwise create it's 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}}";
}
Sort platforms lexicographically as well. Also, support more than two variants of a symbol.
2001-03-02 12:14:54 +00:00
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;
}
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: make_variant: Exit with variant of ",$s," = ",$variant{$s},"\n" if $debug;
};
print STDERR "DEBUG: parsing ----------\n" if $debug;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
while(<IN>) {
Stop perl warning.
2005-04-19 18:57:17 +00:00
if (/\/\* Error codes for the \w+ functions\. \*\//)
{
undef @tag;
last;
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
if ($line ne '') {
$_ = $line . $_;
$line = '';
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
if (/\\$/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
chomp; # remove eol
chop; # remove ending backslash
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
$line = $_;
next;
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$cpp = 1 if /^\#.*ifdef.*cplusplus/;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
if ($cpp) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$cpp = 0 if /^\#.*endif/;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
next;
}
s/\/\*.*?\*\///gs; # ignore comments
Sometimes, we have partial comments on the same line as other stuff we parse. Make sure to read in the whole comment, so it can be entirely removed.
2003-03-20 23:51:35 +00:00
if (/\/\*/) { # if we have part
$line = $_; # of a comment,
next; # continue reading
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
s/{[^{}]*}//gs; # ignore {} blocks
For the mkdef.pl to recognise if the "external" engines are inserted into libcrypto, we need the "algorithm" STATIC_ENGINE.
2002-10-24 19:09:03 +00:00
print STDERR "DEBUG: \$def=\"$def\"\n" if $debug && $def ne "";
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
print STDERR "DEBUG: \$_=\"$_\"\n" if $debug;
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
if (/^\#\s*ifndef\s+(.*)/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push(@tag,"-");
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
push(@tag,$1);
$tag{$1}=-1;
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
} elsif (/^\#\s*if\s+!defined\(([^\)]+)\)/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push(@tag,"-");
if (/^\#\s*if\s+(!defined\(([^\)]+)\)(\s+\&\&\s+!defined\(([^\)]+)\))*)$/) {
my $tmp_1 = $1;
my $tmp_;
foreach $tmp_ (split '\&\&',$tmp_1) {
$tmp_ =~ /!defined\(([^\)]+)\)/;
print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
push(@tag,$1);
$tag{$1}=-1;
}
} else {
print STDERR "Warning: $file: complicated expression: $_" if $debug; # because it is O...
print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
push(@tag,$1);
$tag{$1}=-1;
}
In mkdef.pl ignore trailing whitespace in #ifdef lines
2005-02-05 17:22:14 +00:00
} elsif (/^\#\s*ifdef\s+(\S*)/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push(@tag,"-");
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
push(@tag,$1);
$tag{$1}=1;
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
} elsif (/^\#\s*if\s+defined\(([^\)]+)\)/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push(@tag,"-");
if (/^\#\s*if\s+(defined\(([^\)]+)\)(\s+\|\|\s+defined\(([^\)]+)\))*)$/) {
my $tmp_1 = $1;
my $tmp_;
foreach $tmp_ (split '\|\|',$tmp_1) {
$tmp_ =~ /defined\(([^\)]+)\)/;
print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
push(@tag,$1);
$tag{$1}=1;
}
} else {
print STDERR "Warning: $file: complicated expression: $_\n" if $debug; # because it is O...
print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
push(@tag,$1);
$tag{$1}=1;
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
} elsif (/^\#\s*error\s+(\w+) is disabled\./) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
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: chaged tag $1 = 2\n" if $debug;
}
$tag_i--;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
} elsif (/^\#\s*endif/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
my $tag_i = $#tag;
Add SHA256 and SHA512 algorithms to mkdef.pl. Fix mkdef.pl script to avoid infinite loop when parsing sha.h.
2004-05-19 17:03:59 +00:00
while($tag_i > 0 && $tag[$tag_i] ne "-") {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
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;
} 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--;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
pop(@tag);
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
} elsif (/^\#\s*else/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
my $tag_i = $#tag;
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--;
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
} elsif (/^\#\s*if\s+1/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push(@tag,"-");
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
# Dummy tag
push(@tag,"TRUE");
$tag{"TRUE"}=1;
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
print STDERR "DEBUG: $file: found 1\n" if $debug;
Handle "#if 0" correctly (I hope)
1999-09-03 13:30:47 +00:00
} elsif (/^\#\s*if\s+0/) {
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push(@tag,"-");
Handle "#if 0" correctly (I hope)
1999-09-03 13:30:47 +00:00
# Dummy tag
push(@tag,"TRUE");
$tag{"TRUE"}=-1;
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
print STDERR "DEBUG: $file: found 0\n" if $debug;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
} elsif (/^\#\s*define\s+(\w+)\s+(\w+)/
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
&& $symhacking && $tag{'TRUE'} != -1) {
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# 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;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
if (/^\#/) {
Do not insert things in syms{} and kind{} when parsing the header files. Instead, insert proper information in the $def string, which will be properly munged later on.
2001-02-19 13:33:04 +00:00
@current_platforms =
grep(!/^$/,
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
map { $tag{$_} == 1 ? $_ :
$tag{$_} == -1 ? "!".$_ : "" }
Do not insert things in syms{} and kind{} when parsing the header files. Instead, insert proper information in the $def string, which will be properly munged later on.
2001-02-19 13:33:04 +00:00
@known_platforms);
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
push @current_platforms
, grep(!/^$/,
map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ :
$tag{"OPENSSL_SYS_".$_} == -1 ? "!".$_ : "" }
@known_ossl_platforms);
Do not insert things in syms{} and kind{} when parsing the header files. Instead, insert proper information in the $def string, which will be properly munged later on.
2001-02-19 13:33:04 +00:00
@current_algorithms =
grep(!/^$/,
Make all configuration macros available for application by making sure they are available in opensslconf.h, by giving them names starting with "OPENSSL_" to avoid conflicts with other packages and by making sure e_os2.h will cover all platform-specific cases together with opensslconf.h. I've checked fairly well that nothing breaks with this (apart from external software that will adapt if they have used something like NO_KRB5), but I can't guarantee it completely, so a review of this change would be a good thing.
2001-02-19 16:06:34 +00:00
map { $tag{"OPENSSL_NO_".$_} == -1 ? $_ : "" }
Do not insert things in syms{} and kind{} when parsing the header files. Instead, insert proper information in the $def string, which will be properly munged later on.
2001-02-19 13:33:04 +00:00
@known_algorithms);
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
next;
}
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
if ($tag{'TRUE'} != -1) {
if (/^\s*DECLARE_STACK_OF\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);";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Variant for platforms that do not
# have to access globale variables
# in shared libraries through functions
$def .=
"#INFO:"
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
.join(',',@current_algorithms).";";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$def .= "OPENSSL_EXTERN int $2_it;";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Variant for platforms that have to
# access globale variables in shared
# libraries through functions
&$make_variant("$2_it","$2_it",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
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);";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Variant for platforms that do not
# have to access globale variables
# in shared libraries through functions
$def .=
"#INFO:"
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
.join(',',@current_algorithms).";";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$def .= "OPENSSL_EXTERN int $2_it;";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Variant for platforms that have to
# access globale variables in shared
# libraries through functions
&$make_variant("$2_it","$2_it",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
next;
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
} 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);";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Variant for platforms that do not
# have to access globale variables
# in shared libraries through functions
$def .=
"#INFO:"
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
.join(',',@current_algorithms).";";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$def .= "OPENSSL_EXTERN int $1_it;";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Variant for platforms that have to
# access globale variables in shared
# libraries through functions
&$make_variant("$1_it","$1_it",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
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);";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Variant for platforms that do not
# have to access globale variables
# in shared libraries through functions
$def .=
"#INFO:"
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
.join(',',@current_algorithms).";";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$def .= "OPENSSL_EXTERN int $2_it;";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Variant for platforms that have to
# access globale variables in shared
# libraries through functions
&$make_variant("$2_it","$2_it",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
next;
New ASN1 macros to just implement and declare the new and free functions and changes to mkdef.pl so it recognises them. Use these in policyMappings extension.
2003-03-20 17:58:33 +00:00
} elsif (/^\s*DECLARE_ASN1_ALLOC_FUNCTIONS\s*\(\s*(\w*)\s*\)/) {
$def .= "int $1_free(void);";
$def .= "int $1_new(void);";
next;
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
} 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);";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Variant for platforms that do not
# have to access globale variables
# in shared libraries through functions
$def .=
"#INFO:"
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
.join(',',@current_algorithms).";";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$def .= "OPENSSL_EXTERN int $2_it;";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Variant for platforms that have to
# access globale variables in shared
# libraries through functions
&$make_variant("$2_it","$2_it",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
next;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
} elsif (/^\s*DECLARE_ASN1_ITEM\s*\(\s*(\w*)\s*\)/) {
# Variant for platforms that do not
# have to access globale variables
# in shared libraries through functions
$def .=
"#INFO:"
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
.join(',',@current_algorithms).";";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$def .= "OPENSSL_EXTERN int $1_it;";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Variant for platforms that have to
# access globale variables in shared
# libraries through functions
&$make_variant("$1_it","$1_it",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
next;
Update mkdef.pl to handle new ASN1 macro
2002-10-04 20:24:50 +00:00
} elsif (/^\s*DECLARE_ASN1_NDEF_FUNCTION\s*\(\s*(\w*)\s*\)/) {
Typo.
2002-10-05 01:38:58 +00:00
$def .= "int i2d_$1_NDEF(void);";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
} elsif (/^\s*DECLARE_ASN1_SET_OF\s*\(\s*(\w*)\s*\)/) {
next;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
} elsif (/^\s*DECLARE_PKCS12_STACK_OF\s*\(\s*(\w*)\s*\)/) {
next;
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
} elsif (/^DECLARE_PEM_rw\s*\(\s*(\w*)\s*,/ ||
/^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ ) {
# Things not in Win16
$def .=
"#INFO:"
.join(',',"!WIN16",@current_platforms).":"
.join(',',@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_cb\s*\(\s*(\w*)\s*,/ ) {
# Things not in Win16
$def .=
"#INFO:"
.join(',',"!WIN16",@current_platforms).":"
.join(',',@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*,/ ) {
# Things not in Win16
$def .=
"#INFO:"
.join(',',"!WIN16",@current_platforms).":"
.join(',',@current_algorithms).";";
$def .= "int PEM_read_$1(void);";
$def .=
"#INFO:"
.join(',',@current_platforms).":"
.join(',',@current_algorithms).";";
# Things that are everywhere
$def .= "int PEM_read_bio_$1(void);";
next;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
} elsif (/^OPENSSL_DECLARE_GLOBAL\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
# Variant for platforms that do not
# have to access globale 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 globale variables in shared
# libraries through functions
&$make_variant("_shadow_$2","_shadow_$2",
"EXPORT_VAR_AS_FUNCTION",
"FUNCTION");
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
} elsif ($tag{'CONST_STRICT'} != 1) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if (/\{|\/\*|\([^\)]*$/) {
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
$line = $_;
} else {
$def .= $_;
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
}
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
close(IN);
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $algs;
my $plays;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: postprocessing ----------\n" if $debug;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
foreach (split /;/, $def) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $s; my $k = "FUNCTION"; my $p; my $a;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
s/^[\n\s]*//g;
s/[\n\s]*$//g;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
next if(/\#undef/);
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
next if(/typedef\W/);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
next if(/\#define/);
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: \$_ = \"$_\"\n" if $debug;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if (/^\#INFO:([^:]*):(.*)$/) {
$plats = $1;
$algs = $2;
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
print STDERR "DEBUG: found info on platforms ($plats) and algorithms ($algs)\n" if $debug;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
next;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
} elsif (/^\s*OPENSSL_EXTERN\s.*?(\w+(\{[0-9]+\})?)(\[[0-9]*\])*\s*$/) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$s = $1;
$k = "VARIABLE";
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
print STDERR "DEBUG: found external variable $s\n" if $debug;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
} elsif (/\(\*(\w*(\{[0-9]+\})?)\([^\)]+/) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$s = $1;
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
print STDERR "DEBUG: found ANSI C function $s\n" if $debug;
Counter for GCC attributes.
2003-04-03 23:04:48 +00:00
} elsif (/\w+\W+(\w+)\W*\(\s*\)(\s*__attribute__\(.*\)\s*)?$/s) {
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
# K&R C
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
print STDERR "DEBUG: found K&R C function $s\n" if $debug;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
next;
Counter for GCC attributes.
2003-04-03 23:04:48 +00:00
} elsif (/\w+\W+\w+(\{[0-9]+\})?\W*\(.*\)(\s*__attribute__\(.*\)\s*)?$/s) {
while (not /\(\)(\s*__attribute__\(.*\)\s*)?$/s) {
s/[^\(\)]*\)(\s*__attribute__\(.*\)\s*)?$/\)/s;
s/\([^\(\)]*\)\)(\s*__attribute__\(.*\)\s*)?$/\)/s;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
s/\(void\)//;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
/(\w+(\{[0-9]+\})?)\W*\(\)/s;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$s = $1;
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
print STDERR "DEBUG: found function $s\n" if $debug;
Ignore TYPEDEF_OF in mkdef.pl
2005-04-19 11:49:25 +00:00
} elsif (/TYPEDEF_\w+_OF/) {
next;
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
} elsif (/\(/ and not (/=/)) {
print STDERR "File $file: cannot parse: $_;\n";
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
next;
} else {
next;
}
$syms{$s} = 1;
$kind{$s} = $k;
$p = $plats;
$a = $algs;
$a .= ",BF" if($s =~ /EVP_bf/);
$a .= ",CAST" if($s =~ /EVP_cast/);
$a .= ",DES" if($s =~ /EVP_des/);
$a .= ",DSA" if($s =~ /EVP_dss/);
$a .= ",IDEA" if($s =~ /EVP_idea/);
$a .= ",MD2" if($s =~ /EVP_md2/);
$a .= ",MD4" if($s =~ /EVP_md4/);
$a .= ",MD5" if($s =~ /EVP_md5/);
$a .= ",RC2" if($s =~ /EVP_rc2/);
$a .= ",RC4" if($s =~ /EVP_rc4/);
$a .= ",RC5" if($s =~ /EVP_rc5/);
$a .= ",RIPEMD" if($s =~ /EVP_ripemd/);
$a .= ",SHA" if($s =~ /EVP_sha/);
$a .= ",RSA" if($s =~ /EVP_(Open|Seal)(Final|Init)/);
$a .= ",RSA" if($s =~ /PEM_Seal(Final|Init|Update)/);
$a .= ",RSA" if($s =~ /RSAPrivateKey/);
$a .= ",RSA" if($s =~ /SSLv23?_((client|server)_)?method/);
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$platform{$s} =
&reduce_platforms((defined($platform{$s})?$platform{$s}.',':"").$p);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$algorithm{$s} .= ','.$a;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if (defined($variant{$s})) {
Sort platforms lexicographically as well. Also, support more than two variants of a symbol.
2001-03-02 12:14:54 +00:00
foreach $v (split /;/,$variant{$s}) {
(my $r, my $p, my $k) = split(/:/,$v);
my $ip = join ',',map({ /^!(.*)$/ ? $1 : "!".$_ } split /,/, $p);
$syms{$r} = 1;
if (!defined($k)) { $k = $kind{$s}; }
$kind{$r} = $k."(".$s.")";
$algorithm{$r} = $algorithm{$s};
$platform{$r} = &reduce_platforms($platform{$s}.",".$p.",".$p);
$platform{$s} = &reduce_platforms($platform{$s}.','.$ip.','.$ip);
print STDERR "DEBUG: \$variant{\"$s\"} = ",$v,"; \$r = $r; \$p = ",$platform{$r},"; \$a = ",$algorithm{$r},"; \$kind = ",$kind{$r},"\n" if $debug;
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: \$s = $s; \$p = ",$platform{$s},"; \$a = ",$algorithm{$s},"; \$kind = ",$kind{$s},"\n" if $debug;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# Prune the returned symbols
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
delete $syms{"bn_dump1"};
$platform{"BIO_s_log"} .= ",!WIN32,!WIN16,!macintosh";
When inside a #if 0..#endif, do not define anything.
2001-02-22 13:24:17 +00:00
$platform{"PEM_read_NS_CERT_SEQ"} = "VMS";
$platform{"PEM_write_NS_CERT_SEQ"} = "VMS";
$platform{"PEM_read_P8_PRIV_KEY_INFO"} = "VMS";
$platform{"PEM_write_P8_PRIV_KEY_INFO"} = "VMS";
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# Info we know about
push @ret, map { $_."\\".&info_string($_,"EXIST",
$platform{$_},
$kind{$_},
$algorithm{$_}) } keys %syms;
Enhancements to mkdef.pl: * detect "unknown" algorithms (any C macro starting with NO_ that is not explicitely mentioned in mkdef.pl as a known algorithm) and report. * add a number of algorithms that can be deselected. * look in ssl/kssl.h as well. * accept multiple whitespace (not just one SPC) in preprocessor lines.
2000-12-29 00:05:14 +00:00
if (keys %unknown_algorithms) {
print STDERR "WARNING: mkdef.pl doesn't know the following algorithms:\n";
print STDERR "\t",join("\n\t",keys %unknown_algorithms),"\n";
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
return(@ret);
}
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Param: string of comma-separated platform-specs.
sub reduce_platforms
{
my ($platforms) = @_;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $pl = defined($platforms) ? $platforms : "";
my %p = map { $_ => 0 } split /,/, $pl;
my $ret;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: Entered reduce_platforms with \"$platforms\"\n"
if $debug;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# We do this, because if there's code like the following, it really
# means the function exists in all cases and should therefore be
# everywhere. By increasing and decreasing, we may attain 0:
#
# ifndef WIN16
# int foo();
# else
# int _fat foo();
# endif
foreach $platform (split /,/, $pl) {
if ($platform =~ /^!(.*)$/) {
$p{$1}--;
} else {
$p{$platform}++;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
foreach $platform (keys %p) {
if ($p{$platform} == 0) { delete $p{$platform}; }
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
delete $p{""};
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
Sort platforms lexicographically as well. Also, support more than two variants of a symbol.
2001-03-02 12:14:54 +00:00
$ret = join(',',sort(map { $p{$_} < 0 ? "!".$_ : $_ } keys %p));
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: Exiting reduce_platforms with \"$ret\"\n"
if $debug;
return $ret;
}
sub info_string {
(my $symbol, my $exist, my $platforms, my $kind, my $algorithms) = @_;
my %a = defined($algorithms) ?
map { $_ => 1 } split /,/, $algorithms : ();
my $k = defined($kind) ? $kind : "FUNCTION";
my $ret;
my $p = &reduce_platforms($platforms);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
delete $a{""};
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$ret = $exist;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$ret .= ":".$p;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$ret .= ":".$k;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$ret .= ":".join(',',sort keys %a);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
return $ret;
}
sub maybe_add_info {
(my $name, *nums, my @symbols) = @_;
my $sym;
my $new_info = 0;
Detect and mark functions that no longer exist.
2000-11-14 13:20:10 +00:00
my %syms=();
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
print STDERR "Updating $name info\n";
foreach $sym (@symbols) {
(my $s, my $i) = split /\\/, $sym;
if (defined($nums{$s})) {
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$i =~ s/^(.*?:.*?:\w+)(\(\w+\))?/$1/;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
(my $n, my $dummy) = split /\\/, $nums{$s};
if (!defined($dummy) || $i ne $dummy) {
$nums{$s} = $n."\\".$i;
$new_info++;
Modify mkdef.pl to recognise and parse prprocessor conditionals of the form '#if defined(...) || defined(...) || ...' and '#if !defined(...) && !defined(...) && ...'. This also avoids the growing number of special cases it was previously handling (some of them wrongly).
2001-02-21 14:12:03 +00:00
print STDERR "DEBUG: maybe_add_info for $s: \"$dummy\" => \"$i\"\n" if $debug;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
}
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$syms{$s} = 1;
Detect and mark functions that no longer exist.
2000-11-14 13:20:10 +00:00
}
my @s=sort { &parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n") } keys %nums;
foreach $sym (@s) {
(my $n, my $i) = split /\\/, $nums{$sym};
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if (!defined($syms{$sym}) && $i !~ /^NOEXIST:/) {
Detect and mark functions that no longer exist.
2000-11-14 13:20:10 +00:00
$new_info++;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: maybe_add_info for $sym: -> undefined\n" if $debug;
Detect and mark functions that no longer exist.
2000-11-14 13:20:10 +00:00
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
if ($new_info) {
print STDERR "$new_info old symbols got an info update\n";
Tell users that a rewrite might be a good idea.
2000-09-17 15:41:24 +00:00
if (!$do_rewrite) {
print STDERR "You should do a rewrite to fix this.\n";
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
} else {
print STDERR "No old symbols needed info update\n";
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Param: string of comma-separated keywords, each possibly prefixed with a "!"
sub is_valid
{
my ($keywords_txt,$platforms) = @_;
my (@keywords) = split /,/,$keywords_txt;
Fix logic in mkdef.pl function is_valid. Update symbols
2005-04-19 23:54:44 +00:00
my ($falsesum, $truesum) = (0, 1);
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Param: one keyword
sub recognise
{
my ($keyword,$platforms) = @_;
if ($platforms) {
# platforms
if ($keyword eq "VMS" && $VMS) { return 1; }
if ($keyword eq "WIN32" && $W32) { return 1; }
if ($keyword eq "WIN16" && $W16) { return 1; }
if ($keyword eq "WINNT" && $NT) { return 1; }
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if ($keyword eq "OS2" && $OS2) { return 1; }
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Special platforms:
# EXPORT_VAR_AS_FUNCTION means that global variables
# will be represented as functions. This currently
# only happens on VMS-VAX.
Win16 too :-).
2001-05-13 05:01:58 +00:00
if ($keyword eq "EXPORT_VAR_AS_FUNCTION" && ($VMSVAX || $W32 || $W16)) {
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
return 1;
}
return 0;
} else {
# algorithms
if ($keyword eq "RC2" && $no_rc2) { return 0; }
if ($keyword eq "RC4" && $no_rc4) { return 0; }
if ($keyword eq "RC5" && $no_rc5) { return 0; }
if ($keyword eq "IDEA" && $no_idea) { return 0; }
if ($keyword eq "DES" && $no_des) { return 0; }
if ($keyword eq "BF" && $no_bf) { return 0; }
if ($keyword eq "CAST" && $no_cast) { return 0; }
if ($keyword eq "MD2" && $no_md2) { return 0; }
if ($keyword eq "MD4" && $no_md4) { return 0; }
if ($keyword eq "MD5" && $no_md5) { return 0; }
if ($keyword eq "SHA" && $no_sha) { return 0; }
if ($keyword eq "RIPEMD" && $no_ripemd) { return 0; }
if ($keyword eq "MDC2" && $no_mdc2) { return 0; }
if ($keyword eq "RSA" && $no_rsa) { return 0; }
if ($keyword eq "DSA" && $no_dsa) { return 0; }
if ($keyword eq "DH" && $no_dh) { return 0; }
Make proper use of all disabling variables.
2001-04-26 21:02:57 +00:00
if ($keyword eq "EC" && $no_ec) { return 0; }
ECDSA support Submitted by: Nils Larsch <nla@trustcenter.de>
2002-02-13 18:21:51 +00:00
if ($keyword eq "ECDSA" && $no_ecdsa) { return 0; }
Add ECDH support. Additional changes: - use EC_GROUP_get_degree() in apps/req.c - add ECDSA and ECDH to apps/speed.c - adds support for EC curves over binary fields to ECDSA - new function EC_KEY_up_ref() in crypto/ec/ec_key.c - reorganize crypto/ecdsa/ecdsatest.c - add engine support for ECDH - fix a few bugs in ECDSA engine support Submitted by: Douglas Stebila <douglas.stebila@sun.com>
2002-08-09 08:43:04 +00:00
if ($keyword eq "ECDH" && $no_ecdh) { return 0; }
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if ($keyword eq "HMAC" && $no_hmac) { return 0; }
if ($keyword eq "AES" && $no_aes) { return 0; }
Make proper use of all disabling variables.
2001-04-26 21:02:57 +00:00
if ($keyword eq "EVP" && $no_evp) { return 0; }
if ($keyword eq "LHASH" && $no_lhash) { return 0; }
if ($keyword eq "STACK" && $no_stack) { return 0; }
if ($keyword eq "ERR" && $no_err) { return 0; }
if ($keyword eq "BUFFER" && $no_buffer) { return 0; }
if ($keyword eq "BIO" && $no_bio) { return 0; }
if ($keyword eq "COMP" && $no_comp) { return 0; }
if ($keyword eq "DSO" && $no_dso) { return 0; }
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if ($keyword eq "KRB5" && $no_krb5) { return 0; }
Add the possibility to build without the ENGINE framework. PR: 287
2003-01-30 17:39:26 +00:00
if ($keyword eq "ENGINE" && $no_engine) { return 0; }
The util scripts need to handled no-hw. PR: 327
2003-01-30 20:03:45 +00:00
if ($keyword eq "HW" && $no_hw) { return 0; }
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if ($keyword eq "FP_API" && $no_fp_api) { return 0; }
For the mkdef.pl to recognise if the "external" engines are inserted into libcrypto, we need the "algorithm" STATIC_ENGINE.
2002-10-24 19:09:03 +00:00
if ($keyword eq "STATIC_ENGINE" && $no_static_engine) { return 0; }
New "algorithm define" OPENSSL_NO_GMP. Update mkdef.pl and Configure script to use it.
2005-04-19 13:24:44 +00:00
if ($keyword eq "GMP" && $no_gmp) { return 0; }
Hmm, Geoff's change made things quite interesting. We can now give users the option of disabling deprecated functions, which should of course be reflected in libeay.num and .def files. Quite nice, actually.
2002-12-09 02:18:16 +00:00
if ($keyword eq "DEPRECATED" && $no_deprecated) { return 0; }
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# Nothing recognise as true
return 1;
}
}
foreach $k (@keywords) {
if ($k =~ /^!(.*)$/) {
$falsesum += &recognise($1,$platforms);
} else {
Fix logic in mkdef.pl function is_valid. Update symbols
2005-04-19 23:54:44 +00:00
$truesum *= &recognise($k,$platforms);
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
}
}
print STDERR "DEBUG: [",$#keywords,",",$#keywords < 0,"] is_valid($keywords_txt) => (\!$falsesum) && $truesum = ",(!$falsesum) && $truesum,"\n" if $debug;
return (!$falsesum) && $truesum;
}
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
sub print_test_file
{
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
(*OUT,my $name,*nums,my $testall,my @symbols)=@_;
Honor the no-xxx Configure options when creating .DEF files.
2000-01-07 03:17:47 +00:00
my $n = 1; my @e; my @r;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $sym; my $prev = ""; my $prefSSLeay;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
(@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
(@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:.*/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
@symbols=((sort @e),(sort @r));
foreach $sym (@symbols) {
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $v = 0;
$v = 1 if $i=~ /^.*?:.*?:VARIABLE/;
my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
if (!defined($nums{$s})) {
print STDERR "Warning: $s does not have a number assigned\n"
if(!$do_update);
} elsif (is_valid($p,1) && is_valid($a,0)) {
my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
if ($prev eq $s2) {
print OUT "\t/* The following has already appeared previously */\n";
print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
}
$prev = $s2; # To warn about duplicates...
($nn,$ni)=($nums{$s2} =~ /^(.*?)\\(.*)$/);
if ($v) {
print OUT "\textern int $s2; /* type unknown */ /* $nn $ni */\n";
New option 'ctestall' for mkdef.pl, that makes it not only generate existing functions, but really all functions that exist in libeay.num and ssleay.num. This is a good check on how much we should actually clean up the number files.
2000-08-17 21:26:22 +00:00
} else {
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print OUT "\textern int $s2(); /* type unknown */ /* $nn $ni */\n";
New option 'ctestall' for mkdef.pl, that makes it not only generate existing functions, but really all functions that exist in libeay.num and ssleay.num. This is a good check on how much we should actually clean up the number files.
2000-08-17 21:26:22 +00:00
}
Fixes so NO_RSA works again.
1999-12-24 17:26:33 +00:00
}
}
}
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
sub get_version {
local *MF;
my $v = '?';
Makefile.ssl -> Makefile
2005-04-13 19:09:43 +00:00
open MF, 'Makefile' or return $v;
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
while (<MF>) {
$v = $1, last if /^VERSION=(.*?)\s*$/;
}
close MF;
return $v;
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
sub print_def_file
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
{
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
(*OUT,my $name,*nums,my @symbols)=@_;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $n = 1; my @e; my @r; my @v; my $prev="";
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
my $liboptions="";
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
my $libname = $name;
my $http_vendor = 'www.openssl.org/';
my $version = get_version();
my $what = "OpenSSL: implementation of Secure Socket Layer";
my $description = "$what $version, $name - http://$http_vendor";
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Fix the Win32 compile environment and add various changes so it will now compile under Win32 (9X and NT) again. Note: some signed/unsigned changes recently checked in were killing the Win32 compile.
1999-03-03 02:01:26 +00:00
if ($W32)
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
{ $libname.="32"; }
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
elsif ($W16)
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
{ $libname.="16"; }
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
elsif ($OS2)
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
{ # DLL names should not clash on the whole system.
# However, they should not have any particular relationship
# to the name of the static library. Chose descriptive names
# (must be at most 8 chars).
my %translate = (ssl => 'open_ssl', crypto => 'cryptssl');
$libname = $translate{$name} || $name;
$liboptions = <<EOO;
INITINSTANCE
DATA MULTIPLE NONSHARED
EOO
# Vendor field can't contain colon, drat; so we omit http://
$description = "\@#$http_vendor:$version#\@$what; DLL for library $name. Build for EMX -Zmtd";
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
print OUT <<"EOF";
;
Fix various stuff: that VC++ 5.0 chokes on: 1. Add *lots* of missing prototypes for static ssl functions. 2. VC++ doesn't understand the 'LL' suffix for 64 bits constants: change bn.org 3. Add a few missing prototypes in pem.org Fix mk1mf.pl so it outputs a Makefile that doesn't choke Win95. Fix mkdef.pl so it doesn't truncate longer names.
1999-01-31 17:30:18 +00:00
; Definition file for the DLL version of the $name library from OpenSSL
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
;
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
LIBRARY $libname $liboptions
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
DESCRIPTION '$description'
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
EOF
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if ($W16) {
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
print <<"EOF";
CODE PRELOAD MOVEABLE
DATA PRELOAD MOVEABLE SINGLE
EXETYPE WINDOWS
HEAPSIZE 4096
STACKSIZE 8192
EOF
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
print "EXPORTS\n";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
(@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
(@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:FUNCTION/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
(@v)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:VARIABLE/,@symbols);
Make mkdef.pl parse some ASN1 IMPLEMENT macros. Initial support for variables in DEF files.
2000-12-16 01:19:24 +00:00
@symbols=((sort @e),(sort @r), (sort @v));
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
foreach $sym (@symbols) {
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
Make mkdef.pl parse some ASN1 IMPLEMENT macros. Initial support for variables in DEF files.
2000-12-16 01:19:24 +00:00
my $v = 0;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$v = 1 if $i =~ /^.*?:.*?:VARIABLE/;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if (!defined($nums{$s})) {
printf STDERR "Warning: $s does not have a number assigned\n"
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if(!$do_update);
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
} else {
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
(my $n, my $dummy) = split /\\/, $nums{$s};
mkdef.pl still needed better logic. Also, the semantics of the platforms list is clarified (it's however not quite followed in the RSAREF case...). RSAREF is also checked now.
2000-09-11 20:04:58 +00:00
my %pf = ();
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
if (is_valid($p,1) && is_valid($a,0)) {
my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
if ($prev eq $s2) {
print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
}
$prev = $s2; # To warn about duplicates...
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
if($v && !$OS2) {
Add the 'ec' directory to mkdef.pl and mkfiles.pl so the Windows build can see it. Fixup mkdef.pl so it doesn't mess up with function names longer than 39 characters in length.
2001-03-10 01:56:48 +00:00
printf OUT " %s%-39s @%-8d DATA\n",($W32)?"":"_",$s2,$n;
Make mkdef.pl parse some ASN1 IMPLEMENT macros. Initial support for variables in DEF files.
2000-12-16 01:19:24 +00:00
} else {
Add support for shared libraries with OS/2. PR: 124
2002-07-17 13:27:43 +00:00
printf OUT " %s%-39s @%d\n",($W32||$OS2)?"":"_",$s2,$n;
Make mkdef.pl parse some ASN1 IMPLEMENT macros. Initial support for variables in DEF files.
2000-12-16 01:19:24 +00:00
}
mkdef.pl has erroneous conditions to check if a symbol is excluded from the given target. Fixed, I hope.
2000-09-11 17:31:05 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
}
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
printf OUT "\n";
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
sub load_numbers
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
{
my($name)=@_;
my(@a,%ret);
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
$max_num = 0;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$num_noinfo = 0;
$prev = "";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$prev_cnt = 0;
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
open(IN,"<$name") || die "unable to open $name:$!\n";
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
while (<IN>) {
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
chop;
s/#.*$//;
next if /^\s*$/;
@a=split;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if (defined $ret{$a[0]}) {
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
# This is actually perfectly OK
#print STDERR "Warning: Symbol '",$a[0],"' redefined. old=",$ret{$a[0]},", new=",$a[1],"\n";
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
if ($max_num > $a[1]) {
print STDERR "Warning: Number decreased from ",$max_num," to ",$a[1],"\n";
}
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
elsif ($max_num == $a[1]) {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
# This is actually perfectly OK
#print STDERR "Warning: Symbol ",$a[0]," has same number as previous ",$prev,": ",$a[1],"\n";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
if ($a[0] eq $prev) {
$prev_cnt++;
$a[0] .= "{$prev_cnt}";
}
}
else {
$prev_cnt = 0;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
if ($#a < 2) {
# Existence will be proven later, in do_defs
$ret{$a[0]}=$a[1];
$num_noinfo++;
} else {
$ret{$a[0]}=$a[1]."\\".$a[2]; # \\ is a special marker
}
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
$max_num = $a[1] if $a[1] > $max_num;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
$prev=$a[0];
}
if ($num_noinfo) {
print STDERR "Warning: $num_noinfo symbols were without info.";
if ($do_rewrite) {
printf STDERR " The rewrite will fix this.\n";
} else {
printf STDERR " You should do a rewrite to fix this.\n";
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 10:52:47 +00:00
close(IN);
return(%ret);
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
sub parse_number
{
(my $str, my $what) = @_;
(my $n, my $i) = split(/\\/,$str);
if ($what eq "n") {
return $n;
} else {
return $i;
}
}
sub rewrite_numbers
{
(*OUT,$name,*nums,@symbols)=@_;
my $thing;
print STDERR "Rewriting $name\n";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $r; my %r; my %rsyms;
foreach $r (@r) {
(my $s, my $i) = split /\\/, $r;
my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
$i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
$r{$a} = $s."\\".$i;
$rsyms{$s} = 1;
}
Detect and mark functions that no longer exist.
2000-11-14 13:20:10 +00:00
my %syms = ();
foreach $_ (@symbols) {
(my $n, my $i) = split /\\/;
$syms{$n} = 1;
}
Two changes: 1. if there are several symbols with the same entry number, sort those symbols in ASCII order. 2. Do not stop reading the header files when "BEGIN ERROR CODES" is found, since mkerr.pl will add a function declaration after that comment. Instead, trigger on "Error codes for the \w+ function", which is the actual start of the error code macros. Additionally, a few more debugging printouts that helped.
2001-09-26 15:06:45 +00:00
my @s=sort {
&parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n")
|| $a cmp $b
} keys %nums;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
foreach $sym (@s) {
(my $n, my $i) = split /\\/, $nums{$sym};
next if defined($i) && $i =~ /^.*?:.*?:\w+\(\w+\)/;
next if defined($rsyms{$sym});
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
print STDERR "DEBUG: rewrite_numbers for sym = ",$sym,": i = ",$i,", n = ",$n,", rsym{sym} = ",$rsyms{$sym},"syms{sym} = ",$syms{$sym},"\n" if $debug;
Detect and mark functions that no longer exist.
2000-11-14 13:20:10 +00:00
$i="NOEXIST::FUNCTION:"
if !defined($i) || $i eq "" || !defined($syms{$sym});
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $s2 = $sym;
$s2 =~ s/\{[0-9]+\}$//;
Add the 'ec' directory to mkdef.pl and mkfiles.pl so the Windows build can see it. Fixup mkdef.pl so it doesn't mess up with function names longer than 39 characters in length.
2001-03-10 01:56:48 +00:00
printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if (exists $r{$sym}) {
(my $s, $i) = split /\\/,$r{$sym};
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $s2 = $s;
$s2 =~ s/\{[0-9]+\}$//;
Add the 'ec' directory to mkdef.pl and mkfiles.pl so the Windows build can see it. Fixup mkdef.pl so it doesn't mess up with function names longer than 39 characters in length.
2001-03-10 01:56:48 +00:00
printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
}
}
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
sub update_numbers
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
{
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
(*OUT,$name,*nums,my $start_num, my @symbols)=@_;
my $new_syms = 0;
print STDERR "Updating $name numbers\n";
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
my $r; my %r; my %rsyms;
foreach $r (@r) {
(my $s, my $i) = split /\\/, $r;
my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
$i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
$r{$a} = $s."\\".$i;
$rsyms{$s} = 1;
}
foreach $sym (@symbols) {
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
next if $i =~ /^.*?:.*?:\w+\(\w+\)/;
next if defined($rsyms{$sym});
die "ERROR: Symbol $sym had no info attached to it."
if $i eq "";
if (!exists $nums{$s}) {
$new_syms++;
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
my $s2 = $s;
$s2 =~ s/\{[0-9]+\}$//;
Add the 'ec' directory to mkdef.pl and mkfiles.pl so the Windows build can see it. Fixup mkdef.pl so it doesn't mess up with function names longer than 39 characters in length.
2001-03-10 01:56:48 +00:00
printf OUT "%s%-39s %d\t%s\n","",$s2, ++$start_num,$i;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if (exists $r{$s}) {
Wrong variable used. It's funny how some bugs take a long time getting triggered...
2000-09-20 14:47:04 +00:00
($s, $i) = split /\\/,$r{$s};
Introduce the possibility to access global variables through functions on platform were that's the best way to handle exporting global variables in shared libraries. To enable this functionality, one must configure with "EXPORT_VAR_AS_FN" or defined the C macro "OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter is normally done by Configure or something similar). To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL in the source file (foo.c) like this: OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1; OPENSSL_IMPLEMENT_GLOBAL(double,bar); To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL and OPENSSL_GLOBAL_REF in the header file (foo.h) like this: OPENSSL_DECLARE_GLOBAL(int,foo); #define foo OPENSSL_GLOBAL_REF(foo) OPENSSL_DECLARE_GLOBAL(double,bar); #define bar OPENSSL_GLOBAL_REF(bar) The #defines are very important, and therefore so is including the header file everywere where the defined globals are used. The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition of ASN.1 items, but that structure is a bt different. The largest change is in util/mkdef.pl which has been enhanced with better and easier to understand logic to choose which symbols should go into the Windows .def files as well as a number of fixes and code cleanup (among others, algorithm keywords are now sorted lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
$s =~ s/\{[0-9]+\}$//;
Add the 'ec' directory to mkdef.pl and mkfiles.pl so the Windows build can see it. Fixup mkdef.pl so it doesn't mess up with function names longer than 39 characters in length.
2001-03-10 01:56:48 +00:00
printf OUT "%s%-39s %d\t%s\n","",$s, $start_num,$i;
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
}
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
if($new_syms) {
print STDERR "$new_syms New symbols added\n";
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
} else {
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
print STDERR "No New symbols Added\n";
}
}
sub check_existing
{
(*nums, my @symbols)=@_;
my %existing; my @remaining;
@remaining=();
foreach $sym (@symbols) {
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
$existing{$s}=1;
}
foreach $sym (keys %nums) {
if (!exists $existing{$sym}) {
push @remaining, $sym;
}
}
if(@remaining) {
print STDERR "The following symbols do not seem to exist:\n";
foreach $sym (@remaining) {
print STDERR "\t",$sym,"\n";
}
Make the 'crypto' and 'ssl' options in the perl script mkdef.pl really work, also add an 'update' option to automatically append any new functions to the ssleay.num and libeay.num files.
1999-02-11 01:39:30 +00:00
}
Extensively changed the DEF file generator mkdef.pl to use a modified version of Ulf's prototype parser, also general tidying and fixing of several problems with the original. Its still a bit of a hack but should work. This is the last bit of the old code that uses the K&R prototypes: after some testing they can finally go away...
1999-04-26 00:23:10 +00:00
}
Major hack of mkdef.pl. There should be no more need to redo the process when some symbols are missing. Instead, all needed info is saved in the .num files, including what conditions are needed for a specific symbol to exist. This was needed for the work I'm doing with shared libraries under VMS.
2000-09-07 08:43:08 +00:00
Reference in a new issue Copy permalink