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