Replaced by mkerr.pl

#!/usr/local/bin/perl -w

# Modified by Steve Henson. It should now read in the .err

# file and only add new error codes, retaining the old

# numbers. 

# Before it re-sorted new codes and re-ordered the whole thing. 

# This is the motivation for the change: the re numbering caused large

# patch files even if only one error or reason code was added.

# To force regeneration of all error codes (the old behaviour) use the

# -regen flag.

$regen = 0;

while (@ARGV)

	{

	$in=shift(@ARGV);

	if ($in =~ /^-conf$/)

		{

		$in=shift(@ARGV);

		open(IN,"<$in") || die "unable to open '$in'\n";

		while (<IN>)

			{

			s/#.*$//;

			s/\s+$//;

			next if (/^$/);

			if (/^L\s+(\S+)\s+(\S+)$/)

				{ $errfile{$1}=$2; }

			elsif (/^F\s+(\S+)$/)

				{ $function{$1}=1; }

			elsif (/^R\s+(\S+)\s+(\S+)$/)

				{ $r_value{$1}=$2; }

			else { die "bad input line: $in:$.\n"; }

			}

		close(IN);

		next;

		}

	elsif ($in =~ /^-regen/)

		{

		$regen = 1;

		next;

	}

	open(IN,"<$in") || die "unable to open '$in'\n";

	$last="";

	while (<IN>)

		{

		if (/err\(([A-Z0-9]+_F_[0-9A-Z_]+)\s*,\s*([0-9A-Z]+_R_[0-9A-Z_]+)\s*\)/)

			{

# Not sure what this was supposed to be for: it's broken anyway [steve]

#			if ($1 != $last)

#				{

#				if ($function{$1} == 0)

#					{

#					printf STDERR "$. $1 is bad\n";

#					}

#				}

			$function{$1}++;

			$last=$1;

			$reason{$2}++;

			}

		}

	close(IN);

	}

foreach (keys %function,keys %reason)

	{

	/^([A-Z0-9]+)_/;

	$prefix{$1}++;

	}

@F=sort keys %function;

@R=sort keys %reason;

foreach $j (sort keys %prefix)

	{

	next if !defined $errfile{$j};

	next if $errfile{$j} eq "NONE";

	printf STDERR "doing %-6s - ",$j;

	@f=grep(/^${j}_/,@F);

	@r=grep(/^${j}_/,@R);

	if (defined($errfile{$j}))

		{

		read_errcodes($errfile{$j});

		# Check to see if any new codes: if not ignore.

		$new_codes = 0;

		foreach (@f) {

			if(!exists $func_codes{$_}) {

				$new_codes = 1;

				last;

			}

		}

		if(!$new_codes) {

			foreach (@r) {

				if(!exists $reason_codes{$_}) {

					$new_codes = 1;

					last;

				}

			}

		}

		if(!$new_codes) {

			print STDERR "No New Codes\n";

			next;

		}

		open(OUT,">$errfile{$j}") ||

			die "unable to open '$errfile{$j}':$!\n";

		$close_file=1;

		}

	else

		{

		$min_func = 100;

		$min_reason = 100;

		*OUT=*STDOUT;

		$close_file=0;

		}

	$num=$min_func;

	print OUT "/* Error codes for the $j functions. */\n\n";

	print OUT "/* Function codes. */\n";

	$f_count=0;

	foreach $i (@f)

		{

		$z=6-int(length($i)/8);

		if(exists $func_codes{$i}) {

			printf OUT "#define $i%s $func_codes{$i}\n","\t" x $z;

		} else {

			printf OUT "#define $i%s $num\n","\t" x $z;

			$num++;

		}

		$f_count++;

		}

	$num=$min_reason;

	print OUT "\n/* Reason codes. */\n";

	$r_count=0;

	foreach $i (@r)

		{

		$z=6-int(length($i)/8);

		if (exists $reason_codes{$i}) {

			printf OUT "#define $i%s $reason_codes{$i}\n","\t" x $z;

		} elsif (exists $r_value{$i}) {

			printf OUT "#define $i%s $r_value{$i}\n","\t" x $z;

		} else {

			printf OUT "#define $i%s $num\n","\t" x $z;

			$num++;

		}

		$r_count++;

		}

	close(OUT) if $close_file;

	printf STDERR "%3d functions, %3d reasons\n",$f_count,$r_count;

	}

# Read in the error codes and populate %function and %reason with the

# old codes. Also define $min_func and $min_reason with the smallest

# unused function and reason codes. Care is needed because the

# config file can define larger reason codes and these should be

# ignored.

sub read_errcodes {

$file = $_[0];

$min_func = 100;

$min_reason = 100;

undef %func_codes;

undef %reason_codes;

return if ($regen);

if (open IN, $file) {

	while(<IN>) {

		if(/^#define\s*(\S*)\s*(\S*)/) {

			if (exists $function{$1} ) {

				if($2 >= $min_func) {$min_func = $2 + 1;}

				$func_codes{$1} = $2;

			} elsif ((defined %reason) && exists $reason{$1}) {

				$reason_codes{$1} = $2;

				if( !(exists $r_value{$1})  &&

						 ($2 >= $min_reason))

							 {$min_reason = $2 + 1;}

			}

		}

	}

	close IN;

}

}

#!/usr/local/bin/perl

if ($ARGV[0] eq "-s") { $static=1; shift @ARGV; }

