]> git.ipfire.org Git - thirdparty/openssl.git/blame - util/mkdef.pl
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Type-checked (and modern C compliant) OBJ_bsearch.
[thirdparty/openssl.git] / util / mkdef.pl
CommitLineData
ce9449cf 1#!/usr/local/bin/perl -w
d02b48c6
RE		 2#
3# generate a .def file
4#
5# It does this by parsing the header files and looking for the
47339f61 6# prototyped functions: it then prunes the output.
d02b48c6 7#
948d0125
RL		 8# Intermediary files are created, call libeay.num and ssleay.num,...
9# Previously, they had the following format:
10#
11# routine-name nnnn
12#
13# But that isn't enough for a number of reasons, the first on being that
14# this format is (needlessly) very Win32-centric, and even then...
15# One of the biggest problems is that there's no information about what
16# routines should actually be used, which varies with what crypto algorithms
17# are disabled. Also, some operating systems (for example VMS with VAX C)
18# need to keep track of the global variables as well as the functions.
19#
20# So, a remake of this script is done so as to include information on the
21# kind of symbol it is (function or variable) and what algorithms they're
22# part of. This will allow easy translating to .def files or the corresponding
23# file in other operating systems (a .opt file for VMS, possibly with a .mar
24# file).
25#
26# The format now becomes:
27#
28# routine-name nnnn info
29#
30# and the "info" part is actually a colon-separated string of fields with
31# the following meaning:
32#
33# existence:platform:kind:algorithms
34#
35# - "existence" can be "EXIST" or "NOEXIST" depending on if the symbol is
36# found somewhere in the source,
37# - "platforms" is empty if it exists on all platforms, otherwise it contains
38# comma-separated list of the platform, just as they are if the symbol exists
39# for those platforms, or prepended with a "!" if not. This helps resolve
62dc5aad 40# symbol name variants for platforms where the names are too long for the
948d0125 41# compiler or linker, or if the systems is case insensitive and there is a
62dc5aad
RL		 42# clash, or the symbol is implemented differently (see
43# EXPORT_VAR_AS_FUNCTION). This script assumes renaming of symbols is found
44# in the file crypto/symhacks.h.
45# The semantics for the platforms is that every item is checked against the
5012158a
LJ		 46# environment. For the negative items ("!FOO"), if any of them is false
47# (i.e. "FOO" is true) in the environment, the corresponding symbol can't be
62dc5aad
RL		 48# used. For the positive itms, if all of them are false in the environment,
49# the corresponding symbol can't be used. Any combination of positive and
50# negative items are possible, and of course leave room for some redundancy.
948d0125
RL		 51# - "kind" is "FUNCTION" or "VARIABLE". The meaning of that is obvious.
52# - "algorithms" is a comma-separated list of algorithm names. This helps
53# exclude symbols that are part of an algorithm that some user wants to
54# exclude.
55#
d02b48c6 56
d399fdf8
RL		 57my $debug=0;
58
948d0125
RL		 59my $crypto_num= "util/libeay.num";
60my $ssl_num= "util/ssleay.num";
cd4c36ad 61my $libname;
d02b48c6 62
47339f61 63my $do_update = 0;
1449bda0 64my $do_rewrite = 1;
47339f61
DSH		 65my $do_crypto = 0;
66my $do_ssl = 0;
0f583f69 67my $do_ctest = 0;
967f4ca8 68my $do_ctestall = 0;
c47c6196 69my $do_checkexist = 0;
47339f61 70
62dc5aad
RL		 71my $VMSVAX=0;
72my $VMSAlpha=0;
948d0125
RL		 73my $VMS=0;
74my $W32=0;
75my $W16=0;
0f583f69 76my $NT=0;
cd4c36ad 77my $OS2=0;
28a98809 78# Set this to make typesafe STACK definitions appear in DEF
e41c8d6a 79my $safe_stack_def = 0;
31ff97b2 80
62dc5aad 81my @known_platforms = ( "__FreeBSD__", "PERL5", "NeXT",
8931b30d 82 "EXPORT_VAR_AS_FUNCTION", "ZLIB" );
cd4c36ad 83my @known_ossl_platforms = ( "VMS", "WIN16", "WIN32", "WINNT", "OS2" );
948d0125 84my @known_algorithms = ( "RC2", "RC4", "RC5", "IDEA", "DES", "BF",
3f07fe09 85 "CAST", "MD2", "MD4", "MD5", "SHA", "SHA0", "SHA1",
665560e9 86 "SHA256", "SHA512", "RIPEMD",
96afc1cf
BM		 87 "MDC2", "WHIRLPOOL", "RSA", "DSA", "DH", "EC", "ECDH", "ECDSA",
88 "HMAC", "AES", "CAMELLIA", "SEED", "GOST",
3f07fe09
RL		 89 # Envelope "algorithms"
90 "EVP", "X509", "ASN1_TYPEDEFS",
91 # Helper "algorithms"
92 "BIO", "COMP", "BUFFER", "LHASH", "STACK", "ERR",
93 "LOCKING",
94 # External "algorithms"
64387788 95 "FP_API", "STDIO", "SOCK", "KRB5", "DGRAM",
6cb68620 96 # Engines
987bebaf 97 "STATIC_ENGINE", "ENGINE", "HW", "GMP",
d137b56a
DSH		 98 # RFC3779
99 "RFC3779",
c20276e4
DSH		 100 # TLS
101 "TLSEXT", "PSK",
8931b30d
DSH		 102 # CMS
103 "CMS",
d8bd55a3
DSH		 104 # CryptoAPI Engine
105 "CAPIENG",
4ccfe5f4
RL		 106 # Deprecated functions
107 "DEPRECATED" );
948d0125 108
0f583f69 109my $options="";
52272327 110open(IN,"<Makefile") || die "unable to open Makefile!\n";
31ff97b2
UM		 111while(<IN>) {
112 $options=$1 if (/^OPTIONS=(.*)$/);
113}
ce457a54 114close(IN);
31ff97b2 115
0f583f69
UM		 116# The following ciphers may be excluded (by Configure). This means functions
117# defined with ifndef(NO_XXX) are not included in the .def file, and everything
118# in directory xxx is ignored.
119my $no_rc2; my $no_rc4; my $no_rc5; my $no_idea; my $no_des; my $no_bf;
96afc1cf 120my $no_cast; my $no_whirlpool; my $no_camellia; my $no_seed;
3009458e 121my $no_md2; my $no_md4; my $no_md5; my $no_sha; my $no_ripemd; my $no_mdc2;
c063f2c5 122my $no_rsa; my $no_dsa; my $no_dh; my $no_hmac=0; my $no_aes; my $no_krb5;
5cd48abf 123my $no_ec; my $no_ecdsa; my $no_ecdh; my $no_engine; my $no_hw;
f858d222 124my $no_fp_api; my $no_static_engine=1; my $no_gmp; my $no_deprecated;
d8bd55a3 125my $no_rfc3779; my $no_psk; my $no_tlsext; my $no_cms; my $no_capieng;
8931b30d
DSH		 126
127my $zlib;
987bebaf 128
0f583f69 129
31ff97b2 130foreach (@ARGV, split(/ /, $options))
d02b48c6 131 {
62dc5aad 132 $debug=1 if $_ eq "debug";
06c68491 133 $W32=1 if $_ eq "32";
948d0125 134 $W16=1 if $_ eq "16";
06c68491
DSH		 135 if($_ eq "NT") {
136 $W32 = 1;
137 $NT = 1;
138 }
62dc5aad
RL		 139 if ($_ eq "VMS-VAX") {
140 $VMS=1;
141 $VMSVAX=1;
142 }
143 if ($_ eq "VMS-Alpha") {
144 $VMS=1;
145 $VMSAlpha=1;
146 }
948d0125 147 $VMS=1 if $_ eq "VMS";
cd4c36ad 148 $OS2=1 if $_ eq "OS2";
8931b30d
DSH		 149 if ($_ eq "zlib" || $_ eq "zlib-dynamic"
150 || $_ eq "enable-zlib-dynamic") {
151 $zlib = 1;
152 }
153
d63b8db8 154
d02b48c6 155 $do_ssl=1 if $_ eq "ssleay";
cd4c36ad
RL		 156 if ($_ eq "ssl") {
157 $do_ssl=1;
158 $libname=$_
159 }
d02b48c6 160 $do_crypto=1 if $_ eq "libeay";
cd4c36ad
RL		 161 if ($_ eq "crypto") {
162 $do_crypto=1;
163 $libname=$_;
164 }
fbf002bb
DSH		 165 $no_static_engine=1 if $_ eq "no-static-engine";
166 $no_static_engine=0 if $_ eq "enable-static-engine";
55a9cc6e 167 $do_update=1 if $_ eq "update";
948d0125 168 $do_rewrite=1 if $_ eq "rewrite";
12aefe78 169 $do_ctest=1 if $_ eq "ctest";
967f4ca8 170 $do_ctestall=1 if $_ eq "ctestall";
c47c6196 171 $do_checkexist=1 if $_ eq "exist";
a8b07aa4 172 #$safe_stack_def=1 if $_ eq "-DDEBUG_SAFESTACK";
8cf65228
UM		 173
174 if (/^no-rc2$/) { $no_rc2=1; }
175 elsif (/^no-rc4$/) { $no_rc4=1; }
176 elsif (/^no-rc5$/) { $no_rc5=1; }
177 elsif (/^no-idea$/) { $no_idea=1; }
be054868 178 elsif (/^no-des$/) { $no_des=1; $no_mdc2=1; }
8cf65228
UM		 179 elsif (/^no-bf$/) { $no_bf=1; }
180 elsif (/^no-cast$/) { $no_cast=1; }
ec645d90 181 elsif (/^no-whirlpool$/) { $no_whirlpool=1; }
8cf65228 182 elsif (/^no-md2$/) { $no_md2=1; }
3009458e 183 elsif (/^no-md4$/) { $no_md4=1; }
8cf65228
UM		 184 elsif (/^no-md5$/) { $no_md5=1; }
185 elsif (/^no-sha$/) { $no_sha=1; }
186 elsif (/^no-ripemd$/) { $no_ripemd=1; }
187 elsif (/^no-mdc2$/) { $no_mdc2=1; }
188 elsif (/^no-rsa$/) { $no_rsa=1; }
189 elsif (/^no-dsa$/) { $no_dsa=1; }
190 elsif (/^no-dh$/) { $no_dh=1; }
b4f682d3 191 elsif (/^no-ec$/) { $no_ec=1; }
4d94ae00 192 elsif (/^no-ecdsa$/) { $no_ecdsa=1; }
e172d60d 193 elsif (/^no-ecdh$/) { $no_ecdh=1; }
8cf65228 194 elsif (/^no-hmac$/) { $no_hmac=1; }
c47c6196 195 elsif (/^no-aes$/) { $no_aes=1; }
f3dea9a5 196 elsif (/^no-camellia$/) { $no_camellia=1; }
96afc1cf 197 elsif (/^no-seed$/) { $no_seed=1; }
3f07fe09
RL		 198 elsif (/^no-evp$/) { $no_evp=1; }
199 elsif (/^no-lhash$/) { $no_lhash=1; }
200 elsif (/^no-stack$/) { $no_stack=1; }
201 elsif (/^no-err$/) { $no_err=1; }
202 elsif (/^no-buffer$/) { $no_buffer=1; }
203 elsif (/^no-bio$/) { $no_bio=1; }
204 #elsif (/^no-locking$/) { $no_locking=1; }
205 elsif (/^no-comp$/) { $no_comp=1; }
206 elsif (/^no-dso$/) { $no_dso=1; }
c063f2c5 207 elsif (/^no-krb5$/) { $no_krb5=1; }
0b13e9f0 208 elsif (/^no-engine$/) { $no_engine=1; }
5cd48abf 209 elsif (/^no-hw$/) { $no_hw=1; }
987bebaf 210 elsif (/^no-gmp$/) { $no_gmp=1; }
d137b56a 211 elsif (/^no-rfc3779$/) { $no_rfc3779=1; }
525de5d3 212 elsif (/^no-tlsext$/) { $no_tlsext=1; }
8931b30d 213 elsif (/^no-cms$/) { $no_cms=1; }
d8bd55a3 214 elsif (/^no-capieng$/) { $no_capieng=1; }
d02b48c6
RE		 215 }
216
12aefe78 217
cd4c36ad
RL		 218if (!$libname) {
219 if ($do_ssl) {
220 $libname="SSLEAY";
221 }
222 if ($do_crypto) {
223 $libname="LIBEAY";
224 }
225}
226
948d0125 227# If no platform is given, assume WIN32
cd4c36ad 228if ($W32 + $W16 + $VMS + $OS2 == 0) {
948d0125
RL		 229 $W32 = 1;
230}
231
232# Add extra knowledge
233if ($W16) {
234 $no_fp_api=1;
235}
236
d02b48c6
RE		 237if (!$do_ssl && !$do_crypto)
238 {
cd4c36ad 239 print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT | OS2 ]\n";
d02b48c6
RE		 240 exit(1);
241 }
242
243%ssl_list=&load_numbers($ssl_num);
55a9cc6e 244$max_ssl = $max_num;
d02b48c6 245%crypto_list=&load_numbers($crypto_num);
55a9cc6e 246$max_crypto = $max_num;
d02b48c6 247
0f583f69 248my $ssl="ssl/ssl.h";
3f07fe09 249$ssl.=" ssl/kssl.h";
c20276e4 250$ssl.=" ssl/tls1.h";
d02b48c6 251
0f583f69 252my $crypto ="crypto/crypto.h";
6ac15712 253$crypto.=" crypto/o_dir.h";
c2e4f17c 254$crypto.=" crypto/des/des.h crypto/des/des_old.h" ; # unless $no_des;
0d96bf89
RL		 255$crypto.=" crypto/idea/idea.h" ; # unless $no_idea;
256$crypto.=" crypto/rc4/rc4.h" ; # unless $no_rc4;
257$crypto.=" crypto/rc5/rc5.h" ; # unless $no_rc5;
258$crypto.=" crypto/rc2/rc2.h" ; # unless $no_rc2;
259$crypto.=" crypto/bf/blowfish.h" ; # unless $no_bf;
260$crypto.=" crypto/cast/cast.h" ; # unless $no_cast;
ec645d90 261$crypto.=" crypto/whrlpool/whrlpool.h" ;
0d96bf89
RL		 262$crypto.=" crypto/md2/md2.h" ; # unless $no_md2;
263$crypto.=" crypto/md4/md4.h" ; # unless $no_md4;
264$crypto.=" crypto/md5/md5.h" ; # unless $no_md5;
265$crypto.=" crypto/mdc2/mdc2.h" ; # unless $no_mdc2;
266$crypto.=" crypto/sha/sha.h" ; # unless $no_sha;
267$crypto.=" crypto/ripemd/ripemd.h" ; # unless $no_ripemd;
6f9079fd 268$crypto.=" crypto/aes/aes.h" ; # unless $no_aes;
f3dea9a5 269$crypto.=" crypto/camellia/camellia.h" ; # unless $no_camellia;
96afc1cf 270$crypto.=" crypto/seed/seed.h"; # unless $no_seed;
d02b48c6
RE		 271
272$crypto.=" crypto/bn/bn.h";
0d96bf89
RL		 273$crypto.=" crypto/rsa/rsa.h" ; # unless $no_rsa;
274$crypto.=" crypto/dsa/dsa.h" ; # unless $no_dsa;
275$crypto.=" crypto/dh/dh.h" ; # unless $no_dh;
276$crypto.=" crypto/ec/ec.h" ; # unless $no_ec;
4d94ae00 277$crypto.=" crypto/ecdsa/ecdsa.h" ; # unless $no_ecdsa;
e172d60d 278$crypto.=" crypto/ecdh/ecdh.h" ; # unless $no_ecdh;
0d96bf89 279$crypto.=" crypto/hmac/hmac.h" ; # unless $no_hmac;
d02b48c6 280
0b13e9f0 281$crypto.=" crypto/engine/engine.h"; # unless $no_engine;
0d96bf89
RL		 282$crypto.=" crypto/stack/stack.h" ; # unless $no_stack;
283$crypto.=" crypto/buffer/buffer.h" ; # unless $no_buffer;
284$crypto.=" crypto/bio/bio.h" ; # unless $no_bio;
285$crypto.=" crypto/dso/dso.h" ; # unless $no_dso;
286$crypto.=" crypto/lhash/lhash.h" ; # unless $no_lhash;
d02b48c6
RE		 287$crypto.=" crypto/conf/conf.h";
288$crypto.=" crypto/txt_db/txt_db.h";
289
0d96bf89 290$crypto.=" crypto/evp/evp.h" ; # unless $no_evp;
d02b48c6
RE		 291$crypto.=" crypto/objects/objects.h";
292$crypto.=" crypto/pem/pem.h";
293#$crypto.=" crypto/meth/meth.h";
294$crypto.=" crypto/asn1/asn1.h";
9c67ab2f 295$crypto.=" crypto/asn1/asn1t.h";
d02b48c6 296$crypto.=" crypto/asn1/asn1_mac.h";
0d96bf89 297$crypto.=" crypto/err/err.h" ; # unless $no_err;
d02b48c6 298$crypto.=" crypto/pkcs7/pkcs7.h";
ee0508d4 299$crypto.=" crypto/pkcs12/pkcs12.h";
d02b48c6
RE		 300$crypto.=" crypto/x509/x509.h";
301$crypto.=" crypto/x509/x509_vfy.h";
679ab7c3 302$crypto.=" crypto/x509v3/x509v3.h";
c7235be6 303$crypto.=" crypto/ts/ts.h";
d02b48c6 304$crypto.=" crypto/rand/rand.h";
0d96bf89 305$crypto.=" crypto/comp/comp.h" ; # unless $no_comp;
eb64730b 306$crypto.=" crypto/ocsp/ocsp.h";
1449bda0 307$crypto.=" crypto/ui/ui.h crypto/ui/ui_compat.h";
c62da732 308$crypto.=" crypto/krb5/krb5_asn.h";
863d447e 309#$crypto.=" crypto/store/store.h";
6c61726b 310$crypto.=" crypto/pqueue/pqueue.h";
8931b30d 311$crypto.=" crypto/cms/cms.h";
d02b48c6 312
948d0125 313my $symhacks="crypto/symhacks.h";
55a9cc6e 314
948d0125
RL		 315my @ssl_symbols = &do_defs("SSLEAY", $ssl, $symhacks);
316my @crypto_symbols = &do_defs("LIBEAY", $crypto, $symhacks);
47339f61 317
55a9cc6e
DSH		 318if ($do_update) {
319
320if ($do_ssl == 1) {
948d0125
RL		 321
322 &maybe_add_info("SSLEAY",*ssl_list,@ssl_symbols);
323 if ($do_rewrite == 1) {
324 open(OUT, ">$ssl_num");
325 &rewrite_numbers(*OUT,"SSLEAY",*ssl_list,@ssl_symbols);
948d0125
RL		 326 } else {
327 open(OUT, ">>$ssl_num");
328 }
329 &update_numbers(*OUT,"SSLEAY",*ssl_list,$max_ssl,@ssl_symbols);
55a9cc6e
DSH		 330 close OUT;
331}
332
333if($do_crypto == 1) {
948d0125
RL		 334
335 &maybe_add_info("LIBEAY",*crypto_list,@crypto_symbols);
336 if ($do_rewrite == 1) {
337 open(OUT, ">$crypto_num");
338 &rewrite_numbers(*OUT,"LIBEAY",*crypto_list,@crypto_symbols);
339 } else {
340 open(OUT, ">>$crypto_num");
341 }
342 &update_numbers(*OUT,"LIBEAY",*crypto_list,$max_crypto,@crypto_symbols);
55a9cc6e 343 close OUT;
12aefe78
DSH		 344}
345
c47c6196
DSH		 346} elsif ($do_checkexist) {
347 &check_existing(*ssl_list, @ssl_symbols)
348 if $do_ssl == 1;
349 &check_existing(*crypto_list, @crypto_symbols)
350 if $do_crypto == 1;
967f4ca8 351} elsif ($do_ctest || $do_ctestall) {
12aefe78
DSH		 352
353 print <<"EOF";
354
355/* Test file to check all DEF file symbols are present by trying
356 * to link to all of them. This is *not* intended to be run!
357 */
358
359int main()
360{
361EOF
948d0125 362 &print_test_file(*STDOUT,"SSLEAY",*ssl_list,$do_ctestall,@ssl_symbols)
12aefe78
DSH		 363 if $do_ssl == 1;
364
948d0125 365 &print_test_file(*STDOUT,"LIBEAY",*crypto_list,$do_ctestall,@crypto_symbols)
12aefe78
DSH		 366 if $do_crypto == 1;
367
368 print "}\n";
55a9cc6e
DSH		 369
370} else {
8cf65228 371
cd4c36ad 372 &print_def_file(*STDOUT,$libname,*ssl_list,@ssl_symbols)
55a9cc6e
DSH		 373 if $do_ssl == 1;
374
cd4c36ad 375 &print_def_file(*STDOUT,$libname,*crypto_list,@crypto_symbols)
55a9cc6e 376 if $do_crypto == 1;
8cf65228 377
55a9cc6e 378}
d02b48c6 379
d02b48c6
RE		 380
381sub do_defs
47339f61 382{
948d0125 383 my($name,$files,$symhacksfile)=@_;
0f583f69 384 my $file;
47339f61 385 my @ret;
948d0125
RL		 386 my %syms;
387 my %platform; # For anything undefined, we assume ""
388 my %kind; # For anything undefined, we assume "FUNCTION"
389 my %algorithm; # For anything undefined, we assume ""
62dc5aad
RL		 390 my %variant;
391 my %variant_cnt; # To be able to allocate "name{n}" if "name"
392 # is the same name as the original.
0f583f69 393 my $cpp;
3f07fe09 394 my %unknown_algorithms = ();
d02b48c6 395
948d0125 396 foreach $file (split(/\s+/,$symhacksfile." ".$files))
d02b48c6 397 {
89eeccac 398 print STDERR "DEBUG: starting on $file:\n" if $debug;
d02b48c6 399 open(IN,"<$file") || die "unable to open $file:$!\n";
0f583f69 400 my $line = "", my $def= "";
47339f61 401 my %tag = (
d399fdf8
RL		 402 (map { $_ => 0 } @known_platforms),
403 (map { "OPENSSL_SYS_".$_ => 0 } @known_ossl_platforms),
cf1b7d96 404 (map { "OPENSSL_NO_".$_ => 0 } @known_algorithms),
47339f61 405 NOPROTO => 0,
47339f61
DSH		 406 PERL5 => 0,
407 _WINDLL => 0,
47339f61
DSH		 408 CONST_STRICT => 0,
409 TRUE => 1,
410 );
948d0125 411 my $symhacking = $file eq $symhacksfile;
267a1927
RL		 412 my @current_platforms = ();
413 my @current_algorithms = ();
414
62dc5aad
RL		 415 # params: symbol, alias, platforms, kind
416 # The reason to put this subroutine in a variable is that
417 # it will otherwise create it's own, unshared, version of
418 # %tag and %variant...
419 my $make_variant = sub
420 {
421 my ($s, $a, $p, $k) = @_;
422 my ($a1, $a2);
423
424 print STDERR "DEBUG: make_variant: Entered with ",$s,", ",$a,", ",(defined($p)?$p:""),", ",(defined($k)?$k:""),"\n" if $debug;
425 if (defined($p))
426 {
427 $a1 = join(",",$p,
428 grep(!/^$/,
429 map { $tag{$_} == 1 ? $_ : "" }
430 @known_platforms));
431 }
432 else
433 {
434 $a1 = join(",",
435 grep(!/^$/,
436 map { $tag{$_} == 1 ? $_ : "" }
437 @known_platforms));
438 }
439 $a2 = join(",",
440 grep(!/^$/,
441 map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ : "" }
442 @known_ossl_platforms));
443 print STDERR "DEBUG: make_variant: a1 = $a1; a2 = $a2\n" if $debug;
444 if ($a1 eq "") { $a1 = $a2; }
445 elsif ($a1 ne "" && $a2 ne "") { $a1 .= ",".$a2; }
446 if ($a eq $s)
447 {
448 if (!defined($variant_cnt{$s}))
449 {
450 $variant_cnt{$s} = 0;
451 }
452 $variant_cnt{$s}++;
453 $a .= "{$variant_cnt{$s}}";
454 }
c454dbcd
RL		 455 my $toadd = $a.":".$a1.(defined($k)?":".$k:"");
456 my $togrep = $s.'(\{[0-9]+\})?:'.$a1.(defined($k)?":".$k:"");
457 if (!grep(/^$togrep$/,
458 split(/;/, defined($variant{$s})?$variant{$s}:""))) {
459 if (defined($variant{$s})) { $variant{$s} .= ";"; }
460 $variant{$s} .= $toadd;
461 }
62dc5aad
RL		 462 print STDERR "DEBUG: make_variant: Exit with variant of ",$s," = ",$variant{$s},"\n" if $debug;
463 };
464
465 print STDERR "DEBUG: parsing ----------\n" if $debug;
47339f61 466 while(<IN>) {
40e950ae
DSH		 467 if (/\/\* Error codes for the \w+ functions\. \*\//)
468 {
469 undef @tag;
470 last;
471 }
47339f61
DSH		 472 if ($line ne '') {
473 $_ = $line . $_;
474 $line = '';
d02b48c6 475 }
47339f61
DSH		 476
477 if (/\\$/) {
d399fdf8
RL		 478 chomp; # remove eol
479 chop; # remove ending backslash
47339f61
DSH		 480 $line = $_;
481 next;
482 }
483
68e57536
AP		 484 if(/\/\*/) {
485 if (not /\*\//) { # multiline comment...
486 $line = $_; # ... just accumulate
487 next;
488 } else {
489 s/\/\*.*?\*\///gs;# wipe it
490 }
491 }
492
47339f61 493 if ($cpp) {
68e57536
AP		 494 $cpp++ if /^#\s*if/;
495 $cpp-- if /^#\s*endif/;
47339f61
DSH		 496 next;
497 }
68e57536 498 $cpp = 1 if /^#.*ifdef.*cplusplus/;
47339f61 499
47339f61 500 s/{[^{}]*}//gs; # ignore {} blocks
6cb68620 501 print STDERR "DEBUG: \$def=\"$def\"\n" if $debug && $def ne "";
d399fdf8 502 print STDERR "DEBUG: \$_=\"$_\"\n" if $debug;
3f07fe09 503 if (/^\#\s*ifndef\s+(.*)/) {
d399fdf8 504 push(@tag,"-");
d02b48c6
RE		 505 push(@tag,$1);
506 $tag{$1}=-1;
d399fdf8 507 print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
3f07fe09 508 } elsif (/^\#\s*if\s+!defined\(([^\)]+)\)/) {
d399fdf8
RL		 509 push(@tag,"-");
510 if (/^\#\s*if\s+(!defined\(([^\)]+)\)(\s+\&\&\s+!defined\(([^\)]+)\))*)$/) {
511 my $tmp_1 = $1;
512 my $tmp_;
513 foreach $tmp_ (split '\&\&',$tmp_1) {
514 $tmp_ =~ /!defined\(([^\)]+)\)/;
515 print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
516 push(@tag,$1);
517 $tag{$1}=-1;
518 }
519 } else {
520 print STDERR "Warning: $file: complicated expression: $_" if $debug; # because it is O...
521 print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
522 push(@tag,$1);
523 $tag{$1}=-1;
524 }
8aa36bca 525 } elsif (/^\#\s*ifdef\s+(\S*)/) {
d399fdf8 526 push(@tag,"-");
d02b48c6
RE		 527 push(@tag,$1);
528 $tag{$1}=1;
d399fdf8 529 print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
3f07fe09 530 } elsif (/^\#\s*if\s+defined\(([^\)]+)\)/) {
d399fdf8
RL		 531 push(@tag,"-");
532 if (/^\#\s*if\s+(defined\(([^\)]+)\)(\s+\|\|\s+defined\(([^\)]+)\))*)$/) {
533 my $tmp_1 = $1;
534 my $tmp_;
535 foreach $tmp_ (split '\|\|',$tmp_1) {
536 $tmp_ =~ /defined\(([^\)]+)\)/;
537 print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
538 push(@tag,$1);
539 $tag{$1}=1;
540 }
541 } else {
542 print STDERR "Warning: $file: complicated expression: $_\n" if $debug; # because it is O...
543 print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
544 push(@tag,$1);
545 $tag{$1}=1;
546 }
948d0125 547 } elsif (/^\#\s*error\s+(\w+) is disabled\./) {
d399fdf8
RL		 548 my $tag_i = $#tag;
549 while($tag[$tag_i] ne "-") {
550 if ($tag[$tag_i] eq "OPENSSL_NO_".$1) {
551 $tag{$tag[$tag_i]}=2;
552 print STDERR "DEBUG: $file: chaged tag $1 = 2\n" if $debug;
553 }
554 $tag_i--;
948d0125 555 }
47339f61 556 } elsif (/^\#\s*endif/) {
d399fdf8 557 my $tag_i = $#tag;
665560e9 558 while($tag_i > 0 && $tag[$tag_i] ne "-") {
d399fdf8
RL		 559 my $t=$tag[$tag_i];
560 print STDERR "DEBUG: \$t=\"$t\"\n" if $debug;
561 if ($tag{$t}==2) {
562 $tag{$t}=-1;
563 } else {
564 $tag{$t}=0;
565 }
566 print STDERR "DEBUG: $file: changed tag ",$t," = ",$tag{$t},"\n" if $debug;
567 pop(@tag);
568 if ($t =~ /^OPENSSL_NO_([A-Z0-9_]+)$/) {
569 $t=$1;
570 } else {
571 $t="";
572 }
573 if ($t ne ""
574 && !grep(/^$t$/, @known_algorithms)) {
575 $unknown_algorithms{$t} = 1;
576 #print STDERR "DEBUG: Added as unknown algorithm: $t\n" if $debug;
577 }
578 $tag_i--;
948d0125 579 }
d02b48c6 580 pop(@tag);
47339f61 581 } elsif (/^\#\s*else/) {
d399fdf8
RL		 582 my $tag_i = $#tag;
583 while($tag[$tag_i] ne "-") {
584 my $t=$tag[$tag_i];
585 $tag{$t}= -$tag{$t};
586 print STDERR "DEBUG: $file: changed tag ",$t," = ",$tag{$t},"\n" if $debug;
587 $tag_i--;
588 }
47339f61 589 } elsif (/^\#\s*if\s+1/) {
d399fdf8 590 push(@tag,"-");
47339f61
DSH		 591 # Dummy tag
592 push(@tag,"TRUE");
593 $tag{"TRUE"}=1;
d399fdf8 594 print STDERR "DEBUG: $file: found 1\n" if $debug;
1e414935 595 } elsif (/^\#\s*if\s+0/) {
d399fdf8 596 push(@tag,"-");
1e414935
BM		 597 # Dummy tag
598 push(@tag,"TRUE");
599 $tag{"TRUE"}=-1;
d399fdf8 600 print STDERR "DEBUG: $file: found 0\n" if $debug;
948d0125 601 } elsif (/^\#\s*define\s+(\w+)\s+(\w+)/
2ae87d46 602 && $symhacking && $tag{'TRUE'} != -1) {
62dc5aad
RL		 603 # This is for aliasing. When we find an alias,
604 # we have to invert
605 &$make_variant($1,$2);
606 print STDERR "DEBUG: $file: defined $1 = $2\n" if $debug;
948d0125
RL		 607 }
608 if (/^\#/) {
267a1927
RL		 609 @current_platforms =
610 grep(!/^$/,
d399fdf8
RL		 611 map { $tag{$_} == 1 ? $_ :
612 $tag{$_} == -1 ? "!".$_ : "" }
267a1927 613 @known_platforms);
d399fdf8
RL		 614 push @current_platforms
615 , grep(!/^$/,
616 map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ :
617 $tag{"OPENSSL_SYS_".$_} == -1 ? "!".$_ : "" }
618 @known_ossl_platforms);
267a1927
RL		 619 @current_algorithms =
620 grep(!/^$/,
cf1b7d96 621 map { $tag{"OPENSSL_NO_".$_} == -1 ? $_ : "" }
267a1927
RL		 622 @known_algorithms);
623 $def .=
624 "#INFO:"
625 .join(',',@current_platforms).":"
626 .join(',',@current_algorithms).";";
47339f61
DSH		 627 next;
628 }
2ae87d46
RL		 629 if ($tag{'TRUE'} != -1) {
630 if (/^\s*DECLARE_STACK_OF\s*\(\s*(\w*)\s*\)/) {
631 next;
632 } elsif (/^\s*DECLARE_ASN1_ENCODE_FUNCTIONS\s*\(\s*(\w*)\s*,\s*(\w*)\s*,\s*(\w*)\s*\)/) {
633 $def .= "int d2i_$3(void);";
634 $def .= "int i2d_$3(void);";
62dc5aad
RL		 635 # Variant for platforms that do not
636 # have to access globale variables
637 # in shared libraries through functions
638 $def .=
639 "#INFO:"
640 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
641 .join(',',@current_algorithms).";";
2ae87d46 642 $def .= "OPENSSL_EXTERN int $2_it;";
62dc5aad
RL		 643 $def .=
644 "#INFO:"
645 .join(',',@current_platforms).":"
646 .join(',',@current_algorithms).";";
647 # Variant for platforms that have to
648 # access globale variables in shared
649 # libraries through functions
650 &$make_variant("$2_it","$2_it",
651 "EXPORT_VAR_AS_FUNCTION",
652 "FUNCTION");
2ae87d46
RL		 653 next;
654 } elsif (/^\s*DECLARE_ASN1_FUNCTIONS_fname\s*\(\s*(\w*)\s*,\s*(\w*)\s*,\s*(\w*)\s*\)/) {
655 $def .= "int d2i_$3(void);";
656 $def .= "int i2d_$3(void);";
657 $def .= "int $3_free(void);";
658 $def .= "int $3_new(void);";
62dc5aad
RL		 659 # Variant for platforms that do not
660 # have to access globale variables
661 # in shared libraries through functions
662 $def .=
663 "#INFO:"
664 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
665 .join(',',@current_algorithms).";";
2ae87d46 666 $def .= "OPENSSL_EXTERN int $2_it;";
62dc5aad
RL		 667 $def .=
668 "#INFO:"
669 .join(',',@current_platforms).":"
670 .join(',',@current_algorithms).";";
671 # Variant for platforms that have to
672 # access globale variables in shared
673 # libraries through functions
674 &$make_variant("$2_it","$2_it",
675 "EXPORT_VAR_AS_FUNCTION",
676 "FUNCTION");
677 next;
2ae87d46
RL		 678 } elsif (/^\s*DECLARE_ASN1_FUNCTIONS\s*\(\s*(\w*)\s*\)/ ||
679 /^\s*DECLARE_ASN1_FUNCTIONS_const\s*\(\s*(\w*)\s*\)/) {
680 $def .= "int d2i_$1(void);";
681 $def .= "int i2d_$1(void);";
682 $def .= "int $1_free(void);";
683 $def .= "int $1_new(void);";
62dc5aad
RL		 684 # Variant for platforms that do not
685 # have to access globale variables
686 # in shared libraries through functions
687 $def .=
688 "#INFO:"
689 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
690 .join(',',@current_algorithms).";";
2ae87d46 691 $def .= "OPENSSL_EXTERN int $1_it;";
62dc5aad
RL		 692 $def .=
693 "#INFO:"
694 .join(',',@current_platforms).":"
695 .join(',',@current_algorithms).";";
696 # Variant for platforms that have to
697 # access globale variables in shared
698 # libraries through functions
699 &$make_variant("$1_it","$1_it",
700 "EXPORT_VAR_AS_FUNCTION",
701 "FUNCTION");
2ae87d46
RL		 702 next;
703 } elsif (/^\s*DECLARE_ASN1_ENCODE_FUNCTIONS_const\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
704 $def .= "int d2i_$2(void);";
705 $def .= "int i2d_$2(void);";
62dc5aad
RL		 706 # Variant for platforms that do not
707 # have to access globale variables
708 # in shared libraries through functions
709 $def .=
710 "#INFO:"
711 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
712 .join(',',@current_algorithms).";";
2ae87d46 713 $def .= "OPENSSL_EXTERN int $2_it;";
62dc5aad
RL		 714 $def .=
715 "#INFO:"
716 .join(',',@current_platforms).":"
717 .join(',',@current_algorithms).";";
718 # Variant for platforms that have to
719 # access globale variables in shared
720 # libraries through functions
721 &$make_variant("$2_it","$2_it",
722 "EXPORT_VAR_AS_FUNCTION",
723 "FUNCTION");
2ae87d46 724 next;
ea3675b5
DSH		 725 } elsif (/^\s*DECLARE_ASN1_ALLOC_FUNCTIONS\s*\(\s*(\w*)\s*\)/) {
726 $def .= "int $1_free(void);";
727 $def .= "int $1_new(void);";
728 next;
2ae87d46
RL		 729 } elsif (/^\s*DECLARE_ASN1_FUNCTIONS_name\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
730 $def .= "int d2i_$2(void);";
731 $def .= "int i2d_$2(void);";
732 $def .= "int $2_free(void);";
733 $def .= "int $2_new(void);";
62dc5aad
RL		 734 # Variant for platforms that do not
735 # have to access globale variables
736 # in shared libraries through functions
737 $def .=
738 "#INFO:"
739 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
740 .join(',',@current_algorithms).";";
2ae87d46 741 $def .= "OPENSSL_EXTERN int $2_it;";
62dc5aad
RL		 742 $def .=
743 "#INFO:"
744 .join(',',@current_platforms).":"
745 .join(',',@current_algorithms).";";
746 # Variant for platforms that have to
747 # access globale variables in shared
748 # libraries through functions
749 &$make_variant("$2_it","$2_it",
750 "EXPORT_VAR_AS_FUNCTION",
751 "FUNCTION");
2ae87d46 752 next;
62dc5aad
RL		 753 } elsif (/^\s*DECLARE_ASN1_ITEM\s*\(\s*(\w*)\s*\)/) {
754 # Variant for platforms that do not
755 # have to access globale variables
756 # in shared libraries through functions
757 $def .=
758 "#INFO:"
759 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
760 .join(',',@current_algorithms).";";
2ae87d46 761 $def .= "OPENSSL_EXTERN int $1_it;";
62dc5aad
RL		 762 $def .=
763 "#INFO:"
764 .join(',',@current_platforms).":"
765 .join(',',@current_algorithms).";";
766 # Variant for platforms that have to
767 # access globale variables in shared
768 # libraries through functions
769 &$make_variant("$1_it","$1_it",
770 "EXPORT_VAR_AS_FUNCTION",
771 "FUNCTION");
2ae87d46 772 next;
f86abc2e 773 } elsif (/^\s*DECLARE_ASN1_NDEF_FUNCTION\s*\(\s*(\w*)\s*\)/) {
97ebe047 774 $def .= "int i2d_$1_NDEF(void);";
2ae87d46
RL		 775 } elsif (/^\s*DECLARE_ASN1_SET_OF\s*\(\s*(\w*)\s*\)/) {
776 next;
16094305
DSH		 777 } elsif (/^\s*DECLARE_ASN1_PRINT_FUNCTION\s*\(\s*(\w*)\s*\)/) {
778 $def .= "int $1_print_ctx(void);";
779 next;
780 } elsif (/^\s*DECLARE_ASN1_PRINT_FUNCTION_name\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
781 $def .= "int $2_print_ctx(void);";
782 next;
62dc5aad
RL		 783 } elsif (/^\s*DECLARE_PKCS12_STACK_OF\s*\(\s*(\w*)\s*\)/) {
784 next;
2ae87d46 785 } elsif (/^DECLARE_PEM_rw\s*\(\s*(\w*)\s*,/ ||
47738cba
AP		 786 /^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ ||
787 /^DECLARE_PEM_rw_const\s*\(\s*(\w*)\s*,/ ) {
2ae87d46
RL		 788 # Things not in Win16
789 $def .=
790 "#INFO:"
791 .join(',',"!WIN16",@current_platforms).":"
792 .join(',',@current_algorithms).";";
793 $def .= "int PEM_read_$1(void);";
794 $def .= "int PEM_write_$1(void);";
795 $def .=
796 "#INFO:"
797 .join(',',@current_platforms).":"
798 .join(',',@current_algorithms).";";
799 # Things that are everywhere
800 $def .= "int PEM_read_bio_$1(void);";
801 $def .= "int PEM_write_bio_$1(void);";
802 next;
803 } elsif (/^DECLARE_PEM_write\s*\(\s*(\w*)\s*,/ ||
804 /^DECLARE_PEM_write_cb\s*\(\s*(\w*)\s*,/ ) {
805 # Things not in Win16
806 $def .=
807 "#INFO:"
808 .join(',',"!WIN16",@current_platforms).":"
809 .join(',',@current_algorithms).";";
810 $def .= "int PEM_write_$1(void);";
811 $def .=
812 "#INFO:"
813 .join(',',@current_platforms).":"
814 .join(',',@current_algorithms).";";
815 # Things that are everywhere
816 $def .= "int PEM_write_bio_$1(void);";
817 next;
818 } elsif (/^DECLARE_PEM_read\s*\(\s*(\w*)\s*,/ ||
819 /^DECLARE_PEM_read_cb\s*\(\s*(\w*)\s*,/ ) {
820 # Things not in Win16
821 $def .=
822 "#INFO:"
823 .join(',',"!WIN16",@current_platforms).":"
824 .join(',',@current_algorithms).";";
825 $def .= "int PEM_read_$1(void);";
826 $def .=
827 "#INFO:"
828 .join(',',@current_platforms).":"
829 .join(',',@current_algorithms).";";
830 # Things that are everywhere
831 $def .= "int PEM_read_bio_$1(void);";
832 next;
62dc5aad
RL		 833 } elsif (/^OPENSSL_DECLARE_GLOBAL\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
834 # Variant for platforms that do not
835 # have to access globale variables
836 # in shared libraries through functions
837 $def .=
838 "#INFO:"
839 .join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
840 .join(',',@current_algorithms).";";
841 $def .= "OPENSSL_EXTERN int _shadow_$2;";
842 $def .=
843 "#INFO:"
844 .join(',',@current_platforms).":"
845 .join(',',@current_algorithms).";";
846 # Variant for platforms that have to
847 # access globale variables in shared
848 # libraries through functions
849 &$make_variant("_shadow_$2","_shadow_$2",
850 "EXPORT_VAR_AS_FUNCTION",
851 "FUNCTION");
2ae87d46 852 } elsif ($tag{'CONST_STRICT'} != 1) {
948d0125 853 if (/\{|\/\*|\([^\)]*$/) {
47339f61
DSH		 854 $line = $_;
855 } else {
856 $def .= $_;
857 }
d02b48c6
RE		 858 }
859 }
2ae87d46 860 }
d02b48c6 861 close(IN);
47339f61 862
948d0125
RL		 863 my $algs;
864 my $plays;
865
62dc5aad 866 print STDERR "DEBUG: postprocessing ----------\n" if $debug;
47339f61 867 foreach (split /;/, $def) {
948d0125 868 my $s; my $k = "FUNCTION"; my $p; my $a;
47339f61
DSH		 869 s/^[\n\s]*//g;
870 s/[\n\s]*$//g;
948d0125 871 next if(/\#undef/);
47339f61 872 next if(/typedef\W/);
948d0125
RL		 873 next if(/\#define/);
874
68e57536
AP		 875 # Reduce argument lists to empty ()
876 # fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}
877 while(/\(.*\)/s) {
878 s/\([^\(\)]+\)/\{\}/gs;
879 s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs; #(*f{}) -> f
880 }
881 # pretend as we didn't use curly braces: {} -> ()
882 s/\{\}/\(\)/gs;
883
884 s/STACK_OF\(\)/void/gs;
174c86a2 885 s/LHASH_OF\(\)/void/gs;
68e57536 886
62dc5aad 887 print STDERR "DEBUG: \$_ = \"$_\"\n" if $debug;
948d0125
RL		 888 if (/^\#INFO:([^:]*):(.*)$/) {
889 $plats = $1;
890 $algs = $2;
89eeccac 891 print STDERR "DEBUG: found info on platforms ($plats) and algorithms ($algs)\n" if $debug;
948d0125 892 next;
62dc5aad 893 } elsif (/^\s*OPENSSL_EXTERN\s.*?(\w+(\{[0-9]+\})?)(\[[0-9]*\])*\s*$/) {
948d0125
RL		 894 $s = $1;
895 $k = "VARIABLE";
89eeccac 896 print STDERR "DEBUG: found external variable $s\n" if $debug;
68e57536 897 } elsif (/TYPEDEF_\w+_OF/s) {
47339f61 898 next;
68e57536
AP		 899 } elsif (/(\w+)\s*\(\).*/s) { # first token prior [first] () is
900 $s = $1; # a function name!
89eeccac 901 print STDERR "DEBUG: found function $s\n" if $debug;
47339f61
DSH		 902 } elsif (/\(/ and not (/=/)) {
903 print STDERR "File $file: cannot parse: $_;\n";
948d0125
RL		 904 next;
905 } else {
906 next;
907 }
908
909 $syms{$s} = 1;
910 $kind{$s} = $k;
911
912 $p = $plats;
913 $a = $algs;
914 $a .= ",BF" if($s =~ /EVP_bf/);
915 $a .= ",CAST" if($s =~ /EVP_cast/);
916 $a .= ",DES" if($s =~ /EVP_des/);
917 $a .= ",DSA" if($s =~ /EVP_dss/);
918 $a .= ",IDEA" if($s =~ /EVP_idea/);
919 $a .= ",MD2" if($s =~ /EVP_md2/);
920 $a .= ",MD4" if($s =~ /EVP_md4/);
921 $a .= ",MD5" if($s =~ /EVP_md5/);
922 $a .= ",RC2" if($s =~ /EVP_rc2/);
923 $a .= ",RC4" if($s =~ /EVP_rc4/);
924 $a .= ",RC5" if($s =~ /EVP_rc5/);
925 $a .= ",RIPEMD" if($s =~ /EVP_ripemd/);
926 $a .= ",SHA" if($s =~ /EVP_sha/);
927 $a .= ",RSA" if($s =~ /EVP_(Open|Seal)(Final|Init)/);
928 $a .= ",RSA" if($s =~ /PEM_Seal(Final|Init|Update)/);
929 $a .= ",RSA" if($s =~ /RSAPrivateKey/);
930 $a .= ",RSA" if($s =~ /SSLv23?_((client|server)_)?method/);
931
62dc5aad
RL		 932 $platform{$s} =
933 &reduce_platforms((defined($platform{$s})?$platform{$s}.',':"").$p);
948d0125
RL		 934 $algorithm{$s} .= ','.$a;
935
62dc5aad 936 if (defined($variant{$s})) {
c454dbcd
RL		 937 foreach $v (split /;/,$variant{$s}) {
938 (my $r, my $p, my $k) = split(/:/,$v);
939 my $ip = join ',',map({ /^!(.*)$/ ? $1 : "!".$_ } split /,/, $p);
940 $syms{$r} = 1;
941 if (!defined($k)) { $k = $kind{$s}; }
942 $kind{$r} = $k."(".$s.")";
943 $algorithm{$r} = $algorithm{$s};
944 $platform{$r} = &reduce_platforms($platform{$s}.",".$p.",".$p);
945 $platform{$s} = &reduce_platforms($platform{$s}.','.$ip.','.$ip);
946 print STDERR "DEBUG: \$variant{\"$s\"} = ",$v,"; \$r = $r; \$p = ",$platform{$r},"; \$a = ",$algorithm{$r},"; \$kind = ",$kind{$r},"\n" if $debug;
947 }
47339f61 948 }
62dc5aad 949 print STDERR "DEBUG: \$s = $s; \$p = ",$platform{$s},"; \$a = ",$algorithm{$s},"; \$kind = ",$kind{$s},"\n" if $debug;
d02b48c6 950 }
d02b48c6
RE		 951 }
952
948d0125 953 # Prune the returned symbols
47339f61 954
948d0125 955 delete $syms{"bn_dump1"};
948d0125
RL		 956 $platform{"BIO_s_log"} .= ",!WIN32,!WIN16,!macintosh";
957
2ae87d46
RL		 958 $platform{"PEM_read_NS_CERT_SEQ"} = "VMS";
959 $platform{"PEM_write_NS_CERT_SEQ"} = "VMS";
960 $platform{"PEM_read_P8_PRIV_KEY_INFO"} = "VMS";
961 $platform{"PEM_write_P8_PRIV_KEY_INFO"} = "VMS";
962
948d0125
RL		 963 # Info we know about
964
948d0125
RL		 965 push @ret, map { $_."\\".&info_string($_,"EXIST",
966 $platform{$_},
967 $kind{$_},
968 $algorithm{$_}) } keys %syms;
969
3f07fe09
RL		 970 if (keys %unknown_algorithms) {
971 print STDERR "WARNING: mkdef.pl doesn't know the following algorithms:\n";
972 print STDERR "\t",join("\n\t",keys %unknown_algorithms),"\n";
973 }
948d0125
RL		 974 return(@ret);
975}
976
62dc5aad
RL		 977# Param: string of comma-separated platform-specs.
978sub reduce_platforms
979{
980 my ($platforms) = @_;
948d0125
RL		 981 my $pl = defined($platforms) ? $platforms : "";
982 my %p = map { $_ => 0 } split /,/, $pl;
948d0125
RL		 983 my $ret;
984
62dc5aad
RL		 985 print STDERR "DEBUG: Entered reduce_platforms with \"$platforms\"\n"
986 if $debug;
948d0125
RL		 987 # We do this, because if there's code like the following, it really
988 # means the function exists in all cases and should therefore be
989 # everywhere. By increasing and decreasing, we may attain 0:
990 #
991 # ifndef WIN16
992 # int foo();
993 # else
994 # int _fat foo();
995 # endif
996 foreach $platform (split /,/, $pl) {
997 if ($platform =~ /^!(.*)$/) {
998 $p{$1}--;
999 } else {
1000 $p{$platform}++;
d02b48c6 1001 }
47339f61 1002 }
948d0125
RL		 1003 foreach $platform (keys %p) {
1004 if ($p{$platform} == 0) { delete $p{$platform}; }
d02b48c6
RE		 1005 }
1006
948d0125 1007 delete $p{""};
62dc5aad 1008
c454dbcd 1009 $ret = join(',',sort(map { $p{$_} < 0 ? "!".$_ : $_ } keys %p));
62dc5aad
RL		 1010 print STDERR "DEBUG: Exiting reduce_platforms with \"$ret\"\n"
1011 if $debug;
1012 return $ret;
1013}
1014
1015sub info_string {
1016 (my $symbol, my $exist, my $platforms, my $kind, my $algorithms) = @_;
1017
1018 my %a = defined($algorithms) ?
1019 map { $_ => 1 } split /,/, $algorithms : ();
1020 my $k = defined($kind) ? $kind : "FUNCTION";
1021 my $ret;
1022 my $p = &reduce_platforms($platforms);
1023
948d0125 1024 delete $a{""};
d02b48c6 1025
948d0125 1026 $ret = $exist;
62dc5aad 1027 $ret .= ":".$p;
948d0125 1028 $ret .= ":".$k;
62dc5aad 1029 $ret .= ":".join(',',sort keys %a);
948d0125
RL		 1030 return $ret;
1031}
1032
1033sub maybe_add_info {
1034 (my $name, *nums, my @symbols) = @_;
1035 my $sym;
1036 my $new_info = 0;
451e60e9 1037 my %syms=();
948d0125
RL		 1038
1039 print STDERR "Updating $name info\n";
1040 foreach $sym (@symbols) {
1041 (my $s, my $i) = split /\\/, $sym;
948d0125 1042 if (defined($nums{$s})) {
62dc5aad 1043 $i =~ s/^(.*?:.*?:\w+)(\(\w+\))?/$1/;
948d0125
RL		 1044 (my $n, my $dummy) = split /\\/, $nums{$s};
1045 if (!defined($dummy) || $i ne $dummy) {
1046 $nums{$s} = $n."\\".$i;
1047 $new_info++;
d399fdf8 1048 print STDERR "DEBUG: maybe_add_info for $s: \"$dummy\" => \"$i\"\n" if $debug;
948d0125
RL		 1049 }
1050 }
62dc5aad 1051 $syms{$s} = 1;
451e60e9
RL		 1052 }
1053
1054 my @s=sort { &parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n") } keys %nums;
1055 foreach $sym (@s) {
1056 (my $n, my $i) = split /\\/, $nums{$sym};
62dc5aad 1057 if (!defined($syms{$sym}) && $i !~ /^NOEXIST:/) {
451e60e9 1058 $new_info++;
62dc5aad 1059 print STDERR "DEBUG: maybe_add_info for $sym: -> undefined\n" if $debug;
451e60e9 1060 }
948d0125
RL		 1061 }
1062 if ($new_info) {
1063 print STDERR "$new_info old symbols got an info update\n";
6d50071e
RL		 1064 if (!$do_rewrite) {
1065 print STDERR "You should do a rewrite to fix this.\n";
1066 }
948d0125
RL		 1067 } else {
1068 print STDERR "No old symbols needed info update\n";
1069 }
47339f61 1070}
d02b48c6 1071
62dc5aad
RL		 1072# Param: string of comma-separated keywords, each possibly prefixed with a "!"
1073sub is_valid
1074{
1075 my ($keywords_txt,$platforms) = @_;
1076 my (@keywords) = split /,/,$keywords_txt;
d3fdc27a 1077 my ($falsesum, $truesum) = (0, 1);
62dc5aad
RL		 1078
1079 # Param: one keyword
1080 sub recognise
1081 {
1082 my ($keyword,$platforms) = @_;
1083
1084 if ($platforms) {
1085 # platforms
1086 if ($keyword eq "VMS" && $VMS) { return 1; }
1087 if ($keyword eq "WIN32" && $W32) { return 1; }
1088 if ($keyword eq "WIN16" && $W16) { return 1; }
1089 if ($keyword eq "WINNT" && $NT) { return 1; }
cd4c36ad 1090 if ($keyword eq "OS2" && $OS2) { return 1; }
62dc5aad
RL		 1091 # Special platforms:
1092 # EXPORT_VAR_AS_FUNCTION means that global variables
1093 # will be represented as functions. This currently
1094 # only happens on VMS-VAX.
2d10c715 1095 if ($keyword eq "EXPORT_VAR_AS_FUNCTION" && ($VMSVAX || $W32 || $W16)) {
62dc5aad
RL		 1096 return 1;
1097 }
8931b30d 1098 if ($keyword eq "ZLIB" && $zlib) { return 1; }
62dc5aad
RL		 1099 return 0;
1100 } else {
1101 # algorithms
1102 if ($keyword eq "RC2" && $no_rc2) { return 0; }
1103 if ($keyword eq "RC4" && $no_rc4) { return 0; }
1104 if ($keyword eq "RC5" && $no_rc5) { return 0; }
1105 if ($keyword eq "IDEA" && $no_idea) { return 0; }
1106 if ($keyword eq "DES" && $no_des) { return 0; }
1107 if ($keyword eq "BF" && $no_bf) { return 0; }
1108 if ($keyword eq "CAST" && $no_cast) { return 0; }
1109 if ($keyword eq "MD2" && $no_md2) { return 0; }
1110 if ($keyword eq "MD4" && $no_md4) { return 0; }
1111 if ($keyword eq "MD5" && $no_md5) { return 0; }
1112 if ($keyword eq "SHA" && $no_sha) { return 0; }
1113 if ($keyword eq "RIPEMD" && $no_ripemd) { return 0; }
1114 if ($keyword eq "MDC2" && $no_mdc2) { return 0; }
ec645d90 1115 if ($keyword eq "WHIRLPOOL" && $no_whirlpool) { return 0; }
62dc5aad
RL		 1116 if ($keyword eq "RSA" && $no_rsa) { return 0; }
1117 if ($keyword eq "DSA" && $no_dsa) { return 0; }
1118 if ($keyword eq "DH" && $no_dh) { return 0; }
26a81abf 1119 if ($keyword eq "EC" && $no_ec) { return 0; }
4d94ae00 1120 if ($keyword eq "ECDSA" && $no_ecdsa) { return 0; }
e172d60d 1121 if ($keyword eq "ECDH" && $no_ecdh) { return 0; }
62dc5aad
RL		 1122 if ($keyword eq "HMAC" && $no_hmac) { return 0; }
1123 if ($keyword eq "AES" && $no_aes) { return 0; }
f3dea9a5 1124 if ($keyword eq "CAMELLIA" && $no_camellia) { return 0; }
96afc1cf 1125 if ($keyword eq "SEED" && $no_seed) { return 0; }
26a81abf
RL		 1126 if ($keyword eq "EVP" && $no_evp) { return 0; }
1127 if ($keyword eq "LHASH" && $no_lhash) { return 0; }
1128 if ($keyword eq "STACK" && $no_stack) { return 0; }
1129 if ($keyword eq "ERR" && $no_err) { return 0; }
1130 if ($keyword eq "BUFFER" && $no_buffer) { return 0; }
1131 if ($keyword eq "BIO" && $no_bio) { return 0; }
1132 if ($keyword eq "COMP" && $no_comp) { return 0; }
1133 if ($keyword eq "DSO" && $no_dso) { return 0; }
62dc5aad 1134 if ($keyword eq "KRB5" && $no_krb5) { return 0; }
0b13e9f0 1135 if ($keyword eq "ENGINE" && $no_engine) { return 0; }
5cd48abf 1136 if ($keyword eq "HW" && $no_hw) { return 0; }
62dc5aad 1137 if ($keyword eq "FP_API" && $no_fp_api) { return 0; }
6cb68620 1138 if ($keyword eq "STATIC_ENGINE" && $no_static_engine) { return 0; }
987bebaf 1139 if ($keyword eq "GMP" && $no_gmp) { return 0; }
d137b56a 1140 if ($keyword eq "RFC3779" && $no_rfc3779) { return 0; }
c20276e4
DSH		 1141 if ($keyword eq "TLSEXT" && $no_tlsext) { return 0; }
1142 if ($keyword eq "PSK" && $no_psk) { return 0; }
8931b30d 1143 if ($keyword eq "CMS" && $no_cms) { return 0; }
d8bd55a3 1144 if ($keyword eq "CAPIENG" && $no_capieng) { return 0; }
4ccfe5f4 1145 if ($keyword eq "DEPRECATED" && $no_deprecated) { return 0; }
62dc5aad
RL		 1146
1147 # Nothing recognise as true
1148 return 1;
1149 }
1150 }
1151
1152 foreach $k (@keywords) {
1153 if ($k =~ /^!(.*)$/) {
1154 $falsesum += &recognise($1,$platforms);
1155 } else {
d3fdc27a 1156 $truesum *= &recognise($k,$platforms);
62dc5aad
RL		 1157 }
1158 }
1159 print STDERR "DEBUG: [",$#keywords,",",$#keywords < 0,"] is_valid($keywords_txt) => (\!$falsesum) && $truesum = ",(!$falsesum) && $truesum,"\n" if $debug;
1160 return (!$falsesum) && $truesum;
1161}
1162
12aefe78
DSH		 1163sub print_test_file
1164{
62dc5aad 1165 (*OUT,my $name,*nums,my $testall,my @symbols)=@_;
0f583f69 1166 my $n = 1; my @e; my @r;
948d0125
RL		 1167 my $sym; my $prev = ""; my $prefSSLeay;
1168
62dc5aad
RL		 1169 (@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
1170 (@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:.*/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
948d0125
RL		 1171 @symbols=((sort @e),(sort @r));
1172
1173 foreach $sym (@symbols) {
1174 (my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
62dc5aad
RL		 1175 my $v = 0;
1176 $v = 1 if $i=~ /^.*?:.*?:VARIABLE/;
1177 my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
1178 my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
1179 if (!defined($nums{$s})) {
1180 print STDERR "Warning: $s does not have a number assigned\n"
1181 if(!$do_update);
1182 } elsif (is_valid($p,1) && is_valid($a,0)) {
1183 my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
1184 if ($prev eq $s2) {
1185 print OUT "\t/* The following has already appeared previously */\n";
1186 print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
1187 }
1188 $prev = $s2; # To warn about duplicates...
1189
1190 ($nn,$ni)=($nums{$s2} =~ /^(.*?)\\(.*)$/);
1191 if ($v) {
1192 print OUT "\textern int $s2; /* type unknown */ /* $nn $ni */\n";
967f4ca8 1193 } else {
62dc5aad 1194 print OUT "\textern int $s2(); /* type unknown */ /* $nn $ni */\n";
967f4ca8 1195 }
12aefe78
DSH		 1196 }
1197 }
1198}
1199
0b352c58
RL		 1200sub get_version {
1201 local *MF;
1202 my $v = '?';
52272327 1203 open MF, 'Makefile' or return $v;
0b352c58
RL		 1204 while (<MF>) {
1205 $v = $1, last if /^VERSION=(.*?)\s*$/;
1206 }
1207 close MF;
1208 return $v;
1209}
1210
d02b48c6 1211sub print_def_file
47339f61 1212{
948d0125 1213 (*OUT,my $name,*nums,my @symbols)=@_;
62dc5aad 1214 my $n = 1; my @e; my @r; my @v; my $prev="";
cd4c36ad 1215 my $liboptions="";
0b352c58
RL		 1216 my $libname = $name;
1217 my $http_vendor = 'www.openssl.org/';
1218 my $version = get_version();
1219 my $what = "OpenSSL: implementation of Secure Socket Layer";
1220 my $description = "$what $version, $name - http://$http_vendor";
d02b48c6 1221
06c68491 1222 if ($W32)
0b352c58 1223 { $libname.="32"; }
cd4c36ad 1224 elsif ($W16)
0b352c58 1225 { $libname.="16"; }
cd4c36ad 1226 elsif ($OS2)
0b352c58
RL		 1227 { # DLL names should not clash on the whole system.
1228 # However, they should not have any particular relationship
1229 # to the name of the static library. Chose descriptive names
1230 # (must be at most 8 chars).
1231 my %translate = (ssl => 'open_ssl', crypto => 'cryptssl');
1232 $libname = $translate{$name} || $name;
1233 $liboptions = <<EOO;
1234INITINSTANCE
1235DATA MULTIPLE NONSHARED
1236EOO
1237 # Vendor field can't contain colon, drat; so we omit http://
1238 $description = "\@#$http_vendor:$version#\@$what; DLL for library $name. Build for EMX -Zmtd";
1239 }
d02b48c6
RE		 1240
1241 print OUT <<"EOF";
1242;
9b3086fe 1243; Definition file for the DLL version of the $name library from OpenSSL
d02b48c6
RE		 1244;
1245
0b352c58 1246LIBRARY $libname $liboptions
d02b48c6 1247
d02b48c6
RE		 1248EOF
1249
cd4c36ad 1250 if ($W16) {
d02b48c6
RE		 1251 print <<"EOF";
1252CODE PRELOAD MOVEABLE
1253DATA PRELOAD MOVEABLE SINGLE
1254
1255EXETYPE WINDOWS
1256
1257HEAPSIZE 4096
1258STACKSIZE 8192
1259
1260EOF
47339f61 1261 }
d02b48c6
RE		 1262
1263 print "EXPORTS\n";
1264
62dc5aad
RL		 1265 (@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
1266 (@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:FUNCTION/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
1267 (@v)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:VARIABLE/,@symbols);
9c67ab2f 1268 @symbols=((sort @e),(sort @r), (sort @v));
d02b48c6 1269
d02b48c6 1270
948d0125
RL		 1271 foreach $sym (@symbols) {
1272 (my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
9c67ab2f 1273 my $v = 0;
62dc5aad 1274 $v = 1 if $i =~ /^.*?:.*?:VARIABLE/;
948d0125
RL		 1275 if (!defined($nums{$s})) {
1276 printf STDERR "Warning: $s does not have a number assigned\n"
62dc5aad 1277 if(!$do_update);
47339f61 1278 } else {
62dc5aad 1279 (my $n, my $dummy) = split /\\/, $nums{$s};
d63b8db8 1280 my %pf = ();
62dc5aad
RL		 1281 my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
1282 my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
1283 if (is_valid($p,1) && is_valid($a,0)) {
1284 my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
1285 if ($prev eq $s2) {
1286 print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
1287 }
1288 $prev = $s2; # To warn about duplicates...
cd4c36ad 1289 if($v && !$OS2) {
b4f682d3 1290 printf OUT " %s%-39s @%-8d DATA\n",($W32)?"":"_",$s2,$n;
9c67ab2f 1291 } else {
cd4c36ad 1292 printf OUT " %s%-39s @%d\n",($W32||$OS2)?"":"_",$s2,$n;
9c67ab2f 1293 }
965c1775 1294 }
d02b48c6 1295 }
d02b48c6 1296 }
47339f61
DSH		 1297 printf OUT "\n";
1298}
d02b48c6
RE		 1299
1300sub load_numbers
47339f61
DSH		 1301{
1302 my($name)=@_;
1303 my(@a,%ret);
d02b48c6 1304
55a9cc6e 1305 $max_num = 0;
948d0125
RL		 1306 $num_noinfo = 0;
1307 $prev = "";
62dc5aad 1308 $prev_cnt = 0;
55a9cc6e 1309
d02b48c6 1310 open(IN,"<$name") || die "unable to open $name:$!\n";
47339f61 1311 while (<IN>) {
d02b48c6
RE		 1312 chop;
1313 s/#.*$//;
1314 next if /^\s*$/;
1315 @a=split;
948d0125 1316 if (defined $ret{$a[0]}) {
62dc5aad
RL		 1317 # This is actually perfectly OK
1318 #print STDERR "Warning: Symbol '",$a[0],"' redefined. old=",$ret{$a[0]},", new=",$a[1],"\n";
948d0125
RL		 1319 }
1320 if ($max_num > $a[1]) {
1321 print STDERR "Warning: Number decreased from ",$max_num," to ",$a[1],"\n";
1322 }
62dc5aad 1323 elsif ($max_num == $a[1]) {
948d0125
RL		 1324 # This is actually perfectly OK
1325 #print STDERR "Warning: Symbol ",$a[0]," has same number as previous ",$prev,": ",$a[1],"\n";
62dc5aad
RL		 1326 if ($a[0] eq $prev) {
1327 $prev_cnt++;
1328 $a[0] .= "{$prev_cnt}";
1329 }
1330 }
1331 else {
1332 $prev_cnt = 0;
948d0125
RL		 1333 }
1334 if ($#a < 2) {
1335 # Existence will be proven later, in do_defs
1336 $ret{$a[0]}=$a[1];
1337 $num_noinfo++;
1338 } else {
1339 $ret{$a[0]}=$a[1]."\\".$a[2]; # \\ is a special marker
1340 }
55a9cc6e 1341 $max_num = $a[1] if $a[1] > $max_num;
948d0125
RL		 1342 $prev=$a[0];
1343 }
1344 if ($num_noinfo) {
1345 print STDERR "Warning: $num_noinfo symbols were without info.";
1346 if ($do_rewrite) {
1347 printf STDERR " The rewrite will fix this.\n";
1348 } else {
1349 printf STDERR " You should do a rewrite to fix this.\n";
1350 }
47339f61 1351 }
d02b48c6
RE		 1352 close(IN);
1353 return(%ret);
47339f61 1354}
55a9cc6e 1355
948d0125
RL		 1356sub parse_number
1357{
1358 (my $str, my $what) = @_;
1359 (my $n, my $i) = split(/\\/,$str);
1360 if ($what eq "n") {
1361 return $n;
1362 } else {
1363 return $i;
1364 }
1365}
1366
1367sub rewrite_numbers
1368{
1369 (*OUT,$name,*nums,@symbols)=@_;
1370 my $thing;
1371
1372 print STDERR "Rewriting $name\n";
1373
62dc5aad 1374 my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
948d0125
RL		 1375 my $r; my %r; my %rsyms;
1376 foreach $r (@r) {
1377 (my $s, my $i) = split /\\/, $r;
1378 my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
1379 $i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
1380 $r{$a} = $s."\\".$i;
1381 $rsyms{$s} = 1;
1382 }
1383
451e60e9
RL		 1384 my %syms = ();
1385 foreach $_ (@symbols) {
1386 (my $n, my $i) = split /\\/;
1387 $syms{$n} = 1;
1388 }
1389
89eeccac
RL		 1390 my @s=sort {
1391 &parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n")
1392 || $a cmp $b
1393 } keys %nums;
948d0125
RL		 1394 foreach $sym (@s) {
1395 (my $n, my $i) = split /\\/, $nums{$sym};
1396 next if defined($i) && $i =~ /^.*?:.*?:\w+\(\w+\)/;
1397 next if defined($rsyms{$sym});
62dc5aad 1398 print STDERR "DEBUG: rewrite_numbers for sym = ",$sym,": i = ",$i,", n = ",$n,", rsym{sym} = ",$rsyms{$sym},"syms{sym} = ",$syms{$sym},"\n" if $debug;
451e60e9
RL		 1399 $i="NOEXIST::FUNCTION:"
1400 if !defined($i) || $i eq "" || !defined($syms{$sym});
62dc5aad
RL		 1401 my $s2 = $sym;
1402 $s2 =~ s/\{[0-9]+\}$//;
b4f682d3 1403 printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
948d0125
RL		 1404 if (exists $r{$sym}) {
1405 (my $s, $i) = split /\\/,$r{$sym};
62dc5aad
RL		 1406 my $s2 = $s;
1407 $s2 =~ s/\{[0-9]+\}$//;
b4f682d3 1408 printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
948d0125
RL		 1409 }
1410 }
1411}
1412
55a9cc6e 1413sub update_numbers
47339f61 1414{
948d0125
RL		 1415 (*OUT,$name,*nums,my $start_num, my @symbols)=@_;
1416 my $new_syms = 0;
1417
1418 print STDERR "Updating $name numbers\n";
1419
62dc5aad 1420 my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
948d0125
RL		 1421 my $r; my %r; my %rsyms;
1422 foreach $r (@r) {
1423 (my $s, my $i) = split /\\/, $r;
1424 my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
1425 $i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
1426 $r{$a} = $s."\\".$i;
1427 $rsyms{$s} = 1;
1428 }
1429
1430 foreach $sym (@symbols) {
1431 (my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
1432 next if $i =~ /^.*?:.*?:\w+\(\w+\)/;
1433 next if defined($rsyms{$sym});
1434 die "ERROR: Symbol $sym had no info attached to it."
1435 if $i eq "";
1436 if (!exists $nums{$s}) {
1437 $new_syms++;
62dc5aad
RL		 1438 my $s2 = $s;
1439 $s2 =~ s/\{[0-9]+\}$//;
b4f682d3 1440 printf OUT "%s%-39s %d\t%s\n","",$s2, ++$start_num,$i;
948d0125 1441 if (exists $r{$s}) {
33b1a4c2 1442 ($s, $i) = split /\\/,$r{$s};
62dc5aad 1443 $s =~ s/\{[0-9]+\}$//;
b4f682d3 1444 printf OUT "%s%-39s %d\t%s\n","",$s, $start_num,$i;
948d0125 1445 }
55a9cc6e 1446 }
47339f61 1447 }
948d0125
RL		 1448 if($new_syms) {
1449 print STDERR "$new_syms New symbols added\n";
55a9cc6e 1450 } else {
948d0125
RL		 1451 print STDERR "No New symbols Added\n";
1452 }
1453}
1454
1455sub check_existing
1456{
1457 (*nums, my @symbols)=@_;
1458 my %existing; my @remaining;
1459 @remaining=();
1460 foreach $sym (@symbols) {
1461 (my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
1462 $existing{$s}=1;
1463 }
1464 foreach $sym (keys %nums) {
1465 if (!exists $existing{$sym}) {
1466 push @remaining, $sym;
1467 }
1468 }
1469 if(@remaining) {
1470 print STDERR "The following symbols do not seem to exist:\n";
1471 foreach $sym (@remaining) {
1472 print STDERR "\t",$sym,"\n";
1473 }
55a9cc6e 1474 }
47339f61 1475}
948d0125 1476
A mirror of the official openssl repository