Tweak generated warning lines.
[openssl.git] / util / mkerr.pl
1 #! /usr/bin/env perl
2 # Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
3 #
4 # Licensed under the OpenSSL license (the "License").  You may not use
5 # this file except in compliance with the License.  You can obtain a copy
6 # in the file LICENSE in the source distribution or at
7 # https://www.openssl.org/source/license.html
8
9 my $config = "crypto/err/openssl.ec";
10 my $hprefix = "openssl/";
11 my $debug = 0;
12 my $unref = 0;
13 my $rebuild = 0;
14 my $static = 1;
15 my $recurse = 0;
16 my $reindex = 0;
17 my $dowrite = 0;
18 my $staticloader = "";
19 my @t = localtime();
20 my $YEAR = @t[5] + 1900;
21
22 my $pack_errcode;
23 my $load_errcode;
24
25 my $errcount;
26 my $year = (localtime)[5] + 1900;
27
28 while (@ARGV) {
29         my $arg = $ARGV[0];
30         if($arg eq "-conf") {
31                 shift @ARGV;
32                 $config = shift @ARGV;
33         } elsif($arg eq "-hprefix") {
34                 shift @ARGV;
35                 $hprefix = shift @ARGV;
36         } elsif($arg eq "-debug") {
37                 $debug = 1;
38                 $unref = 1;
39                 shift @ARGV;
40         } elsif($arg eq "-rebuild") {
41                 $rebuild = 1;
42                 shift @ARGV;
43         } elsif($arg eq "-recurse") {
44                 $recurse = 1;
45                 shift @ARGV;
46         } elsif($arg eq "-reindex") {
47                 $reindex = 1;
48                 shift @ARGV;
49         } elsif($arg eq "-nostatic") {
50                 $static = 0;
51                 shift @ARGV;
52         } elsif($arg eq "-staticloader") {
53                 $staticloader = "static ";
54                 shift @ARGV;
55         } elsif($arg eq "-unref") {
56                 $unref = 1;
57                 shift @ARGV;
58         } elsif($arg eq "-write") {
59                 $dowrite = 1;
60                 shift @ARGV;
61         } elsif($arg eq "-help" || $arg eq "-h" || $arg eq "-?" || $arg eq "--help") {
62                 print STDERR <<"EOF";
63 mkerr.pl [options] ...
64
65 Options:
66
67   -conf F       Use the config file F instead of the default one:
68                   crypto/err/openssl.ec
69
70   -hprefix P    Prepend the filenames in generated #include <header>
71                 statements with prefix P. Default: 'openssl/' (without
72                 the quotes, naturally)
73
74   -debug        Turn on debugging verbose output on stderr.
75
76   -rebuild      Rebuild all header and C source files, irrespective of the
77                 fact if any error or function codes have been added/removed.
78                 Default: only update files for libraries which saw change
79                          (of course, this requires '-write' as well, or no
80                           files will be touched!)
81
82   -recurse      scan a preconfigured set of directories / files for error and
83                 function codes:
84                   (<crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>, <apps/*.c>)
85                 When this option is NOT specified, the filelist is taken from
86                 the commandline instead. Here, wildcards may be embedded. (Be
87                 sure to escape those to prevent the shell from expanding them
88                 for you when you wish mkerr.pl to do so instead.)
89                 Default: take file list to scan from the command line.
90
91   -reindex      Discard the numeric values previously assigned to the error
92                 and function codes as extracted from the scanned header files;
93                 instead renumber all of them starting from 100. (Note that
94                 the numbers assigned through 'R' records in the config file
95                 remain intact.)
96                 Default: keep previously assigned numbers. (You are warned
97                          when collisions are detected.)
98
99   -nostatic     Generates a different source code, where these additional 
100                 functions are generated for each library specified in the
101                 config file:
102                   void ERR_load_<LIB>_strings(void);
103                   void ERR_unload_<LIB>_strings(void);
104                   void ERR_<LIB>_error(int f, int r, char *fn, int ln);
105                   #define <LIB>err(f,r) ERR_<LIB>_error(f,r,OPENSSL_FILE,OPENSSL_LINE)
106                 while the code facilitates the use of these in an environment
107                 where the error support routines are dynamically loaded at 
108                 runtime.
109                 Default: 'static' code generation.
110
111   -staticloader Prefix generated functions with the 'static' scope modifier.
112                 Default: don't write any scope modifier prefix.
113
114   -unref        Print out unreferenced function and reason codes.
115
116   -write        Actually (over)write the generated code to the header and C 
117                 source files as assigned to each library through the config 
118                 file.
119                 Default: don't write.
120
121   -help / -h / -? / --help            Show this help text.
122
123   ...           Additional arguments are added to the file list to scan,
124                 assuming '-recurse' was NOT specified on the command line.
125
126 EOF
127                 exit 1;
128         } else {
129                 last;
130         }
131 }
132
133 if($recurse) {
134         @source = ( <crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>, <ssl/*/*.c> )
135 } else {
136         @source = @ARGV;
137 }
138
139 # Read in the config file
140
141 open(IN, "<$config") || die "Can't open config file $config";
142
143 # Parse config file
144
145 while(<IN>)
146 {
147         if(/^L\s+(\S+)\s+(\S+)\s+(\S+)/) {
148                 $hinc{$1} = $2;
149                 $libinc{$2} = $1;
150                 $cskip{$3} = $1;
151                 if($3 ne "NONE") {
152                         $csrc{$1} = $3;
153                         $fmax{$1} = 100;
154                         $rmax{$1} = 100;
155                         $fassigned{$1} = ":";
156                         $rassigned{$1} = ":";
157                         $fnew{$1} = 0;
158                         $rnew{$1} = 0;
159                 }
160         } elsif (/^F\s+(\S+)/) {
161         # Add extra function with $1
162         } elsif (/^R\s+(\S+)\s+(\S+)/) {
163                 $rextra{$1} = $2;
164                 $rcodes{$1} = $2;
165         }
166 }
167
168 close IN;
169
170 # Scan each header file in turn and make a list of error codes
171 # and function names
172
173 while (($hdr, $lib) = each %libinc)
174 {
175         next if($hdr eq "NONE");
176         print STDERR "Scanning header file $hdr\n" if $debug; 
177         my $line = "", $def= "", $linenr = 0, $gotfile = 0;
178         if (open(IN, "<$hdr")) {
179             $gotfile = 1;
180             while(<IN>) {
181                 $linenr++;
182                 print STDERR "line: $linenr\r" if $debug;
183
184                 last if(/BEGIN\s+ERROR\s+CODES/);
185                 if ($line ne '') {
186                     $_ = $line . $_;
187                     $line = '';
188                 }
189
190                 if (/\\$/) {
191                     $line = $_;
192                     next;
193                 }
194
195                 if(/\/\*/) {
196                     if (not /\*\//) {           # multiline comment...
197                         $line = $_;             # ... just accumulate
198                         next; 
199                     } else {
200                         s/\/\*.*?\*\///gs;      # wipe it
201                     }
202                 }
203
204                 if ($cpp) {
205                     $cpp++ if /^#\s*if/;
206                     $cpp-- if /^#\s*endif/;
207                     next;
208                 }
209                 $cpp = 1 if /^#.*ifdef.*cplusplus/;  # skip "C" declaration
210
211                 next if (/^\#/);                      # skip preprocessor directives
212
213                 s/{[^{}]*}//gs;                      # ignore {} blocks
214
215                 if (/\{|\/\*/) { # Add a } so editor works...
216                     $line = $_;
217                 } else {
218                     $def .= $_;
219                 }
220             }
221         }
222
223         print STDERR "                                  \r" if $debug;
224         $defnr = 0;
225         # Delete any DECLARE_ macros
226         $def =~ s/DECLARE_\w+\([\w,\s]+\)//gs;
227         foreach (split /;/, $def) {
228             $defnr++;
229             print STDERR "def: $defnr\r" if $debug;
230
231             # The goal is to collect function names from function declarations.
232
233             s/^[\n\s]*//g;
234             s/[\n\s]*$//g;
235
236             # Skip over recognized non-function declarations
237             next if(/typedef\W/ or /DECLARE_STACK_OF/ or /TYPEDEF_.*_OF/);
238
239             # Remove STACK_OF(foo)
240             s/STACK_OF\(\w+\)/void/;
241
242             # Reduce argument lists to empty ()
243             # fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}
244             while(/\(.*\)/s) {
245                 s/\([^\(\)]+\)/\{\}/gs;
246                 s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs;    #(*f{}) -> f
247             }
248             # pretend as we didn't use curly braces: {} -> ()
249             s/\{\}/\(\)/gs;
250
251             if (/(\w+)\s*\(\).*/s) {    # first token prior [first] () is
252                 my $name = $1;          # a function name!
253                 $name =~ tr/[a-z]/[A-Z]/;
254                 $ftrans{$name} = $1;
255             } elsif (/[\(\)]/ and not (/=/)) {
256                 print STDERR "Header $hdr: cannot parse: $_;\n";
257             }
258         }
259
260         print STDERR "                                  \r" if $debug;
261
262         next if $reindex;
263
264         # Scan function and reason codes and store them: keep a note of the
265         # maximum code used.
266
267         if ($gotfile) {
268           while(<IN>) {
269                 if(/^\#\s*define\s+(\S+)\s+(\S+)/) {
270                         $name = $1;
271                         $code = $2;
272                         next if $name =~ /^${lib}err/;
273                         unless($name =~ /^${lib}_([RF])_(\w+)$/) {
274                                 print STDERR "Invalid error code $name\n";
275                                 next;
276                         }
277                         if($1 eq "R") {
278                                 $rcodes{$name} = $code;
279                                 if ($rassigned{$lib} =~ /:$code:/) {
280                                         print STDERR "!! ERROR: $lib reason code $code assigned twice (collision at $name)\n";
281                                         ++$errcount;
282                                 }
283                                 $rassigned{$lib} .= "$code:";
284                                 if(!(exists $rextra{$name}) &&
285                                          ($code > $rmax{$lib}) ) {
286                                         $rmax{$lib} = $code;
287                                 }
288                         } else {
289                                 if ($fassigned{$lib} =~ /:$code:/) {
290                                         print STDERR "!! ERROR: $lib function code $code assigned twice (collision at $name)\n";
291                                         ++$errcount;
292                                 }
293                                 $fassigned{$lib} .= "$code:";
294                                 if($code > $fmax{$lib}) {
295                                         $fmax{$lib} = $code;
296                                 }
297                                 $fcodes{$name} = $code;
298                         }
299                 }
300           }
301         }
302
303         if ($debug) {
304                 if (defined($fmax{$lib})) {
305                         print STDERR "Max function code fmax" . "{" . "$lib" . "} = $fmax{$lib}\n";
306                         $fassigned{$lib} =~ m/^:(.*):$/;
307                         @fassigned = sort {$a <=> $b} split(":", $1);
308                         print STDERR "  @fassigned\n";
309                 }
310                 if (defined($rmax{$lib})) {
311                         print STDERR "Max reason code rmax" . "{" . "$lib" . "} = $rmax{$lib}\n";
312                         $rassigned{$lib} =~ m/^:(.*):$/;
313                         @rassigned = sort {$a <=> $b} split(":", $1);
314                         print STDERR "  @rassigned\n";
315                 }
316         }
317
318         if ($lib eq "SSL") {
319                 if ($rmax{$lib} >= 1000) {
320                         print STDERR "!! ERROR: SSL error codes 1000+ are reserved for alerts.\n";
321                         print STDERR "!!        Any new alerts must be added to $config.\n";
322                         ++$errcount;
323                         print STDERR "\n";
324                 }
325         }
326         close IN;
327 }
328
329 # Scan each C source file and look for function and reason codes
330 # This is done by looking for strings that "look like" function or
331 # reason codes: basically anything consisting of all upper case and
332 # numerics which has _F_ or _R_ in it and which has the name of an
333 # error library at the start. This seems to work fine except for the
334 # oddly named structure BIO_F_CTX which needs to be ignored.
335 # If a code doesn't exist in list compiled from headers then mark it
336 # with the value "X" as a place holder to give it a value later.
337 # Store all function and reason codes found in %ufcodes and %urcodes
338 # so all those unreferenced can be printed out.
339
340
341 foreach $file (@source) {
342         # Don't parse the error source file.
343         next if exists $cskip{$file};
344         print STDERR "File loaded: ".$file."\r" if $debug;
345         open(IN, "<$file") || die "Can't open source file $file\n";
346         my $func;
347         my $linenr = 0;
348         while(<IN>) {
349                 # skip obsoleted source files entirely!
350                 last if(/^#error\s+obsolete/);
351                 $linenr++;
352                 if (!/;$/ && /^\**([a-zA-Z_].*[\s*])?([A-Za-z_0-9]+)\(.*([),]|$)/)
353                         {
354                         /^([^()]*(\([^()]*\)[^()]*)*)\(/;
355                         $1 =~ /([A-Za-z_0-9]*)$/;
356                         $func = $1;
357                         }
358
359                 if(/(([A-Z0-9]+)_F_([A-Z0-9_]+))/) {
360                         next unless exists $csrc{$2};
361                         next if($1 eq "BIO_F_BUFFER_CTX");
362                         $ufcodes{$1} = 1;
363                         if(!exists $fcodes{$1}) {
364                                 $fcodes{$1} = "X";
365                                 $fnew{$2}++;
366                         }
367                         $ftrans{$3} = $func unless exists $ftrans{$3};
368             if (uc $func ne $3) {
369                 print STDERR "ERROR: mismatch $file:$linenr $func:$3\n";
370                 $errcount++;
371             }
372                         print STDERR "Function: $1\t= $fcodes{$1} (lib: $2, name: $3)\n" if $debug; 
373                 }
374                 if(/(([A-Z0-9]+)_R_[A-Z0-9_]+)/) {
375                         next unless exists $csrc{$2};
376                         $urcodes{$1} = 1;
377                         if(!exists $rcodes{$1}) {
378                                 $rcodes{$1} = "X";
379                                 $rnew{$2}++;
380                         }
381                         print STDERR "Reason: $1\t= $rcodes{$1} (lib: $2)\n" if $debug; 
382                 } 
383         }
384         close IN;
385 }
386 print STDERR "                                  \n" if $debug;
387
388 # Now process each library in turn.
389
390 foreach $lib (keys %csrc)
391 {
392         my $hfile = $hinc{$lib};
393         my $cfile = $csrc{$lib};
394         if(!$fnew{$lib} && !$rnew{$lib}) {
395                 next unless $rebuild;
396         } else {
397                 print STDERR "$lib:\t\t$fnew{$lib} New Functions,";
398                 print STDERR " $rnew{$lib} New Reasons.\n";
399                 next unless $dowrite;
400         }
401
402         # If we get here then we have some new error codes so we
403         # need to rebuild the header file and C file.
404
405         # Make a sorted list of error and reason codes for later use.
406
407         my @function = sort grep(/^${lib}_/,keys %fcodes);
408         my @reasons = sort grep(/^${lib}_/,keys %rcodes);
409
410         # Rewrite the header file
411
412         if (open(IN, "<$hfile")) {
413             # Copy across the old file
414             while(<IN>) {
415                 push @out, $_;
416                 last if (/BEGIN ERROR CODES/);
417             }
418             close IN;
419         } else {
420             push @out,
421 "/*\n",
422 " * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.\n",
423 " *\n",
424 " * Licensed under the OpenSSL license (the \"License\").  You may not use\n",
425 " * this file except in compliance with the License.  You can obtain a copy\n",
426 " * in the file LICENSE in the source distribution or at\n",
427 " * https://www.openssl.org/source/license.html\n",
428 " */\n",
429 "\n",
430 "#ifndef HEADER_${lib}_ERR_H\n",
431 "#define HEADER_${lib}_ERR_H\n",
432 "\n",
433 "#ifdef  __cplusplus\n",
434 "extern \"C\" {\n",
435 "#endif\n",
436 "\n",
437 "/* BEGIN ERROR CODES */\n";
438         }
439         open (OUT, ">$hfile") || die "Can't Open File $hfile for writing\n";
440
441         print OUT @out;
442         undef @out;
443         print OUT <<"EOF";
444
445 /*
446  * Content after this point is generated by util/mkerr.pl
447  * DO NOT EDIT!
448  */
449 EOF
450         if($static) {
451                 print OUT <<"EOF";
452 ${staticloader}void ERR_load_${lib}_strings(void);
453 EOF
454         } else {
455                 print OUT <<"EOF";
456 ${staticloader}void ERR_load_${lib}_strings(void);
457 ${staticloader}void ERR_unload_${lib}_strings(void);
458 ${staticloader}void ERR_${lib}_error(int function, int reason, char *file, int line);
459 # define ${lib}err(f,r) ERR_${lib}_error((f),(r),OPENSSL_FILE,OPENSSL_LINE)
460
461 EOF
462         }
463         print OUT <<"EOF";
464 /* Error codes for the $lib functions. */
465
466 /* Function codes. */
467 EOF
468
469         foreach $i (@function) {
470                 $z=48 - length($i);
471                 if($fcodes{$i} eq "X") {
472                         $fassigned{$lib} =~ m/^:([^:]*):/;
473                         $findcode = $1;
474                         if (!defined($findcode)) {
475                                 $findcode = $fmax{$lib};
476                         }
477                         while ($fassigned{$lib} =~ m/:$findcode:/) {
478                                 $findcode++;
479                         }
480                         $fcodes{$i} = $findcode;
481                         $fassigned{$lib} .= "$findcode:";
482                         print STDERR "New Function code $i\n" if $debug;
483                 }
484                 printf OUT "# define $i%s $fcodes{$i}\n"," " x $z;
485         }
486
487         print OUT "\n/* Reason codes. */\n";
488
489         foreach $i (@reasons) {
490                 $z=48 - length($i);
491                 if($rcodes{$i} eq "X") {
492                         $rassigned{$lib} =~ m/^:([^:]*):/;
493                         $findcode = $1;
494                         if (!defined($findcode)) {
495                                 $findcode = $rmax{$lib};
496                         }
497                         while ($rassigned{$lib} =~ m/:$findcode:/) {
498                                 $findcode++;
499                         }
500                         $rcodes{$i} = $findcode;
501                         $rassigned{$lib} .= "$findcode:";
502                         print STDERR "New Reason code   $i\n" if $debug;
503                 }
504                 printf OUT "# define $i%s $rcodes{$i}\n"," " x $z;
505         }
506         print OUT <<"EOF";
507
508 #ifdef  __cplusplus
509 }
510 #endif
511 #endif
512 EOF
513         close OUT;
514
515         # Rewrite the C source file containing the error details.
516
517         # First, read any existing reason string definitions:
518         my %err_reason_strings;
519         if (open(IN,"<$cfile")) {
520                 my $line = "";
521                 while (<IN>) {
522                         s|\R$||; # Better chomp
523                         $_ = $line . $_;
524                         $line = "";
525                         if (/{ERR_(FUNC|REASON)\(/) {
526                                 if (/\b(${lib}_R_\w*)\b.*\"(.*)\"/) {
527                                         $err_reason_strings{$1} = $2;
528                                 } elsif (/\b${lib}_F_(\w*)\b.*\"(.*)\"/) {
529                                         if (!exists $ftrans{$1} && ($1 ne $2)) {
530                                                 print STDERR "WARNING: Mismatched function string $2\n";
531                                                 $ftrans{$1} = $2;
532                                         }
533                                 } else {
534                                         $line = $_;
535                                 }
536                         }
537                 }
538                 close(IN);
539         }
540
541
542         my $hincf;
543         if($static) {
544                 $hfile =~ /([^\/]+)$/;
545                 $hincf = "<${hprefix}$1>";
546         } else {
547                 $hincf = "\"$hfile\"";
548         }
549
550         # If static we know the error code at compile time so use it
551         # in error definitions.
552
553         if ($static)
554                 {
555                 $pack_errcode = "ERR_LIB_${lib}";
556                 $load_errcode = "0";
557                 }
558         else
559                 {
560                 $pack_errcode = "0";
561                 $load_errcode = "ERR_LIB_${lib}";
562                 }
563
564
565         open (OUT,">$cfile") || die "Can't open $cfile for writing";
566
567         print OUT <<"EOF";
568 /*
569  * Generated by util/mkerr.pl DO NOT EDIT
570  * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
571  *
572  * Licensed under the OpenSSL license (the "License").  You may not use
573  * this file except in compliance with the License.  You can obtain a copy
574  * in the file LICENSE in the source distribution or at
575  * https://www.openssl.org/source/license.html
576  */
577
578 #include <stdio.h>
579 #include <openssl/err.h>
580 #include $hincf
581
582 /* BEGIN ERROR CODES */
583 #ifndef OPENSSL_NO_ERR
584
585 # define ERR_FUNC(func) ERR_PACK($pack_errcode,func,0)
586 # define ERR_REASON(reason) ERR_PACK($pack_errcode,0,reason)
587
588 static ERR_STRING_DATA ${lib}_str_functs[] = {
589 EOF
590         # Add each function code: if a function name is found then use it.
591         foreach $i (@function) {
592                 my $fn;
593                 $i =~ /^${lib}_F_(\S+)$/;
594                 $fn = $1;
595                 if(exists $ftrans{$fn}) {
596                         $fn = $ftrans{$fn};
597                 }
598 #               print OUT "{ERR_PACK($pack_errcode,$i,0),\t\"$fn\"},\n";
599                 if(length($i) + length($fn) > 58) {
600                         print OUT "    {ERR_FUNC($i),\n     \"$fn\"},\n";
601                 } else {
602                         print OUT "    {ERR_FUNC($i), \"$fn\"},\n";
603                 }
604         }
605         print OUT <<"EOF";
606     {0, NULL}
607 };
608
609 static ERR_STRING_DATA ${lib}_str_reasons[] = {
610 EOF
611         # Add each reason code.
612         foreach $i (@reasons) {
613                 my $rn;
614                 my $rstr = "ERR_REASON($i)";
615                 if (exists $err_reason_strings{$i}) {
616                         $rn = $err_reason_strings{$i};
617                 } else {
618                         $i =~ /^${lib}_R_(\S+)$/;
619                         $rn = $1;
620                         $rn =~ tr/_[A-Z]/ [a-z]/;
621                 }
622                 if(length($i) + length($rn) > 56) {
623                         print OUT "    {${rstr},\n     \"$rn\"},\n";
624                 } else {
625                         print OUT "    {${rstr}, \"$rn\"},\n";
626                 }
627         }
628 if($static) {
629         print OUT <<"EOF";
630     {0, NULL}
631 };
632
633 #endif
634
635 ${staticloader}void ERR_load_${lib}_strings(void)
636 {
637 #ifndef OPENSSL_NO_ERR
638
639     if (ERR_func_error_string(${lib}_str_functs[0].error) == NULL) {
640         ERR_load_strings($load_errcode, ${lib}_str_functs);
641         ERR_load_strings($load_errcode, ${lib}_str_reasons);
642     }
643 #endif
644 }
645 EOF
646 } else {
647         print OUT <<"EOF";
648     {0, NULL}
649 };
650
651 #endif
652
653 #ifdef ${lib}_LIB_NAME
654 static ERR_STRING_DATA ${lib}_lib_name[] = {
655     {0, ${lib}_LIB_NAME},
656     {0, NULL}
657 };
658 #endif
659
660 static int ${lib}_lib_error_code = 0;
661 static int ${lib}_error_init = 1;
662
663 ${staticloader}void ERR_load_${lib}_strings(void)
664 {
665     if (${lib}_lib_error_code == 0)
666         ${lib}_lib_error_code = ERR_get_next_error_library();
667
668     if (${lib}_error_init) {
669         ${lib}_error_init = 0;
670 #ifndef OPENSSL_NO_ERR
671         ERR_load_strings(${lib}_lib_error_code, ${lib}_str_functs);
672         ERR_load_strings(${lib}_lib_error_code, ${lib}_str_reasons);
673 #endif
674
675 #ifdef ${lib}_LIB_NAME
676         ${lib}_lib_name->error = ERR_PACK(${lib}_lib_error_code, 0, 0);
677         ERR_load_strings(0, ${lib}_lib_name);
678 #endif
679     }
680 }
681
682 ${staticloader}void ERR_unload_${lib}_strings(void)
683 {
684     if (${lib}_error_init == 0) {
685 #ifndef OPENSSL_NO_ERR
686         ERR_unload_strings(${lib}_lib_error_code, ${lib}_str_functs);
687         ERR_unload_strings(${lib}_lib_error_code, ${lib}_str_reasons);
688 #endif
689
690 #ifdef ${lib}_LIB_NAME
691         ERR_unload_strings(0, ${lib}_lib_name);
692 #endif
693         ${lib}_error_init = 1;
694     }
695 }
696
697 ${staticloader}void ERR_${lib}_error(int function, int reason, char *file, int line)
698 {
699     if (${lib}_lib_error_code == 0)
700         ${lib}_lib_error_code = ERR_get_next_error_library();
701     ERR_PUT_error(${lib}_lib_error_code, function, reason, file, line);
702 }
703 EOF
704
705 }
706
707         close OUT;
708         undef %err_reason_strings;
709 }
710
711 if($debug && %notrans) {
712         print STDERR "The following function codes were not translated:\n";
713         foreach(sort keys %notrans)
714         {
715                 print STDERR "$_\n";
716         }
717 }
718
719 # Make a list of unreferenced function and reason codes
720
721 foreach (keys %fcodes) {
722         push (@funref, $_) unless exists $ufcodes{$_};
723 }
724
725 foreach (keys %rcodes) {
726         push (@runref, $_) unless exists $urcodes{$_};
727 }
728
729 if($unref && @funref) {
730         print STDERR "The following function codes were not referenced:\n";
731         foreach(sort @funref)
732         {
733                 print STDERR "$_\n";
734         }
735 }
736
737 if($unref && @runref) {
738         print STDERR "The following reason codes were not referenced:\n";
739         foreach(sort @runref)
740         {
741                 print STDERR "$_\n";
742         }
743 }
744
745 if($errcount) {
746         print STDERR "There were errors, failing...\n\n";
747         exit $errcount;
748 }
749