PageRenderTime 61ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 0ms

/crypto/openssl/util/mkdef.pl

https://bitbucket.org/freebsd/freebsd-head/
Perl | 1539 lines | 1256 code | 114 blank | 169 comment | 373 complexity | a46f1329369ea1e3e09a3b2fb8bd3fed MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, BSD-3-Clause, LGPL-2.0, LGPL-2.1, BSD-2-Clause, 0BSD, JSON, AGPL-1.0, GPL-2.0 
    

  1. #!/usr/local/bin/perl -w
    2. 

  2. #
    3. 

  3. # generate a .def file
    4. 

  4. #
    5. 

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

  6. # prototyped functions: it then prunes the output.
    7. 

  7. #
    8. 

  8. # Intermediary files are created, call libeay.num and ssleay.num,...
    9. 

  9. # Previously, they had the following format:
    10. 

  10. #
    11. 

  11. #	routine-name	nnnn
    12. 

  12. #
    13. 

  13. # But that isn't enough for a number of reasons, the first on being that
    14. 

  14. # this format is (needlessly) very Win32-centric, and even then...
    15. 

  15. # One of the biggest problems is that there's no information about what
    16. 

  16. # routines should actually be used, which varies with what crypto algorithms
    17. 

  17. # are disabled.  Also, some operating systems (for example VMS with VAX C)
    18. 

  18. # need to keep track of the global variables as well as the functions.
    19. 

  19. #
    20. 

  20. # So, a remake of this script is done so as to include information on the
    21. 

  21. # kind of symbol it is (function or variable) and what algorithms they're
    22. 

  22. # part of.  This will allow easy translating to .def files or the corresponding
    23. 

  23. # file in other operating systems (a .opt file for VMS, possibly with a .mar
    24. 

  24. # file).
    25. 

  25. #
    26. 

  26. # The format now becomes:
    27. 

  27. #
    28. 

  28. #	routine-name	nnnn	info
    29. 

  29. #
    30. 

  30. # and the "info" part is actually a colon-separated string of fields with
    31. 

  31. # the following meaning:
    32. 

  32. #
    33. 

  33. #	existence:platform:kind:algorithms
    34. 

  34. #
    35. 

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

  36. #   found somewhere in the source, 
    37. 

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

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

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

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

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

  42. #   clash, or the symbol is implemented differently (see
    43. 

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

  44. #   in the file crypto/symhacks.h.
    45. 

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

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

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

  48. #   used.  For the positive itms, if all of them are false in the environment,
    49. 

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

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

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

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

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

  54. #   exclude.
    55. 

  55. #
    56. 

  56. 

  57. my $debug=0;
    58. 

  58. 

  59. my $crypto_num= "util/libeay.num";
    60. 

  60. my $ssl_num=    "util/ssleay.num";
    61. 

  61. my $libname;
    62. 

  62. 

  63. my $do_update = 0;
    64. 

  64. my $do_rewrite = 1;
    65. 

  65. my $do_crypto = 0;
    66. 

  66. my $do_ssl = 0;
    67. 

  67. my $do_ctest = 0;
    68. 

  68. my $do_ctestall = 0;
    69. 

  69. my $do_checkexist = 0;
    70. 

  70. 

  71. my $VMSVAX=0;
    72. 

  72. my $VMSNonVAX=0;
    73. 

  73. my $VMS=0;
    74. 

  74. my $W32=0;
    75. 

  75. my $W16=0;
    76. 

  76. my $NT=0;
    77. 

  77. my $OS2=0;
    78. 

  78. # Set this to make typesafe STACK definitions appear in DEF
    79. 

  79. my $safe_stack_def = 0;
    80. 

  80. 

  81. my @known_platforms = ( "__FreeBSD__", "PERL5", "NeXT",
    82. 

  82. 			"EXPORT_VAR_AS_FUNCTION", "ZLIB", "OPENSSL_FIPS" );
    83. 

  83. my @known_ossl_platforms = ( "VMS", "WIN16", "WIN32", "WINNT", "OS2" );
    84. 

  84. my @known_algorithms = ( "RC2", "RC4", "RC5", "IDEA", "DES", "BF",
    85. 

  85. 			 "CAST", "MD2", "MD4", "MD5", "SHA", "SHA0", "SHA1",
    86. 

  86. 			 "SHA256", "SHA512", "RIPEMD",
    87. 

  87. 			 "MDC2", "WHIRLPOOL", "RSA", "DSA", "DH", "EC", "ECDH", "ECDSA", "EC2M",
    88. 

  88. 			 "HMAC", "AES", "CAMELLIA", "SEED", "GOST",
    89. 

  89. 			 # EC_NISTP_64_GCC_128
    90. 

  90. 			 "EC_NISTP_64_GCC_128",
    91. 

  91. 			 # Envelope "algorithms"
    92. 

  92. 			 "EVP", "X509", "ASN1_TYPEDEFS",
    93. 

  93. 			 # Helper "algorithms"
    94. 

  94. 			 "BIO", "COMP", "BUFFER", "LHASH", "STACK", "ERR",
    95. 

  95. 			 "LOCKING",
    96. 

  96. 			 # External "algorithms"
    97. 

  97. 			 "FP_API", "STDIO", "SOCK", "KRB5", "DGRAM",
    98. 

  98. 			 # Engines
    99. 

  99. 			 "STATIC_ENGINE", "ENGINE", "HW", "GMP",
    100. 

  100. 			 # RFC3779
    101. 

  101. 			 "RFC3779",
    102. 

  102. 			 # TLS
    103. 

  103. 			 "TLSEXT", "PSK", "SRP", "HEARTBEATS",
    104. 

  104. 			 # CMS
    105. 

  105. 			 "CMS",
    106. 

  106. 			 # CryptoAPI Engine
    107. 

  107. 			 "CAPIENG",
    108. 

  108. 			 # SSL v2
    109. 

  109. 			 "SSL2",
    110. 

  110. 			 # JPAKE
    111. 

  111. 			 "JPAKE",
    112. 

  112. 			 # NEXTPROTONEG
    113. 

  113. 			 "NEXTPROTONEG",
    114. 

  114. 			 # Deprecated functions
    115. 

  115. 			 "DEPRECATED",
    116. 

  116. 			 # Hide SSL internals
    117. 

  117. 			 "SSL_INTERN",
    118. 

  118. 			 # SCTP
    119. 

  119. 			 "SCTP");
    120. 

  120. 

  121. my $options="";
    122. 

  122. open(IN,"<Makefile") || die "unable to open Makefile!\n";
    123. 

  123. while(<IN>) {
    124. 

  124.     $options=$1 if (/^OPTIONS=(.*)$/);
    125. 

  125. }
    126. 

  126. close(IN);
    127. 

  127. 

  128. # The following ciphers may be excluded (by Configure). This means functions
    129. 

  129. # defined with ifndef(NO_XXX) are not included in the .def file, and everything
    130. 

  130. # in directory xxx is ignored.
    131. 

  131. my $no_rc2; my $no_rc4; my $no_rc5; my $no_idea; my $no_des; my $no_bf;
    132. 

  132. my $no_cast; my $no_whirlpool; my $no_camellia; my $no_seed;
    133. 

  133. my $no_md2; my $no_md4; my $no_md5; my $no_sha; my $no_ripemd; my $no_mdc2;
    134. 

  134. my $no_rsa; my $no_dsa; my $no_dh; my $no_hmac=0; my $no_aes; my $no_krb5;
    135. 

  135. my $no_ec; my $no_ecdsa; my $no_ecdh; my $no_engine; my $no_hw;
    136. 

  136. my $no_fp_api; my $no_static_engine=1; my $no_gmp; my $no_deprecated;
    137. 

  137. my $no_rfc3779; my $no_psk; my $no_tlsext; my $no_cms; my $no_capieng;
    138. 

  138. my $no_jpake; my $no_srp; my $no_ssl2; my $no_ec2m; my $no_nistp_gcc; 
    139. 

  139. my $no_nextprotoneg; my $no_sctp;
    140. 

  140. 

  141. my $fips;
    142. 

  142. 

  143. my $zlib;
    144. 

  144. 

  145. 

  146. foreach (@ARGV, split(/ /, $options))
    147. 

  147. 	{
    148. 

  148. 	$debug=1 if $_ eq "debug";
    149. 

  149. 	$W32=1 if $_ eq "32";
    150. 

  150. 	$W16=1 if $_ eq "16";
    151. 

  151. 	if($_ eq "NT") {
    152. 

  152. 		$W32 = 1;
    153. 

  153. 		$NT = 1;
    154. 

  154. 	}
    155. 

  155. 	if ($_ eq "VMS-VAX") {
    156. 

  156. 		$VMS=1;
    157. 

  157. 		$VMSVAX=1;
    158. 

  158. 	}
    159. 

  159. 	if ($_ eq "VMS-NonVAX") {
    160. 

  160. 		$VMS=1;
    161. 

  161. 		$VMSNonVAX=1;
    162. 

  162. 	}
    163. 

  163. 	$VMS=1 if $_ eq "VMS";
    164. 

  164. 	$OS2=1 if $_ eq "OS2";
    165. 

  165. 	$fips=1 if /^fips/;
    166. 

  166. 	if ($_ eq "zlib" || $_ eq "enable-zlib" || $_ eq "zlib-dynamic"
    167. 

  167. 			 || $_ eq "enable-zlib-dynamic") {
    168. 

  168. 		$zlib = 1;
    169. 

  169. 	}
    170. 

  170. 

  171. 	$do_ssl=1 if $_ eq "ssleay";
    172. 

  172. 	if ($_ eq "ssl") {
    173. 

  173. 		$do_ssl=1; 
    174. 

  174. 		$libname=$_
    175. 

  175. 	}
    176. 

  176. 	$do_crypto=1 if $_ eq "libeay";
    177. 

  177. 	if ($_ eq "crypto") {
    178. 

  178. 		$do_crypto=1;
    179. 

  179. 		$libname=$_;
    180. 

  180. 	}
    181. 

  181. 	$no_static_engine=1 if $_ eq "no-static-engine";
    182. 

  182. 	$no_static_engine=0 if $_ eq "enable-static-engine";
    183. 

  183. 	$do_update=1 if $_ eq "update";
    184. 

  184. 	$do_rewrite=1 if $_ eq "rewrite";
    185. 

  185. 	$do_ctest=1 if $_ eq "ctest";
    186. 

  186. 	$do_ctestall=1 if $_ eq "ctestall";
    187. 

  187. 	$do_checkexist=1 if $_ eq "exist";
    188. 

  188. 	#$safe_stack_def=1 if $_ eq "-DDEBUG_SAFESTACK";
    189. 

  189. 

  190. 	if    (/^no-rc2$/)      { $no_rc2=1; }
    191. 

  191. 	elsif (/^no-rc4$/)      { $no_rc4=1; }
    192. 

  192. 	elsif (/^no-rc5$/)      { $no_rc5=1; }
    193. 

  193. 	elsif (/^no-idea$/)     { $no_idea=1; }
    194. 

  194. 	elsif (/^no-des$/)      { $no_des=1; $no_mdc2=1; }
    195. 

  195. 	elsif (/^no-bf$/)       { $no_bf=1; }
    196. 

  196. 	elsif (/^no-cast$/)     { $no_cast=1; }
    197. 

  197. 	elsif (/^no-whirlpool$/)     { $no_whirlpool=1; }
    198. 

  198. 	elsif (/^no-md2$/)      { $no_md2=1; }
    199. 

  199. 	elsif (/^no-md4$/)      { $no_md4=1; }
    200. 

  200. 	elsif (/^no-md5$/)      { $no_md5=1; }
    201. 

  201. 	elsif (/^no-sha$/)      { $no_sha=1; }
    202. 

  202. 	elsif (/^no-ripemd$/)   { $no_ripemd=1; }
    203. 

  203. 	elsif (/^no-mdc2$/)     { $no_mdc2=1; }
    204. 

  204. 	elsif (/^no-rsa$/)      { $no_rsa=1; }
    205. 

  205. 	elsif (/^no-dsa$/)      { $no_dsa=1; }
    206. 

  206. 	elsif (/^no-dh$/)       { $no_dh=1; }
    207. 

  207. 	elsif (/^no-ec$/)       { $no_ec=1; }
    208. 

  208. 	elsif (/^no-ecdsa$/)	{ $no_ecdsa=1; }
    209. 

  209. 	elsif (/^no-ecdh$/) 	{ $no_ecdh=1; }
    210. 

  210. 	elsif (/^no-hmac$/)	{ $no_hmac=1; }
    211. 

  211. 	elsif (/^no-aes$/)	{ $no_aes=1; }
    212. 

  212. 	elsif (/^no-camellia$/)	{ $no_camellia=1; }
    213. 

  213. 	elsif (/^no-seed$/)     { $no_seed=1; }
    214. 

  214. 	elsif (/^no-evp$/)	{ $no_evp=1; }
    215. 

  215. 	elsif (/^no-lhash$/)	{ $no_lhash=1; }
    216. 

  216. 	elsif (/^no-stack$/)	{ $no_stack=1; }
    217. 

  217. 	elsif (/^no-err$/)	{ $no_err=1; }
    218. 

  218. 	elsif (/^no-buffer$/)	{ $no_buffer=1; }
    219. 

  219. 	elsif (/^no-bio$/)	{ $no_bio=1; }
    220. 

  220. 	#elsif (/^no-locking$/)	{ $no_locking=1; }
    221. 

  221. 	elsif (/^no-comp$/)	{ $no_comp=1; }
    222. 

  222. 	elsif (/^no-dso$/)	{ $no_dso=1; }
    223. 

  223. 	elsif (/^no-krb5$/)	{ $no_krb5=1; }
    224. 

  224. 	elsif (/^no-engine$/)	{ $no_engine=1; }
    225. 

  225. 	elsif (/^no-hw$/)	{ $no_hw=1; }
    226. 

  226. 	elsif (/^no-gmp$/)	{ $no_gmp=1; }
    227. 

  227. 	elsif (/^no-rfc3779$/)	{ $no_rfc3779=1; }
    228. 

  228. 	elsif (/^no-tlsext$/)	{ $no_tlsext=1; }
    229. 

  229. 	elsif (/^no-cms$/)	{ $no_cms=1; }
    230. 

  230. 	elsif (/^no-ec2m$/)	{ $no_ec2m=1; }
    231. 

  231. 	elsif (/^no-ec_nistp_64_gcc_128$/)	{ $no_nistp_gcc=1; }
    232. 

  232. 	elsif (/^no-nextprotoneg$/)	{ $no_nextprotoneg=1; }
    233. 

  233. 	elsif (/^no-ssl2$/)	{ $no_ssl2=1; }
    234. 

  234. 	elsif (/^no-capieng$/)	{ $no_capieng=1; }
    235. 

  235. 	elsif (/^no-jpake$/)	{ $no_jpake=1; }
    236. 

  236. 	elsif (/^no-srp$/)	{ $no_srp=1; }
    237. 

  237. 	elsif (/^no-sctp$/)	{ $no_sctp=1; }
    238. 

  238. 	}
    239. 

  239. 

  240. 

  241. if (!$libname) { 
    242. 

  242. 	if ($do_ssl) {
    243. 

  243. 		$libname="SSLEAY";
    244. 

  244. 	}
    245. 

  245. 	if ($do_crypto) {
    246. 

  246. 		$libname="LIBEAY";
    247. 

  247. 	}
    248. 

  248. }
    249. 

  249. 

  250. # If no platform is given, assume WIN32
    251. 

  251. if ($W32 + $W16 + $VMS + $OS2 == 0) {
    252. 

  252. 	$W32 = 1;
    253. 

  253. }
    254. 

  254. 

  255. # Add extra knowledge
    256. 

  256. if ($W16) {
    257. 

  257. 	$no_fp_api=1;
    258. 

  258. }
    259. 

  259. 

  260. if (!$do_ssl && !$do_crypto)
    261. 

  261. 	{
    262. 

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

  263. 	exit(1);
    264. 

  264. 	}
    265. 

  265. 

  266. %ssl_list=&load_numbers($ssl_num);
    267. 

  267. $max_ssl = $max_num;
    268. 

  268. %crypto_list=&load_numbers($crypto_num);
    269. 

  269. $max_crypto = $max_num;
    270. 

  270. 

  271. my $ssl="ssl/ssl.h";
    272. 

  272. $ssl.=" ssl/kssl.h";
    273. 

  273. $ssl.=" ssl/tls1.h";
    274. 

  274. $ssl.=" ssl/srtp.h";
    275. 

  275. 

  276. my $crypto ="crypto/crypto.h";
    277. 

  277. $crypto.=" crypto/cryptlib.h";
    278. 

  278. $crypto.=" crypto/o_dir.h";
    279. 

  279. $crypto.=" crypto/o_str.h";
    280. 

  280. $crypto.=" crypto/o_time.h";
    281. 

  281. $crypto.=" crypto/des/des.h crypto/des/des_old.h" ; # unless $no_des;
    282. 

  282. $crypto.=" crypto/idea/idea.h" ; # unless $no_idea;
    283. 

  283. $crypto.=" crypto/rc4/rc4.h" ; # unless $no_rc4;
    284. 

  284. $crypto.=" crypto/rc5/rc5.h" ; # unless $no_rc5;
    285. 

  285. $crypto.=" crypto/rc2/rc2.h" ; # unless $no_rc2;
    286. 

  286. $crypto.=" crypto/bf/blowfish.h" ; # unless $no_bf;
    287. 

  287. $crypto.=" crypto/cast/cast.h" ; # unless $no_cast;
    288. 

  288. $crypto.=" crypto/whrlpool/whrlpool.h" ;
    289. 

  289. $crypto.=" crypto/md2/md2.h" ; # unless $no_md2;
    290. 

  290. $crypto.=" crypto/md4/md4.h" ; # unless $no_md4;
    291. 

  291. $crypto.=" crypto/md5/md5.h" ; # unless $no_md5;
    292. 

  292. $crypto.=" crypto/mdc2/mdc2.h" ; # unless $no_mdc2;
    293. 

  293. $crypto.=" crypto/sha/sha.h" ; # unless $no_sha;
    294. 

  294. $crypto.=" crypto/ripemd/ripemd.h" ; # unless $no_ripemd;
    295. 

  295. $crypto.=" crypto/aes/aes.h" ; # unless $no_aes;
    296. 

  296. $crypto.=" crypto/camellia/camellia.h" ; # unless $no_camellia;
    297. 

  297. $crypto.=" crypto/seed/seed.h"; # unless $no_seed;
    298. 

  298. 

  299. $crypto.=" crypto/bn/bn.h";
    300. 

  300. $crypto.=" crypto/rsa/rsa.h" ; # unless $no_rsa;
    301. 

  301. $crypto.=" crypto/dsa/dsa.h" ; # unless $no_dsa;
    302. 

  302. $crypto.=" crypto/dh/dh.h" ; # unless $no_dh;
    303. 

  303. $crypto.=" crypto/ec/ec.h" ; # unless $no_ec;
    304. 

  304. $crypto.=" crypto/ecdsa/ecdsa.h" ; # unless $no_ecdsa;
    305. 

  305. $crypto.=" crypto/ecdh/ecdh.h" ; # unless $no_ecdh;
    306. 

  306. $crypto.=" crypto/hmac/hmac.h" ; # unless $no_hmac;
    307. 

  307. $crypto.=" crypto/cmac/cmac.h" ; # unless $no_hmac;
    308. 

  308. 

  309. $crypto.=" crypto/engine/engine.h"; # unless $no_engine;
    310. 

  310. $crypto.=" crypto/stack/stack.h" ; # unless $no_stack;
    311. 

  311. $crypto.=" crypto/buffer/buffer.h" ; # unless $no_buffer;
    312. 

  312. $crypto.=" crypto/bio/bio.h" ; # unless $no_bio;
    313. 

  313. $crypto.=" crypto/dso/dso.h" ; # unless $no_dso;
    314. 

  314. $crypto.=" crypto/lhash/lhash.h" ; # unless $no_lhash;
    315. 

  315. $crypto.=" crypto/conf/conf.h";
    316. 

  316. $crypto.=" crypto/txt_db/txt_db.h";
    317. 

  317. 

  318. $crypto.=" crypto/evp/evp.h" ; # unless $no_evp;
    319. 

  319. $crypto.=" crypto/objects/objects.h";
    320. 

  320. $crypto.=" crypto/pem/pem.h";
    321. 

  321. #$crypto.=" crypto/meth/meth.h";
    322. 

  322. $crypto.=" crypto/asn1/asn1.h";
    323. 

  323. $crypto.=" crypto/asn1/asn1t.h";
    324. 

  324. $crypto.=" crypto/asn1/asn1_mac.h";
    325. 

  325. $crypto.=" crypto/err/err.h" ; # unless $no_err;
    326. 

  326. $crypto.=" crypto/pkcs7/pkcs7.h";
    327. 

  327. $crypto.=" crypto/pkcs12/pkcs12.h";
    328. 

  328. $crypto.=" crypto/x509/x509.h";
    329. 

  329. $crypto.=" crypto/x509/x509_vfy.h";
    330. 

  330. $crypto.=" crypto/x509v3/x509v3.h";
    331. 

  331. $crypto.=" crypto/ts/ts.h";
    332. 

  332. $crypto.=" crypto/rand/rand.h";
    333. 

  333. $crypto.=" crypto/comp/comp.h" ; # unless $no_comp;
    334. 

  334. $crypto.=" crypto/ocsp/ocsp.h";
    335. 

  335. $crypto.=" crypto/ui/ui.h crypto/ui/ui_compat.h";
    336. 

  336. $crypto.=" crypto/krb5/krb5_asn.h";
    337. 

  337. #$crypto.=" crypto/store/store.h";
    338. 

  338. $crypto.=" crypto/pqueue/pqueue.h";
    339. 

  339. $crypto.=" crypto/cms/cms.h";
    340. 

  340. $crypto.=" crypto/jpake/jpake.h";
    341. 

  341. $crypto.=" crypto/modes/modes.h";
    342. 

  342. $crypto.=" crypto/srp/srp.h";
    343. 

  343. 

  344. my $symhacks="crypto/symhacks.h";
    345. 

  345. 

  346. my @ssl_symbols = &do_defs("SSLEAY", $ssl, $symhacks);
    347. 

  347. my @crypto_symbols = &do_defs("LIBEAY", $crypto, $symhacks);
    348. 

  348. 

  349. if ($do_update) {
    350. 

  350. 

  351. if ($do_ssl == 1) {
    352. 

  352. 

  353. 	&maybe_add_info("SSLEAY",*ssl_list,@ssl_symbols);
    354. 

  354. 	if ($do_rewrite == 1) {
    355. 

  355. 		open(OUT, ">$ssl_num");
    356. 

  356. 		&rewrite_numbers(*OUT,"SSLEAY",*ssl_list,@ssl_symbols);
    357. 

  357. 	} else {
    358. 

  358. 		open(OUT, ">>$ssl_num");
    359. 

  359. 	}
    360. 

  360. 	&update_numbers(*OUT,"SSLEAY",*ssl_list,$max_ssl,@ssl_symbols);
    361. 

  361. 	close OUT;
    362. 

  362. }
    363. 

  363. 

  364. if($do_crypto == 1) {
    365. 

  365. 

  366. 	&maybe_add_info("LIBEAY",*crypto_list,@crypto_symbols);
    367. 

  367. 	if ($do_rewrite == 1) {
    368. 

  368. 		open(OUT, ">$crypto_num");
    369. 

  369. 		&rewrite_numbers(*OUT,"LIBEAY",*crypto_list,@crypto_symbols);
    370. 

  370. 	} else {
    371. 

  371. 		open(OUT, ">>$crypto_num");
    372. 

  372. 	}
    373. 

  373. 	&update_numbers(*OUT,"LIBEAY",*crypto_list,$max_crypto,@crypto_symbols);
    374. 

  374. 	close OUT;
    375. 

  375. } 
    376. 

  376. 

  377. } elsif ($do_checkexist) {
    378. 

  378. 	&check_existing(*ssl_list, @ssl_symbols)
    379. 

  379. 		if $do_ssl == 1;
    380. 

  380. 	&check_existing(*crypto_list, @crypto_symbols)
    381. 

  381. 		if $do_crypto == 1;
    382. 

  382. } elsif ($do_ctest || $do_ctestall) {
    383. 

  383. 

  384. 	print <<"EOF";
    385. 

  385. 

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

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

  388.  */
    389. 

  389. 

  390. int main()
    391. 

  391. {
    392. 

  392. EOF
    393. 

  393. 	&print_test_file(*STDOUT,"SSLEAY",*ssl_list,$do_ctestall,@ssl_symbols)
    394. 

  394. 		if $do_ssl == 1;
    395. 

  395. 

  396. 	&print_test_file(*STDOUT,"LIBEAY",*crypto_list,$do_ctestall,@crypto_symbols)
    397. 

  397. 		if $do_crypto == 1;
    398. 

  398. 

  399. 	print "}\n";
    400. 

  400. 

  401. } else {
    402. 

  402. 

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

  404. 		if $do_ssl == 1;
    405. 

  405. 

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

  407. 		if $do_crypto == 1;
    408. 

  408. 

  409. }
    410. 

  410. 

  411. 

  412. sub do_defs
    413. 

  413. {
    414. 

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

  415. 	my $file;
    416. 

  416. 	my @ret;
    417. 

  417. 	my %syms;
    418. 

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

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

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

  421. 	my %variant;
    422. 

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

  423. 				# is the same name as the original.
    424. 

  424. 	my $cpp;
    425. 

  425. 	my %unknown_algorithms = ();
    426. 

  426. 

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

  428. 		{
    429. 

  429. 		print STDERR "DEBUG: starting on $file:\n" if $debug;
    430. 

  430. 		open(IN,"<$file") || die "unable to open $file:$!\n";
    431. 

  431. 		my $line = "", my $def= "";
    432. 

  432. 		my %tag = (
    433. 

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

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

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

  436. 			NOPROTO		=> 0,
    437. 

  437. 			PERL5		=> 0,
    438. 

  438. 			_WINDLL		=> 0,
    439. 

  439. 			CONST_STRICT	=> 0,
    440. 

  440. 			TRUE		=> 1,
    441. 

  441. 		);
    442. 

  442. 		my $symhacking = $file eq $symhacksfile;
    443. 

  443. 		my @current_platforms = ();
    444. 

  444. 		my @current_algorithms = ();
    445. 

  445. 

  446. 		# params: symbol, alias, platforms, kind
    447. 

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

  448. 		# it will otherwise create it's own, unshared, version of
    449. 

  449. 		# %tag and %variant...
    450. 

  450. 		my $make_variant = sub
    451. 

  451. 		{
    452. 

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

  453. 			my ($a1, $a2);
    454. 

  454. 

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

  456. 			if (defined($p))
    457. 

  457. 			{
    458. 

  458. 				$a1 = join(",",$p,
    459. 

  459. 					   grep(!/^$/,
    460. 

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

  461. 						@known_platforms));
    462. 

  462. 			}
    463. 

  463. 			else
    464. 

  464. 			{
    465. 

  465. 				$a1 = join(",",
    466. 

  466. 					   grep(!/^$/,
    467. 

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

  468. 						@known_platforms));
    469. 

  469. 			}
    470. 

  470. 			$a2 = join(",",
    471. 

  471. 				   grep(!/^$/,
    472. 

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

  473. 					@known_ossl_platforms));
    474. 

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

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

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

  477. 			if ($a eq $s)
    478. 

  478. 			{
    479. 

  479. 				if (!defined($variant_cnt{$s}))
    480. 

  480. 				{
    481. 

  481. 					$variant_cnt{$s} = 0;
    482. 

  482. 				}
    483. 

  483. 				$variant_cnt{$s}++;
    484. 

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

  485. 			}
    486. 

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

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

  488. 			if (!grep(/^$togrep$/,
    489. 

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

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

  491. 				$variant{$s} .= $toadd;
    492. 

  492. 			}
    493. 

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

  494. 		};
    495. 

  495. 

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

  497. 		while(<IN>) {
    498. 

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

  499. 				{
    500. 

  500. 				undef @tag;
    501. 

  501. 				last;
    502. 

  502. 				}
    503. 

  503. 			if ($line ne '') {
    504. 

  504. 				$_ = $line . $_;
    505. 

  505. 				$line = '';
    506. 

  506. 			}
    507. 

  507. 

  508. 			if (/\\$/) {
    509. 

  509. 				chomp; # remove eol
    510. 

  510. 				chop; # remove ending backslash
    511. 

  511. 				$line = $_;
    512. 

  512. 				next;
    513. 

  513. 			}
    514. 

  514. 

  515. 			if(/\/\*/) {
    516. 

  516. 				if (not /\*\//) {	# multiline comment...
    517. 

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

  518. 					next;
    519. 

  519. 				} else {
    520. 

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

  521. 				}
    522. 

  522. 			}
    523. 

  523. 

  524. 			if ($cpp) {
    525. 

  525. 				$cpp++ if /^#\s*if/;
    526. 

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

  527. 				next;
    528. 

  528. 	    		}
    529. 

  529. 			$cpp = 1 if /^#.*ifdef.*cplusplus/;
    530. 

  530. 

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

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

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

  534. 			if (/^\#\s*ifndef\s+(.*)/) {
    535. 

  535. 				push(@tag,"-");
    536. 

  536. 				push(@tag,$1);
    537. 

  537. 				$tag{$1}=-1;
    538. 

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

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

  540. 				push(@tag,"-");
    541. 

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

  542. 					my $tmp_1 = $1;
    543. 

  543. 					my $tmp_;
    544. 

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

  545. 						$tmp_ =~ /!defined\(([^\)]+)\)/;
    546. 

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

  547. 						push(@tag,$1);
    548. 

  548. 						$tag{$1}=-1;
    549. 

  549. 					}
    550. 

  550. 				} else {
    551. 

  551. 					print STDERR "Warning: $file: complicated expression: $_" if $debug; # because it is O...
    552. 

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

  553. 					push(@tag,$1);
    554. 

  554. 					$tag{$1}=-1;
    555. 

  555. 				}
    556. 

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

  557. 				push(@tag,"-");
    558. 

  558. 				push(@tag,$1);
    559. 

  559. 				$tag{$1}=1;
    560. 

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

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

  562. 				push(@tag,"-");
    563. 

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

  564. 					my $tmp_1 = $1;
    565. 

  565. 					my $tmp_;
    566. 

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

  567. 						$tmp_ =~ /defined\(([^\)]+)\)/;
    568. 

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

  569. 						push(@tag,$1);
    570. 

  570. 						$tag{$1}=1;
    571. 

  571. 					}
    572. 

  572. 				} else {
    573. 

  573. 					print STDERR "Warning: $file: complicated expression: $_\n" if $debug; # because it is O...
    574. 

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

  575. 					push(@tag,$1);
    576. 

  576. 					$tag{$1}=1;
    577. 

  577. 				}
    578. 

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

  579. 				my $tag_i = $#tag;
    580. 

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

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

  582. 						$tag{$tag[$tag_i]}=2;
    583. 

  583. 						print STDERR "DEBUG: $file: chaged tag $1 = 2\n" if $debug;
    584. 

  584. 					}
    585. 

  585. 					$tag_i--;
    586. 

  586. 				}
    587. 

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

  588. 				my $tag_i = $#tag;
    589. 

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

  590. 					my $t=$tag[$tag_i];
    591. 

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

  592. 					if ($tag{$t}==2) {
    593. 

  593. 						$tag{$t}=-1;
    594. 

  594. 					} else {
    595. 

  595. 						$tag{$t}=0;
    596. 

  596. 					}
    597. 

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

  598. 					pop(@tag);
    599. 

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

  600. 						$t=$1;
    601. 

  601. 					} else {
    602. 

  602. 						$t="";
    603. 

  603. 					}
    604. 

  604. 					if ($t ne ""
    605. 

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

  606. 						$unknown_algorithms{$t} = 1;
    607. 

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

  608. 					}
    609. 

  609. 					$tag_i--;
    610. 

  610. 				}
    611. 

  611. 				pop(@tag);
    612. 

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

  613. 				my $tag_i = $#tag;
    614. 

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

  615. 					my $t=$tag[$tag_i];
    616. 

  616. 					$tag{$t}= -$tag{$t};
    617. 

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

  618. 					$tag_i--;
    619. 

  619. 				}
    620. 

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

  621. 				push(@tag,"-");
    622. 

  622. 				# Dummy tag
    623. 

  623. 				push(@tag,"TRUE");
    624. 

  624. 				$tag{"TRUE"}=1;
    625. 

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

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

  627. 				push(@tag,"-");
    628. 

  628. 				# Dummy tag
    629. 

  629. 				push(@tag,"TRUE");
    630. 

  630. 				$tag{"TRUE"}=-1;
    631. 

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

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

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

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

  635. 				# we have to invert
    636. 

  636. 				&$make_variant($1,$2);
    637. 

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

  638. 			}
    639. 

  639. 			if (/^\#/) {
    640. 

  640. 				@current_platforms =
    641. 

  641. 				    grep(!/^$/,
    642. 

  642. 					 map { $tag{$_} == 1 ? $_ :
    643. 

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

  644. 					 @known_platforms);
    645. 

  645. 				push @current_platforms
    646. 

  646. 				    , grep(!/^$/,
    647. 

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

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

  649. 					   @known_ossl_platforms);
    650. 

  650. 				@current_algorithms =
    651. 

  651. 				    grep(!/^$/,
    652. 

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

  653. 					 @known_algorithms);
    654. 

  654. 				$def .=
    655. 

  655. 				    "#INFO:"
    656. 

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

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

  658. 				next;
    659. 

  659. 			}
    660. 

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

  661. 				if (/^\s*DECLARE_STACK_OF\s*\(\s*(\w*)\s*\)/) {
    662. 

  662. 					next;
    663. 

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

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

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

  666. 					# Variant for platforms that do not
    667. 

  667. 					# have to access globale variables
    668. 

  668. 					# in shared libraries through functions
    669. 

  669. 					$def .=
    670. 

  670. 					    "#INFO:"
    671. 

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

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

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

  674. 					$def .=
    675. 

  675. 					    "#INFO:"
    676. 

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

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

  678. 					# Variant for platforms that have to
    679. 

  679. 					# access globale variables in shared
    680. 

  680. 					# libraries through functions
    681. 

  681. 					&$make_variant("$2_it","$2_it",
    682. 

  682. 						      "EXPORT_VAR_AS_FUNCTION",
    683. 

  683. 						      "FUNCTION");
    684. 

  684. 					next;
    685. 

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

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

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

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

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

  690. 					# Variant for platforms that do not
    691. 

  691. 					# have to access globale variables
    692. 

  692. 					# in shared libraries through functions
    693. 

  693. 					$def .=
    694. 

  694. 					    "#INFO:"
    695. 

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

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

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

  698. 					$def .=
    699. 

  699. 					    "#INFO:"
    700. 

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

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

  702. 					# Variant for platforms that have to
    703. 

  703. 					# access globale variables in shared
    704. 

  704. 					# libraries through functions
    705. 

  705. 					&$make_variant("$2_it","$2_it",
    706. 

  706. 						      "EXPORT_VAR_AS_FUNCTION",
    707. 

  707. 						      "FUNCTION");
    708. 

  708. 					next;
    709. 

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

  710. 					 /^\s*DECLARE_ASN1_FUNCTIONS_const\s*\(\s*(\w*)\s*\)/) {
    711. 

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

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

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

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

  715. 					# Variant for platforms that do not
    716. 

  716. 					# have to access globale variables
    717. 

  717. 					# in shared libraries through functions
    718. 

  718. 					$def .=
    719. 

  719. 					    "#INFO:"
    720. 

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

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

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

  723. 					$def .=
    724. 

  724. 					    "#INFO:"
    725. 

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

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

  727. 					# Variant for platforms that have to
    728. 

  728. 					# access globale variables in shared
    729. 

  729. 					# libraries through functions
    730. 

  730. 					&$make_variant("$1_it","$1_it",
    731. 

  731. 						      "EXPORT_VAR_AS_FUNCTION",
    732. 

  732. 						      "FUNCTION");
    733. 

  733. 					next;
    734. 

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

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

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

  737. 					# Variant for platforms that do not
    738. 

  738. 					# have to access globale variables
    739. 

  739. 					# in shared libraries through functions
    740. 

  740. 					$def .=
    741. 

  741. 					    "#INFO:"
    742. 

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

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

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

  745. 					$def .=
    746. 

  746. 					    "#INFO:"
    747. 

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

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

  749. 					# Variant for platforms that have to
    750. 

  750. 					# access globale variables in shared
    751. 

  751. 					# libraries through functions
    752. 

  752. 					&$make_variant("$2_it","$2_it",
    753. 

  753. 						      "EXPORT_VAR_AS_FUNCTION",
    754. 

  754. 						      "FUNCTION");
    755. 

  755. 					next;
    756. 

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

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

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

  759. 					next;
    760. 

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

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

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

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

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

  765. 					# Variant for platforms that do not
    766. 

  766. 					# have to access globale variables
    767. 

  767. 					# in shared libraries through functions
    768. 

  768. 					$def .=
    769. 

  769. 					    "#INFO:"
    770. 

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

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

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

  773. 					$def .=
    774. 

  774. 					    "#INFO:"
    775. 

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

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

  777. 					# Variant for platforms that have to
    778. 

  778. 					# access globale variables in shared
    779. 

  779. 					# libraries through functions
    780. 

  780. 					&$make_variant("$2_it","$2_it",
    781. 

  781. 						      "EXPORT_VAR_AS_FUNCTION",
    782. 

  782. 						      "FUNCTION");
    783. 

  783. 					next;
    784. 

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

  785. 					# Variant for platforms that do not
    786. 

  786. 					# have to access globale variables
    787. 

  787. 					# in shared libraries through functions
    788. 

  788. 					$def .=
    789. 

  789. 					    "#INFO:"
    790. 

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

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

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

  793. 					$def .=
    794. 

  794. 					    "#INFO:"
    795. 

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

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

  797. 					# Variant for platforms that have to
    798. 

  798. 					# access globale variables in shared
    799. 

  799. 					# libraries through functions
    800. 

  800. 					&$make_variant("$1_it","$1_it",
    801. 

  801. 						      "EXPORT_VAR_AS_FUNCTION",
    802. 

  802. 						      "FUNCTION");
    803. 

  803. 					next;
    804. 

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

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

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

  807. 					next;
    808. 

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

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

  810. 					next;
    811. 

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

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

  813. 					next;
    814. 

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

  815. 					next;
    816. 

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

  817. 					 /^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ ||
    818. 

  818. 					 /^DECLARE_PEM_rw_const\s*\(\s*(\w*)\s*,/ ) {
    819. 

  819. 					# Things not in Win16
    820. 

  820. 					$def .=
    821. 

  821. 					    "#INFO:"
    822. 

  822. 						.join(',',"!WIN16",@current_platforms).":"
    823. 

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

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

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

  826. 					$def .=
    827. 

  827. 					    "#INFO:"
    828. 

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

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

  830. 					# Things that are everywhere
    831. 

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

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

  833. 					next;
    834. 

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

  835. 					 /^DECLARE_PEM_write_cb\s*\(\s*(\w*)\s*,/ ) {
    836. 

  836. 					# Things not in Win16
    837. 

  837. 					$def .=
    838. 

  838. 					    "#INFO:"
    839. 

  839. 						.join(',',"!WIN16",@current_platforms).":"
    840. 

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

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

  842. 					$def .=
    843. 

  843. 					    "#INFO:"
    844. 

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

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

  846. 					# Things that are everywhere
    847. 

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

  848. 					next;
    849. 

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

  850. 					 /^DECLARE_PEM_read_cb\s*\(\s*(\w*)\s*,/ ) {
    851. 

  851. 					# Things not in Win16
    852. 

  852. 					$def .=
    853. 

  853. 					    "#INFO:"
    854. 

  854. 						.join(',',"!WIN16",@current_platforms).":"
    855. 

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

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

  857. 					$def .=
    858. 

  858. 					    "#INFO:"
    859. 

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

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

  861. 					# Things that are everywhere
    862. 

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

  863. 					next;
    864. 

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

  865. 					# Variant for platforms that do not
    866. 

  866. 					# have to access globale variables
    867. 

  867. 					# in shared libraries through functions
    868. 

  868. 					$def .=
    869. 

  869. 					    "#INFO:"
    870. 

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

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

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

  873. 					$def .=
    874. 

  874. 					    "#INFO:"
    875. 

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

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

  877. 					# Variant for platforms that have to
    878. 

  878. 					# access globale variables in shared
    879. 

  879. 					# libraries through functions
    880. 

  880. 					&$make_variant("_shadow_$2","_shadow_$2",
    881. 

  881. 						      "EXPORT_VAR_AS_FUNCTION",
    882. 

  882. 						      "FUNCTION");
    883. 

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

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

  885. 						$line = $_;
    886. 

  886. 					} else {
    887. 

  887. 						$def .= $_;
    888. 

  888. 					}
    889. 

  889. 				}
    890. 

  890. 			}
    891. 

  891. 		}
    892. 

  892. 		close(IN);
    893. 

  893. 

  894. 		my $algs;
    895. 

  895. 		my $plays;
    896. 

  896. 

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

  898. 		foreach (split /;/, $def) {
    899. 

  899. 			my $s; my $k = "FUNCTION"; my $p; my $a;
    900. 

  900. 			s/^[\n\s]*//g;
    901. 

  901. 			s/[\n\s]*$//g;
    902. 

  902. 			next if(/\#undef/);
    903. 

  903. 			next if(/typedef\W/);
    904. 

  904. 			next if(/\#define/);
    905. 

  905. 

  906. 			# Reduce argument lists to empty ()
    907. 

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

  908. 			while(/\(.*\)/s) {
    909. 

  909. 				s/\([^\(\)]+\)/\{\}/gs;
    910. 

  910. 				s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs;	#(*f{}) -> f
    911. 

  911. 			}
    912. 

  912. 			# pretend as we didn't use curly braces: {} -> ()
    913. 

  913. 			s/\{\}/\(\)/gs;
    914. 

  914. 

  915. 			s/STACK_OF\(\)/void/gs;
    916. 

  916. 			s/LHASH_OF\(\)/void/gs;
    917. 

  917. 

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

  919. 			if (/^\#INFO:([^:]*):(.*)$/) {
    920. 

  920. 				$plats = $1;
    921. 

  921. 				$algs = $2;
    922. 

  922. 				print STDERR "DEBUG: found info on platforms ($plats) and algorithms ($algs)\n" if $debug;
    923. 

  923. 				next;
    924. 

  924. 			} elsif (/^\s*OPENSSL_EXTERN\s.*?(\w+(\{[0-9]+\})?)(\[[0-9]*\])*\s*$/) {
    925. 

  925. 				$s = $1;
    926. 

  926. 				$k = "VARIABLE";
    927. 

  927. 				print STDERR "DEBUG: found external variable $s\n" if $debug;
    928. 

  928. 			} elsif (/TYPEDEF_\w+_OF/s) {
    929. 

  929. 				next;
    930. 

  930. 			} elsif (/(\w+)\s*\(\).*/s) {	# first token prior [first] () is
    931. 

  931. 				$s = $1;		# a function name!
    932. 

  932. 				print STDERR "DEBUG: found function $s\n" if $debug;
    933. 

  933. 			} elsif (/\(/ and not (/=/)) {
    934. 

  934. 				print STDERR "File $file: cannot parse: $_;\n";
    935. 

  935. 				next;
    936. 

  936. 			} else {
    937. 

  937. 				next;
    938. 

  938. 			}
    939. 

  939. 

  940. 			$syms{$s} = 1;
    941. 

  941. 			$kind{$s} = $k;
    942. 

  942. 

  943. 			$p = $plats;
    944. 

  944. 			$a = $algs;
    945. 

  945. 			$a .= ",BF" if($s =~ /EVP_bf/);
    946. 

  946. 			$a .= ",CAST" if($s =~ /EVP_cast/);
    947. 

  947. 			$a .= ",DES" if($s =~ /EVP_des/);
    948. 

  948. 			$a .= ",DSA" if($s =~ /EVP_dss/);
    949. 

  949. 			$a .= ",IDEA" if($s =~ /EVP_idea/);
    950. 

  950. 			$a .= ",MD2" if($s =~ /EVP_md2/);
    951. 

  951. 			$a .= ",MD4" if($s =~ /EVP_md4/);
    952. 

  952. 			$a .= ",MD5" if($s =~ /EVP_md5/);
    953. 

  953. 			$a .= ",RC2" if($s =~ /EVP_rc2/);
    954. 

  954. 			$a .= ",RC4" if($s =~ /EVP_rc4/);
    955. 

  955. 			$a .= ",RC5" if($s =~ /EVP_rc5/);
    956. 

  956. 			$a .= ",RIPEMD" if($s =~ /EVP_ripemd/);
    957. 

  957. 			$a .= ",SHA" if($s =~ /EVP_sha/);
    958. 

  958. 			$a .= ",RSA" if($s =~ /EVP_(Open|Seal)(Final|Init)/);
    959. 

  959. 			$a .= ",RSA" if($s =~ /PEM_Seal(Final|Init|Update)/);
    960. 

  960. 			$a .= ",RSA" if($s =~ /RSAPrivateKey/);
    961. 

  961. 			$a .= ",RSA" if($s =~ /SSLv23?_((client|server)_)?method/);
    962. 

  962. 

  963. 			$platform{$s} =
    964. 

  964. 			    &reduce_platforms((defined($platform{$s})?$platform{$s}.',':"").$p);
    965. 

  965. 			$algorithm{$s} .= ','.$a;
    966. 

  966. 

  967. 			if (defined($variant{$s})) {
    968. 

  968. 				foreach $v (split /;/,$variant{$s}) {
    969. 

  969. 					(my $r, my $p, my $k) = split(/:/,$v);
    970. 

  970. 					my $ip = join ',',map({ /^!(.*)$/ ? $1 : "!".$_ } split /,/, $p);
    971. 

  971. 					$syms{$r} = 1;
    972. 

  972. 					if (!defined($k)) { $k = $kind{$s}; }
    973. 

  973. 					$kind{$r} = $k."(".$s.")";
    974. 

  974. 					$algorithm{$r} = $algorithm{$s};
    975. 

  975. 					$platform{$r} = &reduce_platforms($platform{$s}.",".$p.",".$p);
    976. 

  976. 					$platform{$s} = &reduce_platforms($platform{$s}.','.$ip.','.$ip);
    977. 

  977. 					print STDERR "DEBUG: \$variant{\"$s\"} = ",$v,"; \$r = $r; \$p = ",$platform{$r},"; \$a = ",$algorithm{$r},"; \$kind = ",$kind{$r},"\n" if $debug;
    978. 

  978. 				}
    979. 

  979. 			}
    980. 

  980. 			print STDERR "DEBUG: \$s = $s; \$p = ",$platform{$s},"; \$a = ",$algorithm{$s},"; \$kind = ",$kind{$s},"\n" if $debug;
    981. 

  981. 		}
    982. 

  982. 	}
    983. 

  983. 

  984. 	# Prune the returned symbols
    985. 

  985. 

  986.         delete $syms{"bn_dump1"};
    987. 

  987. 	$platform{"BIO_s_log"} .= ",!WIN32,!WIN16,!macintosh";
    988. 

  988. 

  989. 	$platform{"PEM_read_NS_CERT_SEQ"} = "VMS";
    990. 

  990. 	$platform{"PEM_write_NS_CERT_SEQ"} = "VMS";
    991. 

  991. 	$platform{"PEM_read_P8_PRIV_KEY_INFO"} = "VMS";
    992. 

  992. 	$platform{"PEM_write_P8_PRIV_KEY_INFO"} = "VMS";
    993. 

  993. 	$platform{"EVP_sha384"} = "!VMSVAX";
    994. 

  994. 	$platform{"EVP_sha512"} = "!VMSVAX";
    995. 

  995. 	$platform{"SHA384_Init"} = "!VMSVAX";
    996. 

  996. 	$platform{"SHA384_Transform"} = "!VMSVAX";
    997. 

  997. 	$platform{"SHA384_Update"} = "!VMSVAX";
    998. 

  998. 	$platform{"SHA384_Final"} = "!VMSVAX";
    999. 

  999. 	$platform{"SHA384"} = "!VMSVAX";
    1000. 

  1000. 	$platform{"SHA512_Init"} = "!VMSVAX";
    1001. 

  1001. 	$platform{"SHA512_Transform"} = "!VMSVAX";
    1002. 

  1002. 	$platform{"SHA512_Update"} = "!VMSVAX";
    1003. 

  1003. 	$platform{"SHA512_Final"} = "!VMSVAX";
    1004. 

  1004. 	$platform{"SHA512"} = "!VMSVAX";
    1005. 

  1005. 	$platform{"WHIRLPOOL_Init"} = "!VMSVAX";
    1006. 

  1006. 	$platform{"WHIRLPOOL"} = "!VMSVAX";
    1007. 

  1007. 	$platform{"WHIRLPOOL_BitUpdate"} = "!VMSVAX";
    1008. 

  1008. 	$platform{"EVP_whirlpool"} = "!VMSVAX";
    1009. 

  1009. 	$platform{"WHIRLPOOL_Final"} = "!VMSVAX";
    1010. 

  1010. 	$platform{"WHIRLPOOL_Update"} = "!VMSVAX";
    1011. 

  1011. 

  1012. 

  1013. 	# Info we know about
    1014. 

  1014. 

  1015. 	push @ret, map { $_."\\".&info_string($_,"EXIST",
    1016. 

  1016. 					      $platform{$_},
    1017. 

  1017. 					      $kind{$_},
    1018. 

  1018. 					      $algorithm{$_}) } keys %syms;
    1019. 

  1019. 

  1020. 	if (keys %unknown_algorithms) {
    1021. 

  1021. 		print STDERR "WARNING: mkdef.pl doesn't know the following algorithms:\n";
    1022. 

  1022. 		print STDERR "\t",join("\n\t",keys %unknown_algorithms),"\n";
    1023. 

  1023. 	}
    1024. 

  1024. 	return(@ret);
    1025. 

  1025. }
    1026. 

  1026. 

  1027. # Param: string of comma-separated platform-specs.
    1028. 

  1028. sub reduce_platforms
    1029. 

  1029. {
    1030. 

  1030. 	my ($platforms) = @_;
    1031. 

  1031. 	my $pl = defined($platforms) ? $platforms : "";
    1032. 

  1032. 	my %p = map { $_ => 0 } split /,/, $pl;
    1033. 

  1033. 	my $ret;
    1034. 

  1034. 

  1035. 	print STDERR "DEBUG: Entered reduce_platforms with \"$platforms\"\n"
    1036. 

  1036. 	    if $debug;
    1037. 

  1037. 	# We do this, because if there's code like the following, it really
    1038. 

  1038. 	# means the function exists in all cases and should therefore be
    1039. 

  1039. 	# everywhere.  By increasing and decreasing, we may attain 0:
    1040. 

  1040. 	#
    1041. 

  1041. 	# ifndef WIN16
    1042. 

  1042. 	#    int foo();
    1043. 

  1043. 	# else
    1044. 

  1044. 	#    int _fat foo();
    1045. 

  1045. 	# endif
    1046. 

  1046. 	foreach $platform (split /,/, $pl) {
    1047. 

  1047. 		if ($platform =~ /^!(.*)$/) {
    1048. 

  1048. 			$p{$1}--;
    1049. 

  1049. 		} else {
    1050. 

  1050. 			$p{$platform}++;
    1051. 

  1051. 		}
    1052. 

  1052. 	}
    1053. 

  1053. 	foreach $platform (keys %p) {
    1054. 

  1054. 		if ($p{$platform} == 0) { delete $p{$platform}; }
    1055. 

  1055. 	}
    1056. 

  1056. 

  1057. 	delete $p{""};
    1058. 

  1058. 

  1059. 	$ret = join(',',sort(map { $p{$_} < 0 ? "!".$_ : $_ } keys %p));
    1060. 

  1060. 	print STDERR "DEBUG: Exiting reduce_platforms with \"$ret\"\n"
    1061. 

  1061. 	    if $debug;
    1062. 

  1062. 	return $ret;
    1063. 

  1063. }
    1064. 

  1064. 

  1065. sub info_string {
    1066. 

  1066. 	(my $symbol, my $exist, my $platforms, my $kind, my $algorithms) = @_;
    1067. 

  1067. 

  1068. 	my %a = defined($algorithms) ?
    1069. 

  1069. 	    map { $_ => 1 } split /,/, $algorithms : ();
    1070. 

  1070. 	my $k = defined($kind) ? $kind : "FUNCTION";
    1071. 

  1071. 	my $ret;
    1072. 

  1072. 	my $p = &reduce_platforms($platforms);
    1073. 

  1073. 

  1074. 	delete $a{""};
    1075. 

  1075. 

  1076. 	$ret = $exist;
    1077. 

  1077. 	$ret .= ":".$p;
    1078. 

  1078. 	$ret .= ":".$k;
    1079. 

  1079. 	$ret .= ":".join(',',sort keys %a);
    1080. 

  1080. 	return $ret;
    1081. 

  1081. }
    1082. 

  1082. 

  1083. sub maybe_add_info {
    1084. 

  1084. 	(my $name, *nums, my @symbols) = @_;
    1085. 

  1085. 	my $sym;
    1086. 

  1086. 	my $new_info = 0;
    1087. 

  1087. 	my %syms=();
    1088. 

  1088. 

  1089. 	print STDERR "Updating $name info\n";
    1090. 

  1090. 	foreach $sym (@symbols) {
    1091. 

  1091. 		(my $s, my $i) = split /\\/, $sym;
    1092. 

  1092. 		if (defined($nums{$s})) {
    1093. 

  1093. 			$i =~ s/^(.*?:.*?:\w+)(\(\w+\))?/$1/;
    1094. 

  1094. 			(my $n, my $dummy) = split /\\/, $nums{$s};
    1095. 

  1095. 			if (!defined($dummy) || $i ne $dummy) {
    1096. 

  1096. 				$nums{$s} = $n."\\".$i;
    1097. 

  1097. 				$new_info++;
    1098. 

  1098. 				print STDERR "DEBUG: maybe_add_info for $s: \"$dummy\" => \"$i\"\n" if $debug;
    1099. 

  1099. 			}
    1100. 

  1100. 		}
    1101. 

  1101. 		$syms{$s} = 1;
    1102. 

  1102. 	}
    1103. 

  1103. 

  1104. 	my @s=sort { &parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n") } keys %nums;
    1105. 

  1105. 	foreach $sym (@s) {
    1106. 

  1106. 		(my $n, my $i) = split /\\/, $nums{$sym};
    1107. 

  1107. 		if (!defined($syms{$sym}) && $i !~ /^NOEXIST:/) {
    1108. 

  1108. 			$new_info++;
    1109. 

  1109. 			print STDERR "DEBUG: maybe_add_info for $sym: -> undefined\n" if $debug;
    1110. 

  1110. 		}
    1111. 

  1111. 	}
    1112. 

  1112. 	if ($new_info) {
    1113. 

  1113. 		print STDERR "$new_info old symbols got an info update\n";
    1114. 

  1114. 		if (!$do_rewrite) {
    1115. 

  1115. 			print STDERR "You should do a rewrite to fix this.\n";
    1116. 

  1116. 		}
    1117. 

  1117. 	} else {
    1118. 

  1118. 		print STDERR "No old symbols needed info update\n";
    1119. 

  1119. 	}
    1120. 

  1120. }
    1121. 

  1121. 

  1122. # Param: string of comma-separated keywords, each possibly prefixed with a "!"
    1123. 

  1123. sub is_valid
    1124. 

  1124. {
    1125. 

  1125. 	my ($keywords_txt,$platforms) = @_;
    1126. 

  1126. 	my (@keywords) = split /,/,$keywords_txt;
    1127. 

  1127. 	my ($falsesum, $truesum) = (0, 1);
    1128. 

  1128. 

  1129. 	# Param: one keyword
    1130. 

  1130. 	sub recognise
    1131. 

  1131. 	{
    1132. 

  1132. 		my ($keyword,$platforms) = @_;
    1133. 

  1133. 

  1134. 		if ($platforms) {
    1135. 

  1135. 			# platforms
    1136. 

  1136. 			if ($keyword eq "VMSVAX" && $VMSVAX) { return 1; }
    1137. 

  1137. 			if ($keyword eq "VMSNonVAX" && $VMSNonVAX) { return 1; }
    1138. 

  1138. 			if ($keyword eq "VMS" && $VMS) { return 1; }
    1139. 

  1139. 			if ($keyword eq "WIN32" && $W32) { return 1; }
    1140. 

  1140. 			if ($keyword eq "WIN16" && $W16) { return 1; }
    1141. 

  1141. 			if ($keyword eq "WINNT" && $NT) { return 1; }
    1142. 

  1142. 			if ($keyword eq "OS2" && $OS2) { return 1; }
    1143. 

  1143. 			# Special platforms:
    1144. 

  1144. 			# EXPORT_VAR_AS_FUNCTION means that global variables
    1145. 

  1145. 			# will be represented as functions.  This currently
    1146. 

  1146. 			# only happens on VMS-VAX.
    1147. 

  1147. 			if ($keyword eq "EXPORT_VAR_AS_FUNCTION" && ($VMSVAX || $W32 || $W16)) {
    1148. 

  1148. 				return 1;
    1149. 

  1149. 			}
    1150. 

  1150. 			if ($keyword eq "OPENSSL_FIPS" && $fips) {
    1151. 

  1151. 				return 1;
    1152. 

  1152. 			}
    1153. 

  1153. 			if ($keyword eq "ZLIB" && $zlib) { return 1; }
    1154. 

  1154. 			return 0;
    1155. 

  1155. 		} else {
    1156. 

  1156. 			# algorithms
    1157. 

  1157. 			if ($keyword eq "RC2" && $no_rc2) { return 0; }
    1158. 

  1158. 			if ($keyword eq "RC4" && $no_rc4) { return 0; }
    1159. 

  1159. 			if ($keyword eq "RC5" && $no_rc5) { return 0; }
    1160. 

  1160. 			if ($keyword eq "IDEA" && $no_idea) { return 0; }
    1161. 

  1161. 			if ($keyword eq "DES" && $no_des) { return 0; }
    1162. 

  1162. 			if ($keyword eq "BF" && $no_bf) { return 0; }
    1163. 

  1163. 			if ($keyword eq "CAST" && $no_cast) { return 0; }
    1164. 

  1164. 			if ($keyword eq "MD2" && $no_md2) { return 0; }
    1165. 

  1165. 			if ($keyword eq "MD4" && $no_md4) { return 0; }
    1166. 

  1166. 			if ($keyword eq "MD5" && $no_md5) { return 0; }
    1167. 

  1167. 			if ($keyword eq "SHA" && $no_sha) { return 0; }
    1168. 

  1168. 			if ($keyword eq "RIPEMD" && $no_ripemd) { return 0; }
    1169. 

  1169. 			if ($keyword eq "MDC2" && $no_mdc2) { return 0; }
    1170. 

  1170. 			if ($keyword eq "WHIRLPOOL" && $no_whirlpool) { return 0; }
    1171. 

  1171. 			if ($keyword eq "RSA" && $no_rsa) { return 0; }
    1172. 

  1172. 			if ($keyword eq "DSA" && $no_dsa) { return 0; }
    1173. 

  1173. 			if ($keyword eq "DH" && $no_dh) { return 0; }
    1174. 

  1174. 			if ($keyword eq "EC" && $no_ec) { return 0; }
    1175. 

  1175. 			if ($keyword eq "ECDSA" && $no_ecdsa) { return 0; }
    1176. 

  1176. 			if ($keyword eq "ECDH" && $no_ecdh) { return 0; }
    1177. 

  1177. 			if ($keyword eq "HMAC" && $no_hmac) { return 0; }
    1178. 

  1178. 			if ($keyword eq "AES" && $no_aes) { return 0; }
    1179. 

  1179. 			if ($keyword eq "CAMELLIA" && $no_camellia) { return 0; }
    1180. 

  1180. 			if ($keyword eq "SEED" && $no_seed) { return 0; }
    1181. 

  1181. 			if ($keyword eq "EVP" && $no_evp) { return 0; }
    1182. 

  1182. 			if ($keyword eq "LHASH" && $no_lhash) { return 0; }
    1183. 

  1183. 			if ($keyword eq "STACK" && $no_stack) { return 0; }
    1184. 

  1184. 			if ($keyword eq "ERR" && $no_err) { return 0; }
    1185. 

  1185. 			if ($keyword eq "BUFFER" && $no_buffer) { return 0; }
    1186. 

  1186. 			if ($keyword eq "BIO" && $no_bio) { return 0; }
    1187. 

  1187. 			if ($keyword eq "COMP" && $no_comp) { return 0; }
    1188. 

  1188. 			if ($keyword eq "DSO" && $no_dso) { return 0; }
    1189. 

  1189. 			if ($keyword eq "KRB5" && $no_krb5) { return 0; }
    1190. 

  1190. 			if ($keyword eq "ENGINE" && $no_engine) { return 0; }
    1191. 

  1191. 			if ($keyword eq "HW" && $no_hw) { return 0; }
    1192. 

  1192. 			if ($keyword eq "FP_API" && $no_fp_api) { return 0; }
    1193. 

  1193. 			if ($keyword eq "STATIC_ENGINE" && $no_static_engine) { return 0; }
    1194. 

  1194. 			if ($keyword eq "GMP" && $no_gmp) { return 0; }
    1195. 

  1195. 			if ($keyword eq "RFC3779" && $no_rfc3779) { return 0; }
    1196. 

  1196. 			if ($keyword eq "TLSEXT" && $no_tlsext) { return 0; }
    1197. 

  1197. 			if ($keyword eq "PSK" && $no_psk) { return 0; }
    1198. 

  1198. 			if ($keyword eq "CMS" && $no_cms) { return 0; }
    1199. 

  1199. 			if ($keyword eq "EC2M" && $no_ec2m) { return 0; }
    1200. 

  1200. 			if ($keyword eq "NEXTPROTONEG" && $no_nextprotoneg) { return 0; }
    1201. 

  1201. 			if ($keyword eq "EC_NISTP_64_GCC_128" && $no_nistp_gcc)
    1202. 

  1202. 					{ return 0; }
    1203. 

  1203. 			if ($keyword eq "SSL2" && $no_ssl2) { return 0; }
    1204. 

  1204. 			if ($keyword eq "CAPIENG" && $no_capieng) { return 0; }
    1205. 

  1205. 			if ($keyword eq "JPAKE" && $no_jpake) { return 0; }
    1206. 

  1206. 			if ($keyword eq "SRP" && $no_srp) { return 0; }
    1207. 

  1207. 			if ($keyword eq "SCTP" && $no_sctp) { return 0; }
    1208. 

  1208. 			if ($keyword eq "DEPRECATED" && $no_deprecated) { return 0; }
    1209. 

  1209. 

  1210. 			# Nothing recognise as true
    1211. 

  1211. 			return 1;
    1212. 

  1212. 		}
    1213. 

  1213. 	}
    1214. 

  1214. 

  1215. 	foreach $k (@keywords) {
    1216. 

  1216. 		if ($k =~ /^!(.*)$/) {
    1217. 

  1217. 			$falsesum += &recognise($1,$platforms);
    1218. 

  1218. 		} else {
    1219. 

  1219. 			$truesum *= &recognise($k,$platforms);
    1220. 

  1220. 		}
    1221. 

  1221. 	}
    1222. 

  1222. 	print STDERR "DEBUG: [",$#keywords,",",$#keywords < 0,"] is_valid($keywords_txt) => (\!$falsesum) && $truesum = ",(!$falsesum) && $truesum,"\n" if $debug;
    1223. 

  1223. 	return (!$falsesum) && $truesum;
    1224. 

  1224. }
    1225. 

  1225. 

  1226. sub print_test_file
    1227. 

  1227. {
    1228. 

  1228. 	(*OUT,my $name,*nums,my $testall,my @symbols)=@_;
    1229. 

  1229. 	my $n = 1; my @e; my @r;
    1230. 

  1230. 	my $sym; my $prev = ""; my $prefSSLeay;
    1231. 

  1231. 

  1232. 	(@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
    1233. 

  1233. 	(@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:.*/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
    1234. 

  1234. 	@symbols=((sort @e),(sort @r));
    1235. 

  1235. 

  1236. 	foreach $sym (@symbols) {
    1237. 

  1237. 		(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
    1238. 

  1238. 		my $v = 0;
    1239. 

  1239. 		$v = 1 if $i=~ /^.*?:.*?:VARIABLE/;
    1240. 

  1240. 		my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
    1241. 

  1241. 		my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
    1242. 

  1242. 		if (!defined($nums{$s})) {
    1243. 

  1243. 			print STDERR "Warning: $s does not have a number assigned\n"
    1244. 

  1244. 			    if(!$do_update);
    1245. 

  1245. 		} elsif (is_valid($p,1) && is_valid($a,0)) {
    1246. 

  1246. 			my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
    1247. 

  1247. 			if ($prev eq $s2) {
    1248. 

  1248. 				print OUT "\t/* The following has already appeared previously */\n";
    1249. 

  1249. 				print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
    1250. 

  1250. 			}
    1251. 

  1251. 			$prev = $s2;	# To warn about duplicates...
    1252. 

  1252. 

  1253. 			($nn,$ni)=($nums{$s2} =~ /^(.*?)\\(.*)$/);
    1254. 

  1254. 			if ($v) {
    1255. 

  1255. 				print OUT "\textern int $s2; /* type unknown */ /* $nn $ni */\n";
    1256. 

  1256. 			} else {
    1257. 

  1257. 				print OUT "\textern int $s2(); /* type unknown */ /* $nn $ni */\n";
    1258. 

  1258. 			}
    1259. 

  1259. 		}
    1260. 

  1260. 	}
    1261. 

  1261. }
    1262. 

  1262. 

  1263. sub get_version {
    1264. 

  1264.    local *MF;
    1265. 

  1265.    my $v = '?';
    1266. 

  1266.    open MF, 'Makefile' or return $v;
    1267. 

  1267.    while (<MF>) {
    1268. 

  1268.      $v = $1, last if /^VERSION=(.*?)\s*$/;
    1269. 

  1269.    }
    1270. 

  1270.    close MF;
    1271. 

  1271.    return $v;
    1272. 

  1272. }
    1273. 

  1273. 

  1274. sub print_def_file
    1275. 

  1275. {
    1276. 

  1276. 	(*OUT,my $name,*nums,my @symbols)=@_;
    1277. 

  1277. 	my $n = 1; my @e; my @r; my @v; my $prev="";
    1278. 

  1278. 	my $liboptions="";
    1279. 

  1279. 	my $libname = $name;
    1280. 

  1280. 	my $http_vendor = 'www.openssl.org/';
    1281. 

  1281. 	my $version = get_version();
    1282. 

  1282. 	my $what = "OpenSSL: implementation of Secure Socket Layer";
    1283. 

  1283. 	my $description = "$what $version, $name - http://$http_vendor";
    1284. 

  1284. 

  1285. 	if ($W32)
    1286. 

  1286. 		{ $libname.="32"; }
    1287. 

  1287. 	elsif ($W16)
    1288. 

  1288. 		{ $libname.="16"; }
    1289. 

  1289. 	elsif ($OS2)
    1290. 

  1290. 		{ # DLL names should not clash on the whole system.
    1291. 

  1291. 		  # However, they should not have any particular relationship
    1292. 

  1292. 		  # to the name of the static library.  Chose descriptive names
    1293. 

  1293. 		  # (must be at most 8 chars).
    1294. 

  1294. 		  my %translate = (ssl => 'open_ssl', crypto => 'cryptssl');
    1295. 

  1295. 		  $libname = $translate{$name} || $name;
    1296. 

  1296. 		  $liboptions = <<EOO;
    1297. 

  1297. INITINSTANCE
    1298. 

  1298. DATA MULTIPLE NONSHARED
    1299. 

  1299. EOO
    1300. 

  1300. 		  # Vendor field can't contain colon, drat; so we omit http://
    1301. 

  1301. 		  $description = "\@#$http_vendor:$version#\@$what; DLL for library $name.  Build for EMX -Zmtd";
    1302. 

  1302. 		}
    1303. 

  1303. 

  1304. 	print OUT <<"EOF";
    1305. 

  1305. ;
    1306. 

  1306. ; Definition file for the DLL version of the $name library from OpenSSL
    1307. 

  1307. ;
    1308. 

  1308. 

  1309. LIBRARY         $libname	$liboptions
    1310. 

  1310. 

  1311. EOF
    1312. 

  1312. 

  1313. 	if ($W16) {
    1314. 

  1314. 		print <<"EOF";
    1315. 

  1315. CODE            PRELOAD MOVEABLE
    1316. 

  1316. DATA            PRELOAD MOVEABLE SINGLE
    1317. 

  1317. 

  1318. EXETYPE		WINDOWS
    1319. 

  1319. 

  1320. HEAPSIZE	4096
    1321. 

  1321. STACKSIZE	8192
    1322. 

  1322. 

  1323. EOF
    1324. 

  1324. 	}
    1325. 

  1325. 

  1326. 	print "EXPORTS\n";
    1327. 

  1327. 

  1328. 	(@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
    1329. 

  1329. 	(@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:FUNCTION/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
    1330. 

  1330. 	(@v)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:VARIABLE/,@symbols);
    1331. 

  1331. 	@symbols=((sort @e),(sort @r), (sort @v));
    1332. 

  1332. 

  1333. 

  1334. 	foreach $sym (@symbols) {
    1335. 

  1335. 		(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
    1336. 

  1336. 		my $v = 0;
    1337. 

  1337. 		$v = 1 if $i =~ /^.*?:.*?:VARIABLE/;
    1338. 

  1338. 		if (!defined($nums{$s})) {
    1339. 

  1339. 			printf STDERR "Warning: $s does not have a number assigned\n"
    1340. 

  1340. 			    if(!$do_update);
    1341. 

  1341. 		} else {
    1342. 

  1342. 			(my $n, my $dummy) = split /\\/, $nums{$s};
    1343. 

  1343. 			my %pf = ();
    1344. 

  1344. 			my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
    1345. 

  1345. 			my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
    1346. 

  1346. 			if (is_valid($p,1) && is_valid($a,0)) {
    1347. 

  1347. 				my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
    1348. 

  1348. 				if ($prev eq $s2) {
    1349. 

  1349. 					print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
    1350. 

  1350. 				}
    1351. 

  1351. 				$prev = $s2;	# To warn about duplicates...
    1352. 

  1352. 				if($v && !$OS2) {
    1353. 

  1353. 					printf OUT "    %s%-39s @%-8d DATA\n",($W32)?"":"_",$s2,$n;
    1354. 

  1354. 				} else {
    1355. 

  1355. 					printf OUT "    %s%-39s @%d\n",($W32||$OS2)?"":"_",$s2,$n;
    1356. 

  1356. 				}
    1357. 

  1357. 			}
    1358. 

  1358. 		}
    1359. 

  1359. 	}
    1360. 

  1360. 	printf OUT "\n";
    1361. 

  1361. }
    1362. 

  1362. 

  1363. sub load_numbers
    1364. 

  1364. {
    1365. 

  1365. 	my($name)=@_;
    1366. 

  1366. 	my(@a,%ret);
    1367. 

  1367. 

  1368. 	$max_num = 0;
    1369. 

  1369. 	$num_noinfo = 0;
    1370. 

  1370. 	$prev = "";
    1371. 

  1371. 	$prev_cnt = 0;
    1372. 

  1372. 

  1373. 	open(IN,"<$name") || die "unable to open $name:$!\n";
    1374. 

  1374. 	while (<IN>) {
    1375. 

  1375. 		chop;
    1376. 

  1376. 		s/#.*$//;
    1377. 

  1377. 		next if /^\s*$/;
    1378. 

  1378. 		@a=split;
    1379. 

  1379. 		if (defined $ret{$a[0]}) {
    1380. 

  1380. 			# This is actually perfectly OK
    1381. 

  1381. 			#print STDERR "Warning: Symbol '",$a[0],"' redefined. old=",$ret{$a[0]},", new=",$a[1],"\n";
    1382. 

  1382. 		}
    1383. 

  1383. 		if ($max_num > $a[1]) {
    1384. 

  1384. 			print STDERR "Warning: Number decreased from ",$max_num," to ",$a[1],"\n";
    1385. 

  1385. 		}
    1386. 

  1386. 		elsif ($max_num == $a[1]) {
    1387. 

  1387. 			# This is actually perfectly OK
    1388. 

  1388. 			#print STDERR "Warning: Symbol ",$a[0]," has same number as previous ",$prev,": ",$a[1],"\n";
    1389. 

  1389. 			if ($a[0] eq $prev) {
    1390. 

  1390. 				$prev_cnt++;
    1391. 

  1391. 				$a[0] .= "{$prev_cnt}";
    1392. 

  1392. 			}
    1393. 

  1393. 		}
    1394. 

  1394. 		else {
    1395. 

  1395. 			$prev_cnt = 0;
    1396. 

  1396. 		}
    1397. 

  1397. 		if ($#a < 2) {
    1398. 

  1398. 			# Existence will be proven later, in do_defs
    1399. 

  1399. 			$ret{$a[0]}=$a[1];
    1400. 

  1400. 			$num_noinfo++;
    1401. 

  1401. 		} else {
    1402. 

  1402. 			$ret{$a[0]}=$a[1]."\\".$a[2]; # \\ is a special marker
    1403. 

  1403. 		}
    1404. 

  1404. 		$max_num = $a[1] if $a[1] > $max_num;
    1405. 

  1405. 		$prev=$a[0];
    1406. 

  1406. 	}
    1407. 

  1407. 	if ($num_noinfo) {
    1408. 

  1408. 		print STDERR "Warning: $num_noinfo symbols were without info.";
    1409. 

  1409. 		if ($do_rewrite) {
    1410. 

  1410. 			printf STDERR "  The rewrite will fix this.\n";
    1411. 

  1411. 		} else {
    1412. 

  1412. 			printf STDERR "  You should do a rewrite to fix this.\n";
    1413. 

  1413. 		}
    1414. 

  1414. 	}
    1415. 

  1415. 	close(IN);
    1416. 

  1416. 	return(%ret);
    1417. 

  1417. }
    1418. 

  1418. 

  1419. sub parse_number
    1420. 

  1420. {
    1421. 

  1421. 	(my $str, my $what) = @_;
    1422. 

  1422. 	(my $n, my $i) = split(/\\/,$str);
    1423. 

  1423. 	if ($what eq "n") {
    1424. 

  1424. 		return $n;
    1425. 

  1425. 	} else {
    1426. 

  1426. 		return $i;
    1427. 

  1427. 	}
    1428. 

  1428. }
    1429. 

  1429. 

  1430. sub rewrite_numbers
    1431. 

  1431. {
    1432. 

  1432. 	(*OUT,$name,*nums,@symbols)=@_;
    1433. 

  1433. 	my $thing;
    1434. 

  1434. 

  1435. 	print STDERR "Rewriting $name\n";
    1436. 

  1436. 

  1437. 	my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
    1438. 

  1438. 	my $r; my %r; my %rsyms;
    1439. 

  1439. 	foreach $r (@r) {
    1440. 

  1440. 		(my $s, my $i) = split /\\/, $r;
    1441. 

  1441. 		my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
    1442. 

  1442. 		$i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
    1443. 

  1443. 		$r{$a} = $s."\\".$i;
    1444. 

  1444. 		$rsyms{$s} = 1;
    1445. 

  1445. 	}
    1446. 

  1446. 

  1447. 	my %syms = ();
    1448. 

  1448. 	foreach $_ (@symbols) {
    1449. 

  1449. 		(my $n, my $i) = split /\\/;
    1450. 

  1450. 		$syms{$n} = 1;
    1451. 

  1451. 	}
    1452. 

  1452. 

  1453. 	my @s=sort {
    1454. 

  1454. 	    &parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n")
    1455. 

  1455. 	    || $a cmp $b
    1456. 

  1456. 	} keys %nums;
    1457. 

  1457. 	foreach $sym (@s) {
    1458. 

  1458. 		(my $n, my $i) = split /\\/, $nums{$sym};
    1459. 

  1459. 		next if defined($i) && $i =~ /^.*?:.*?:\w+\(\w+\)/;
    1460. 

  1460. 		next if defined($rsyms{$sym});
    1461. 

  1461. 		print STDERR "DEBUG: rewrite_numbers for sym = ",$sym,": i = ",$i,", n = ",$n,", rsym{sym} = ",$rsyms{$sym},"syms{sym} = ",$syms{$sym},"\n" if $debug;
    1462. 

  1462. 		$i="NOEXIST::FUNCTION:"
    1463. 

  1463. 			if !defined($i) || $i eq "" || !defined($syms{$sym});
    1464. 

  1464. 		my $s2 = $sym;
    1465. 

  1465. 		$s2 =~ s/\{[0-9]+\}$//;
    1466. 

  1466. 		printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
    1467. 

  1467. 		if (exists $r{$sym}) {
    1468. 

  1468. 			(my $s, $i) = split /\\/,$r{$sym};
    1469. 

  1469. 			my $s2 = $s;
    1470. 

  1470. 			$s2 =~ s/\{[0-9]+\}$//;
    1471. 

  1471. 			printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
    1472. 

  1472. 		}
    1473. 

  1473. 	}
    1474. 

  1474. }
    1475. 

  1475. 

  1476. sub update_numbers
    1477. 

  1477. {
    1478. 

  1478. 	(*OUT,$name,*nums,my $start_num, my @symbols)=@_;
    1479. 

  1479. 	my $new_syms = 0;
    1480. 

  1480. 

  1481. 	print STDERR "Updating $name numbers\n";
    1482. 

  1482. 

  1483. 	my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
    1484. 

  1484. 	my $r; my %r; my %rsyms;
    1485. 

  1485. 	foreach $r (@r) {
    1486. 

  1486. 		(my $s, my $i) = split /\\/, $r;
    1487. 

  1487. 		my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
    1488. 

  1488. 		$i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
    1489. 

  1489. 		$r{$a} = $s."\\".$i;
    1490. 

  1490. 		$rsyms{$s} = 1;
    1491. 

  1491. 	}
    1492. 

  1492. 

  1493. 	foreach $sym (@symbols) {
    1494. 

  1494. 		(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
    1495. 

  1495. 		next if $i =~ /^.*?:.*?:\w+\(\w+\)/;
    1496. 

  1496. 		next if defined($rsyms{$sym});
    1497. 

  1497. 		die "ERROR: Symbol $sym had no info attached to it."
    1498. 

  1498. 		    if $i eq "";
    1499. 

  1499. 		if (!exists $nums{$s}) {
    1500. 

  1500. 			$new_syms++;
    1501. 

  1501. 			my $s2 = $s;
    1502. 

  1502. 			$s2 =~ s/\{[0-9]+\}$//;
    1503. 

  1503. 			printf OUT "%s%-39s %d\t%s\n","",$s2, ++$start_num,$i;
    1504. 

  1504. 			if (exists $r{$s}) {
    1505. 

  1505. 				($s, $i) = split /\\/,$r{$s};
    1506. 

  1506. 				$s =~ s/\{[0-9]+\}$//;
    1507. 

  1507. 				printf OUT "%s%-39s %d\t%s\n","",$s, $start_num,$i;
    1508. 

  1508. 			}
    1509. 

  1509. 		}
    1510. 

  1510. 	}
    1511. 

  1511. 	if($new_syms) {
    1512. 

  1512. 		print STDERR "$new_syms New symbols added\n";
    1513. 

  1513. 	} else {
    1514. 

  1514. 		print STDERR "No New symbols Added\n";
    1515. 

  1515. 	}
    1516. 

  1516. }
    1517. 

  1517. 

  1518. sub check_existing
    1519. 

  1519. {
    1520. 

  1520. 	(*nums, my @symbols)=@_;
    1521. 

  1521. 	my %existing; my @remaining;
    1522. 

  1522. 	@remaining=();
    1523. 

  1523. 	foreach $sym (@symbols) {
    1524. 

  1524. 		(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
    1525. 

  1525. 		$existing{$s}=1;
    1526. 

  1526. 	}
    1527. 

  1527. 	foreach $sym (keys %nums) {
    1528. 

  1528. 		if (!exists $existing{$sym}) {
    1529. 

  1529. 			push @remaining, $sym;
    1530. 

  1530. 		}
    1531. 

  1531. 	}
    1532. 

  1532. 	if(@remaining) {
    1533. 

  1533. 		print STDERR "The following symbols do not seem to exist:\n";
    1534. 

  1534. 		foreach $sym (@remaining) {
    1535. 

  1535. 			print STDERR "\t",$sym,"\n";
    1536. 

  1536. 		}
    1537. 

  1537. 	}
    1538. 

  1538. }
    1539. 

  1539. 

  1540.