Commit 3f39e5ae authored by Bodo Möller's avatar Bodo Möller
Browse files

Using speaking "variable" names in macros so that e.g. grepping for 

sk_whatever_insert and sk_whatever_set immediately reveals the subtle
difference in parameter order.

Change mkstack.pl so that safestack.h is not rewritten when
nothing has changed.
parent 3aceb94b

Makefile.org

+1 −1
Original line number Diff line number Diff line
@@ -300,7 +300,7 @@ errors: 
	perl util/mkerr.pl -recurse -write



stacks:

	perl util/mkstack.pl -recurse

	perl util/mkstack.pl -write



util/libeay.num::

	perl util/mkdef.pl crypto update

crypto/stack/safestack.h

+783 −768

File changed.

Preview size limit exceeded, changes collapsed.

util/mkstack.pl

+64 −71
Original line number Diff line number Diff line 
#!/usr/local/bin/perl -w

#



# This is a utility that searches out "DECLARE_STACK_OF()"

# declarations in header files, and updates/creates/replaces

# the corresponding macro declarations that follow it. The

# reason is that with "DEBUG_SAFESTACK" defined, each type

# will generate 19 functions, all type-safe variants of the

# base "sk_***" functions for the general STACK type. Without

# DEBUG_SAFESTACK defined, we need to macro define all the

# "type'd sk_##type##_***" functions as mapping directly to

# the standard sk_*** equivalents. As it's not generally

# possible to have macros that generate macros, we need to

# control this from the "outside", here in this script.

# declarations in .h and .c files, and updates/creates/replaces

# the corresponding macro declarations in crypto/stack/safestack.h.

# As it's not generally possible to have macros that generate macros,

# we need to control this from the "outside", here in this script.

#

# Geoff Thorpe, June, 2000 (with massive Perl-hacking

#                           help from Steve Robb)



my $type_thing;

my $recurse = 0;

my @files = @ARGV;

my $safestack = "crypto/stack/safestack";



my $do_write;