($#ARGV == 1) || die "usage: $0 [-s] <header file> <output C file>\n";

open(IN,"<$ARGV[0]") || die "unable to open $ARGV[0]:$!\n";

open(STDOUT,">$ARGV[1]") || die "unable to open $ARGV[1]:$!\n";

$Func=0;

$Reas=0;

$fuction{'FOPEN'}='fopen';

while (<IN>)

	{

	if (/(\S+)\s*\(\);/)

		{

		$t=$1;

		$t =~ s/\*//;

		($upper=$t) =~ tr/a-z/A-Z/;

		$fuction{$upper}=$t;

		}

	next unless (/^#define\s+(\S+)\s/);

	$o=$1;

	if ($o =~ /^([^_]+)_F_(.*)/)

		{

		$type=$1;

		$Func++;

		$n=$2;

		$n=$fuction{$n} if (defined($fuction{$n}));

		$out{$1."_str_functs"}.=

			sprintf("{ERR_PACK(0,%s,0),\t\"$n\"},\n",$o);

		}

	elsif ($o =~ /^([^_]+)_R_(.*)/)

		{

		$type=$1;

		$Reas++;

		$r=$2;

		$r =~ tr/A-Z_/a-z /;

		$pkg{$type."_str_reasons"}=$type;

		$out{$type."_str_reasons"}.=sprintf("{%-40s,\"$r\"},\n",$o);

		}

	elsif ($ARGV[0] =~ /rsaref/ && $o =~ /^RE_(.*)/)

		{

		$type="RSAREF";

		$Reas++;

		$r=$1;

		$r =~ tr/A-Z_/a-z /;

		$pkg{$type."_str_reasons"}=$type;

		$out{$type."_str_reasons"}.=sprintf("{%-40s,\"$r\"},\n",$o);

		}

	}

close(IN);

&header($type,$ARGV[0]);

foreach (sort keys %out)

	{

	print "static ERR_STRING_DATA ${_}\[\]=\n\t{\n";

	print $out{$_};

	print "{0,NULL},\n";

	print "\t};\n\n";

	}

print "#endif\n";

if ($static)

	{ $lib="ERR_LIB_$type"; }

else

	{ 

	print <<"EOF";

#ifdef ${type}_LIB_NAME

static ERR_STRING_DATA ${type}_lib_name[]=

        {

{0	,${type}_LIB_NAME},

{0,NULL}

	};

#endif

EOF

	$lib="${type}_lib_error_code"; 

	}

$str="";

$str.="#ifndef NO_ERR\n";

$str.="\t\tERR_load_strings($lib,${type}_str_functs);\n" if $Func;

$str.="\t\tERR_load_strings($lib,${type}_str_reasons);\n" if $Reas;

$str.="#endif\n";

if (!$static)

	{

print <<"EOF";

int ${type}_lib_error_code=0;

void ERR_load_${type}_strings()

	{

	static int init=1;

	if (${type}_lib_error_code == 0)

		${type}_lib_error_code=ERR_get_next_error_library();

	if (init)

		{

		init=0;

$str

#ifdef ${type}_LIB_NAME

		${type}_lib_name->error = ERR_PACK(${type}_lib_error_code,0,0);

		ERR_load_strings(0,${type}_lib_name);

#endif;

		}

	}

void ERR_${type}_error(function,reason,file,line)

int function;

int reason;

char *file;

int line;

	{

	if (${type}_lib_error_code == 0)

		${type}_lib_error_code=ERR_get_next_error_library();

	ERR_PUT_error(${type}_lib_error_code,function,reason,file,line);

	}

EOF

	}

else # $static

	{

	print <<"EOF";

void ERR_load_${type}_strings()

	{

	static int init=1;

	if (init)

		{

		init=0;

$str

		}

	}

EOF

	}

sub header

	{

	($type,$header)=@_;

	($lc=$type) =~ tr/A-Z/a-z/;

	$header =~ s/^.*\///;

	print "/* lib/$lc/${lc}\_err.c */\n";

	print <<'EOF';

/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)

 * All rights reserved.

 *

 * This package is an SSL implementation written

 * by Eric Young (eay@cryptsoft.com).

 * The implementation was written so as to conform with Netscapes SSL.

 * 

 * This library is free for commercial and non-commercial use as long as

 * the following conditions are aheared to.  The following conditions

 * apply to all code found in this distribution, be it the RC4, RSA,

 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

 * included with this distribution is covered by the same copyright terms

 * except that the holder is Tim Hudson (tjh@cryptsoft.com).

 * 

 * Copyright remains Eric Young's, and as such any Copyright notices in

 * the code are not to be removed.

 * If this package is used in a product, Eric Young should be given attribution

 * as the author of the parts of the library used.

 * This can be in the form of a textual message at program startup or

 * in documentation (online or textual) provided with the package.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *    "This product includes cryptographic software written by

 *     Eric Young (eay@cryptsoft.com)"

 *    The word 'cryptographic' can be left out if the rouines from the library

 *    being used are not cryptographic related :-).

 * 4. If you include any Windows specific code (or a derivative thereof) from 

 *    the apps directory (application code) you must include an acknowledgement:

 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

 * 

 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 * 

 * The licence and distribution terms for any publically available version or

 * derivative of this code cannot be changed.  i.e. this code cannot simply be

 * copied and put under another distribution licence

 * [including the GNU Public Licence.]

 */

EOF

	print "#include <stdio.h>\n";

	print "#include <openssl/err.h>\n";

	print "#include <openssl/$header>\n";

	print "\n/* BEGIN ERROR CODES */\n";

	print "#ifndef NO_ERR\n";

	}