wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
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.
This commit is contained in:
Bodo Möller 2000-06-17 23:41:44 +00:00
parent 3aceb94b9e
commit 3f39e5ae6c
3 changed files with 813 additions and 805 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile.org
View file

@ -300,7 +300,7 @@ errors:
perl util/mkerr.pl -recurse -write perl util/mkerr.pl -recurse -write
stacks: stacks:
perl util/mkstack.pl -recurse perl util/mkstack.pl -write
util/libeay.num:: util/libeay.num::
perl util/mkdef.pl crypto update perl util/mkdef.pl crypto update

1481
crypto/stack/safestack.h
View file

File diff suppressed because it is too large Load diff

135
util/mkstack.pl
View file

@ -1,43 +1,28 @@
#!/usr/local/bin/perl -w #!/usr/local/bin/perl -w
#
# This is a utility that searches out "DECLARE_STACK_OF()" # This is a utility that searches out "DECLARE_STACK_OF()"
# declarations in header files, and updates/creates/replaces # declarations in .h and .c files, and updates/creates/replaces
# the corresponding macro declarations that follow it. The # the corresponding macro declarations in crypto/stack/safestack.h.
# reason is that with "DEBUG_SAFESTACK" defined, each type # As it's not generally possible to have macros that generate macros,
# will generate 19 functions, all type-safe variants of the # we need to control this from the "outside", here in this script.
# 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.
# #
# Geoff Thorpe, June, 2000 (with massive Perl-hacking # Geoff Thorpe, June, 2000 (with massive Perl-hacking
# help from Steve Robb) # help from Steve Robb)
my $type_thing; my $safestack = "crypto/stack/safestack";
my $recurse = 0;
my @files = @ARGV;
my $do_write;
while (@ARGV) { while (@ARGV) {
my $arg = $ARGV[0]; my $arg = $ARGV[0];
if($arg eq "-recurse") { if($arg eq "-write") {
$recurse = 1; $do_write = 1;
shift @ARGV;
} else {
last;
} }
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) { 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; next if -l $file;
# Open the .c/.h file for reading # Open the .c/.h file for reading
@ -49,58 +34,66 @@ foreach $file (@source) {
} }
} }
close(IN); 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 $inside_block = 0; my $new_stackfile = "";
open IN, "< $stackfile.h" || die "Can't open input file"; my $inside_block = 0;
open OUT, "> $stackfile.tmp" || die "Can't open output file"; my $type_thing;
while(<IN>) {
if (m|^/\* This block of defines is updated by a perl script, please do not touch! \*/|) { open(IN, "< $safestack.h") || die "Can't open input file: $!";
$inside_block = 1; while(<IN>) {
} $old_stackfile .= $_;
if (m|^/\* End of perl script block, you may now edit :-\) \*/|) {
$inside_block = 0; if (m|^/\* This block of defines is updated by util/mkstack.pl, please do not touch! \*/|) {
} elsif ($inside_block == 0) { $inside_block = 1;
print OUT; }
} if (m|^/\* End of util/mkstack.pl block, you may now edit :-\) \*/|) {
next if($inside_block != 1); $inside_block = 0;
print OUT <<EOF; } elsif ($inside_block == 0) {
/* This block of defines is updated by a perl script, please do not touch! */ $new_stackfile .= $_;
EOF }
next if($inside_block != 1);
$new_stackfile .= "/* This block of defines is updated by util/mkstack.pl, please do not touch! */";
foreach $type_thing (@stacklst) { foreach $type_thing (@stacklst) {
print OUT <<EOF; $new_stackfile .= <<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))
#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 EOF
} }
print OUT <<EOF; $new_stackfile .= "/* End of util/mkstack.pl block, you may now edit :-) */\n";
/* End of perl script block, you may now edit :-) */
EOF
$inside_block = 2; $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; close OUT;
} }