while (@ARGV) {

	my $arg = $ARGV[0];

	if($arg eq "-recurse") {

		$recurse = 1;

		shift @ARGV;

	} else {

		last;

	if($arg eq "-write") {

		$do_write = 1;

	}

	shift @ARGV;

}



if($recurse) {

	@source = (<crypto/*.[ch]>, <crypto/*/*.[ch]>, <rsaref/*.[ch]>, <ssl/*.[ch]>);

} else {

	@source = @ARGV;

}



@source = (<crypto/*.[ch]>, <crypto/*/*.[ch]>, <rsaref/*.[ch]>, <ssl/*.[ch]>);

foreach $file (@source) {

	# After "Configure" has been run, we need to make sure we don't

	# overwrite symbollic links with new header files!

	next if -l $file;



	# Open the .c/.h file for reading
@@ -49,58 +34,66 @@ foreach $file (@source) { 
		}

	}

	close(IN);

	write_defines("crypto/stack/safestack");

	unlink("crypto/stack/safestack.h");

	rename("crypto/stack/safestack.tmp","crypto/stack/safestack.h");

}



sub write_defines {



	my $stackfile = $_[0];

my $old_stackfile = "";

my $new_stackfile = "";

my $inside_block = 0;

	open IN, "< $stackfile.h" || die "Can't open input file";

	open OUT, "> $stackfile.tmp" || die "Can't open output file";

my $type_thing;



open(IN, "< $safestack.h") || die "Can't open input file: $!";

while(<IN>) {

		if (m|^/\* This block of defines is updated by a perl script, please do not touch! \*/|) {

	$old_stackfile .= $_;



	if (m|^/\* This block of defines is updated by util/mkstack.pl, please do not touch! \*/|) {

		$inside_block = 1;

	}

		if (m|^/\* End of perl script block, you may now edit :-\) \*/|) {

	if (m|^/\* End of util/mkstack.pl block, you may now edit :-\) \*/|) {

		$inside_block = 0;

	} elsif ($inside_block == 0) {

			print OUT;

		$new_stackfile .= $_;

	}

	next if($inside_block != 1);

		print OUT <<EOF;

/* This block of defines is updated by a perl script, please do not touch! */

EOF

	$new_stackfile .= "/* This block of defines is updated by util/mkstack.pl, please do not touch! */";

		

	foreach $type_thing (@stacklst) {

print OUT <<EOF;

	#define sk_${type_thing}_new(a) SKM_sk_new($type_thing, (a))

	#define sk_${type_thing}_new_null() SKM_sk_new_null($type_thing)

	#define sk_${type_thing}_free(a) SKM_sk_free($type_thing, (a))

	#define sk_${type_thing}_num(a) SKM_sk_num($type_thing, (a))

	#define sk_${type_thing}_value(a,b) SKM_sk_value($type_thing, (a), (b))

	#define sk_${type_thing}_set(a,b,c) SKM_sk_set($type_thing, (a), (b), (c))

	#define sk_${type_thing}_zero(a) SKM_sk_zero($type_thing, (a))

	#define sk_${type_thing}_push(a,b) SKM_sk_push($type_thing, (a),(b))

	#define sk_${type_thing}_unshift(a,b) SKM_sk_unshift($type_thing, (a),(b))

	#define sk_${type_thing}_find(a,b) SKM_sk_find($type_thing, (a), (b))

	#define sk_${type_thing}_delete(a,b) SKM_sk_delete($type_thing, (a),(b))

	#define sk_${type_thing}_delete_ptr(a,b) SKM_sk_delete_ptr($type_thing, (a),(b))

	#define sk_${type_thing}_insert(a,b,c) SKM_sk_insert($type_thing, (a),(b),(c))

	#define sk_${type_thing}_set_cmp_func(a,b) SKM_sk_set_cmp_func($type_thing, (a),(b))

	#define sk_${type_thing}_dup(a) SKM_sk_dup($type_thing, a)

	#define sk_${type_thing}_pop_free(a,b) SKM_sk_pop_free($type_thing, (a),(b))

	#define sk_${type_thing}_shift(a) SKM_sk_shift($type_thing, (a))

	#define sk_${type_thing}_pop(a) SKM_sk_pop($type_thing, (a))

	#define sk_${type_thing}_sort(a) SKM_sk_sort($type_thing, (a))

		$new_stackfile .= <<EOF;



#define sk_${type_thing}_new(st) SKM_sk_new($type_thing, (st))

#define sk_${type_thing}_new_null() SKM_sk_new_null($type_thing)

#define sk_${type_thing}_free(st) SKM_sk_free($type_thing, (st))

#define sk_${type_thing}_num(st) SKM_sk_num($type_thing, (st))

#define sk_${type_thing}_value(st, i) SKM_sk_value($type_thing, (st), (i))

#define sk_${type_thing}_set(st, i, val) SKM_sk_set($type_thing, (st), (i), (val))

#define sk_${type_thing}_zero(st) SKM_sk_zero($type_thing, (st))

#define sk_${type_thing}_push(st, val) SKM_sk_push($type_thing, (st), (val))

#define sk_${type_thing}_unshift(st, val) SKM_sk_unshift($type_thing, (st), (val))

#define sk_${type_thing}_find(st, val) SKM_sk_find($type_thing, (st), (val))

#define sk_${type_thing}_delete(st, i) SKM_sk_delete($type_thing, (st), (i))

#define sk_${type_thing}_delete_ptr(st, ptr) SKM_sk_delete_ptr($type_thing, (st), (ptr))

#define sk_${type_thing}_insert(st, val, i) SKM_sk_insert($type_thing, (st), (val), (i))

#define sk_${type_thing}_set_cmp_func(st, cmp) SKM_sk_set_cmp_func($type_thing, (st), (cmp))

#define sk_${type_thing}_dup(st) SKM_sk_dup($type_thing, st)

#define sk_${type_thing}_pop_free(st, free_func) SKM_sk_pop_free($type_thing, (st), (free_func))

#define sk_${type_thing}_shift(st) SKM_sk_shift($type_thing, (st))

#define sk_${type_thing}_pop(st) SKM_sk_pop($type_thing, (st))

#define sk_${type_thing}_sort(st) SKM_sk_sort($type_thing, (st))

EOF

	}

print OUT <<EOF;

/* End of perl script block, you may now edit :-) */

EOF

	$new_stackfile .= "/* End of util/mkstack.pl block, you may now edit :-) */\n";

	$inside_block = 2;

}





if ($new_stackfile eq $old_stackfile) {

	print "No changes to $safestack.h.\n";

	exit 0; # avoid unnecessary rebuild

}



if ($do_write) {

	print "Writing new $safestack.h.\n";

	open OUT, ">$safestack.h" || die "Can't open output file";

	print OUT $new_stackfile;

	close OUT;

}