util/mkstack.pl now generates entire safestack.h

The mkstack.pl script now generates the entire safestack.h file.
It generates output that follows the coding style.
Also, removed all instances of the obsolete IMPLEMENT_STACK_OF
macro.

Reviewed-by: Andy Polyakov <appro@openssl.org>

crypto/asn1/a_int.c

@@ -455,6 +455,4 @@ BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
     return (ret);
 }
 
-IMPLEMENT_STACK_OF(ASN1_INTEGER)
-
 IMPLEMENT_ASN1_SET_OF(ASN1_INTEGER)

crypto/asn1/a_object.c

@@ -400,6 +400,4 @@ ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
     return (OBJ_dup(&o));
 }
 
-IMPLEMENT_STACK_OF(ASN1_OBJECT)
-
 IMPLEMENT_ASN1_SET_OF(ASN1_OBJECT)

crypto/asn1/a_strnid.c

@@ -302,8 +302,6 @@ static void st_free(ASN1_STRING_TABLE *tbl)
 }
 
 
-IMPLEMENT_STACK_OF(ASN1_STRING_TABLE)
-
 #ifdef STRING_TABLE_TEST
 
 main()

crypto/asn1/a_type.c

@@ -103,8 +103,6 @@ int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value)
     return 1;
 }
 
-IMPLEMENT_STACK_OF(ASN1_TYPE)
-
 IMPLEMENT_ASN1_SET_OF(ASN1_TYPE)
 
 /* Returns 0 if they are equal, != 0 otherwise. */

crypto/asn1/asn_mime.c

@@ -78,7 +78,6 @@ typedef struct {
 } MIME_PARAM;
 
 DECLARE_STACK_OF(MIME_PARAM)
-IMPLEMENT_STACK_OF(MIME_PARAM)
 
 typedef struct {
     char *name;                 /* Name of line e.g. "content-type" */
@@ -87,7 +86,6 @@ typedef struct {
 } MIME_HEADER;
 
 DECLARE_STACK_OF(MIME_HEADER)
-IMPLEMENT_STACK_OF(MIME_HEADER)
 
 static int asn1_output_data(BIO *out, BIO *data, ASN1_VALUE *val, int flags,
                             const ASN1_ITEM *it);

crypto/asn1/x_algor.c

@@ -74,8 +74,6 @@ ASN1_ITEM_TEMPLATE_END(X509_ALGORS)
 IMPLEMENT_ASN1_FUNCTIONS(X509_ALGOR)
 IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(X509_ALGORS, X509_ALGORS, X509_ALGORS)
 IMPLEMENT_ASN1_DUP_FUNCTION(X509_ALGOR)
-
-IMPLEMENT_STACK_OF(X509_ALGOR)
 IMPLEMENT_ASN1_SET_OF(X509_ALGOR)
 
 int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)

crypto/asn1/x_crl.c

@@ -506,10 +506,6 @@ void *X509_CRL_get_meth_data(X509_CRL *crl)
     return crl->meth_data;
 }
 
-IMPLEMENT_STACK_OF(X509_REVOKED)
-
 IMPLEMENT_ASN1_SET_OF(X509_REVOKED)
 
-IMPLEMENT_STACK_OF(X509_CRL)
-
 IMPLEMENT_ASN1_SET_OF(X509_CRL)

crypto/asn1/x_info.c

@@ -113,5 +113,3 @@ void X509_INFO_free(X509_INFO *x)
         OPENSSL_free(x->enc_data);
     OPENSSL_free(x);
 }
-
-IMPLEMENT_STACK_OF(X509_INFO)

crypto/asn1/x_name.c

@@ -522,6 +522,4 @@ int X509_NAME_set(X509_NAME **xn, X509_NAME *name)
     return (*xn != NULL);
 }
 
-IMPLEMENT_STACK_OF(X509_NAME_ENTRY)
-
 IMPLEMENT_ASN1_SET_OF(X509_NAME_ENTRY)

crypto/bio/bio_lib.c

@@ -590,5 +590,3 @@ unsigned long BIO_number_written(BIO *bio)
         return bio->num_write;
     return 0;
 }
-
-IMPLEMENT_STACK_OF(BIO)

crypto/conf/conf_api.c

@@ -279,5 +279,3 @@ CONF_VALUE *_CONF_new_section(CONF *conf, const char *section)
     }
     return (v);
 }
-
-IMPLEMENT_STACK_OF(CONF_VALUE)

crypto/ex_data.c

@@ -640,5 +640,3 @@ void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
     else
         return (sk_void_value(ad->sk, idx));
 }
-
-IMPLEMENT_STACK_OF(CRYPTO_EX_DATA_FUNCS)

crypto/objects/o_names.c

@@ -35,7 +35,6 @@ typedef struct name_funcs_st {
 } NAME_FUNCS;
 
 DECLARE_STACK_OF(NAME_FUNCS)
-IMPLEMENT_STACK_OF(NAME_FUNCS)
 
 static STACK_OF(NAME_FUNCS) *name_funcs_stack;
 

crypto/store/str_lib.c

@@ -1187,8 +1187,6 @@ void STORE_OBJECT_free(STORE_OBJECT *data)
     OPENSSL_free(data);
 }
 
-IMPLEMENT_STACK_OF(STORE_OBJECT*)
-
 struct STORE_attr_info_st {
     unsigned char set[(STORE_ATTR_TYPE_NUM + 8) / 8];
     union {

crypto/ui/ui_lib.c

@@ -65,8 +65,6 @@
 #include <openssl/err.h>
 #include "ui_locl.h"
 
-IMPLEMENT_STACK_OF(UI_STRING_ST)
-
 static const UI_METHOD *default_UI_meth = NULL;
 
 UI *UI_new(void)

crypto/x509/x509_ext.c

@@ -206,6 +206,4 @@ int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
     return X509V3_add1_i2d(&x->extensions, nid, value, crit, flags);
 }
 
-IMPLEMENT_STACK_OF(X509_EXTENSION)
-
 IMPLEMENT_ASN1_SET_OF(X509_EXTENSION)

crypto/x509/x509_lu.c

@@ -717,7 +717,3 @@ X509_STORE *X509_STORE_CTX_get0_store(X509_STORE_CTX *ctx)
 {
     return ctx->ctx;
 }
-
-IMPLEMENT_STACK_OF(X509_LOOKUP)
-
-IMPLEMENT_STACK_OF(X509_OBJECT)

crypto/x509/x509_trs.c

@@ -96,8 +96,6 @@ static X509_TRUST trstandard[] = {
 
 #define X509_TRUST_COUNT        (sizeof(trstandard)/sizeof(X509_TRUST))
 
-IMPLEMENT_STACK_OF(X509_TRUST)
-
 static STACK_OF(X509_TRUST) *trtable = NULL;
 
 static int tr_cmp(const X509_TRUST *const *a, const X509_TRUST *const *b)

crypto/x509/x509_vfy.c

@@ -2403,12 +2403,6 @@ void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
     ctx->param = param;
 }
 
-IMPLEMENT_STACK_OF(X509)
-
 IMPLEMENT_ASN1_SET_OF(X509)
 
-IMPLEMENT_STACK_OF(X509_NAME)
-
-IMPLEMENT_STACK_OF(X509_ATTRIBUTE)
-
 IMPLEMENT_ASN1_SET_OF(X509_ATTRIBUTE)

crypto/x509v3/v3_cpols.c

@@ -472,8 +472,3 @@ void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent)
     else
         BIO_printf(out, "%*sNo Qualifiers\n", indent + 2, "");
 }
-
-
-IMPLEMENT_STACK_OF(X509_POLICY_NODE)
-
-IMPLEMENT_STACK_OF(X509_POLICY_DATA)

crypto/x509v3/v3_crld.c

@@ -341,8 +341,6 @@ static void *v2i_crld(const X509V3_EXT_METHOD *method,
     return NULL;
 }
 
-IMPLEMENT_STACK_OF(DIST_POINT)
-
 IMPLEMENT_ASN1_SET_OF(DIST_POINT)
 
 static int dpn_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,

crypto/x509v3/v3_lib.c

@@ -337,5 +337,3 @@ int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) **x, int nid, void *value,
         X509V3err(X509V3_F_X509V3_ADD1_I2D, errcode);
     return 0;
 }
-
-IMPLEMENT_STACK_OF(X509V3_EXT_METHOD)

crypto/x509v3/v3_purp.c

@@ -110,8 +110,6 @@ static X509_PURPOSE xstandard[] = {
 
 #define X509_PURPOSE_COUNT (sizeof(xstandard)/sizeof(X509_PURPOSE))
 
-IMPLEMENT_STACK_OF(X509_PURPOSE)
-
 static STACK_OF(X509_PURPOSE) *xptable = NULL;
 
 static int xp_cmp(const X509_PURPOSE *const *a, const X509_PURPOSE *const *b)

crypto/x509v3/v3_sxnet.c

@@ -268,6 +268,4 @@ ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
     return NULL;
 }
 
-IMPLEMENT_STACK_OF(SXNETID)
-
 IMPLEMENT_ASN1_SET_OF(SXNETID)

ssl/ssl_lib.c

@@ -3599,8 +3599,4 @@ void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
     return ctx->cert->sec_ex;
 }
 
-IMPLEMENT_STACK_OF(SSL_CIPHER)
-
-IMPLEMENT_STACK_OF(SSL_COMP)
-
 IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);

util/mkstack.pl

@@ -1,75 +1,274 @@
 #!/usr/local/bin/perl -w
 
-# This is a utility that searches out "DECLARE_STACK_OF()"
+# Search out "DECLARE_STACK_OF()" # declarations in .h and .c files,
-# declarations in .h and .c files, and updates/creates/replaces
+# and create corresponding macro declarations for crypto/stack/safestack.h.
-# 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 $safestack = "crypto/stack/safestack";
+my $safestack = "crypto/stack/safestack.h";
+my $do_write = 0;
 
-my $do_write;
+foreach ( @ARGV ) {
-while (@ARGV) {
+    $do_write = 1 if $_ eq "-write";
-	my $arg = $ARGV[0];
-	if($arg eq "-write") {
-		$do_write = 1;
-	}
-	shift @ARGV;
 }
 
-
+my @stacklst;
-@source = (<crypto/*.[ch]>, <crypto/*/*.[ch]>, <ssl/*.[ch]>, <apps/*.[ch]>);
+my @sstacklst;
+my @asn1setlst;
+my @p12stklst;
+my @lhashlst;
+my @source = (<crypto/*.[ch]>, <crypto/*/*.[ch]>, <ssl/*.[ch]>, <apps/*.[ch]>);
 foreach $file (@source) {
     next if -l $file;
 
     # Open the .c/.h file for reading
-	open(IN, "< $file") || die "Can't open $file for reading: $!";
+    open(IN, "< $file") || die "Can't open $file for reading, $!";
 
     while(<IN>) {
+        next unless /^DECLARE_/;
         if (/^DECLARE_STACK_OF\(([^)]+)\)/) {
             push @stacklst, $1;
         }
-	        if (/^DECLARE_SPECIAL_STACK_OF\(([^,\s]+)\s*,\s*([^>\s]+)\)/) {
+        elsif (/^DECLARE_SPECIAL_STACK_OF\(([^,\s]+)\s*,\s*([^>\s]+)\)/) {
             push @sstacklst, [$1, $2];
         }
-		if (/^DECLARE_ASN1_SET_OF\(([^)]+)\)/) {
+        elsif (/^DECLARE_ASN1_SET_OF\(([^)]+)\)/) {
             push @asn1setlst, $1;
         }
-		if (/^DECLARE_PKCS12_STACK_OF\(([^)]+)\)/) {
+        elsif (/^DECLARE_PKCS12_STACK_OF\(([^)]+)\)/) {
             push @p12stklst, $1;
         }
-		if (/^DECLARE_LHASH_OF\(([^)]+)\)/) {
+        elsif (/^DECLARE_LHASH_OF\(([^)]+)\)/) {
             push @lhashlst, $1;
         }
     }
     close(IN);
 }
 
+my $new_stackfile = <<'EOF';
+/* automatically generated by util/mkstack.pl */
+/* ====================================================================
+ * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
+ *
+ * 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 above 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 acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED 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 OpenSSL PROJECT OR
+ * ITS 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.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
+#ifndef HEADER_SAFESTACK_H
+# define HEADER_SAFESTACK_H
+
+# include <openssl/stack.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+# ifndef CHECKED_PTR_OF
+#  define CHECKED_PTR_OF(type, p) ((void*) (1 ? p : (type*)0))
+# endif
+
+/*
+ * In C++ we get problems because an explicit cast is needed from (void *) we
+ * use CHECKED_STACK_OF to ensure the correct type is passed in the macros
+ * below.
+ */
+
+# define CHECKED_STACK_OF(type, p) \
+    ((_STACK*) (1 ? p : (STACK_OF(type)*)0))
+
+# define CHECKED_SK_COPY_FUNC(type, p) \
+    ((void *(*)(void *)) ((1 ? p : (type *(*)(const type *))0)))
+
+# define CHECKED_SK_FREE_FUNC(type, p) \
+    ((void (*)(void *)) ((1 ? p : (void (*)(type *))0)))
+
+# define CHECKED_SK_CMP_FUNC(type, p) \
+    ((int (*)(const void *, const void *)) \
+        ((1 ? p : (int (*)(const type * const *, const type * const *))0)))
+
+# define STACK_OF(type) struct stack_st_##type
+# define PREDECLARE_STACK_OF(type) STACK_OF(type);
+
+# define DECLARE_STACK_OF(type) \
+STACK_OF(type) \
+    { \
+    _STACK stack; \
+    };
+# define DECLARE_SPECIAL_STACK_OF(type, type2) \
+STACK_OF(type) \
+    { \
+    _STACK stack; \
+    };
+
+/*-
+ * Strings are special: normally an lhash entry will point to a single
+ * (somewhat) mutable object. In the case of strings:
+ *
+ * a) Instead of a single char, there is an array of chars, NUL-terminated.
+ * b) The string may have be immutable.
+ *
+ * So, they need their own declarations. Especially important for
+ * type-checking tools, such as Deputy.
+ *
+ * In practice, however, it appears to be hard to have a const
+ * string. For now, I'm settling for dealing with the fact it is a
+ * string at all.
+ */
+typedef char *OPENSSL_STRING;
+typedef const char *OPENSSL_CSTRING;
+
+/*-
+ * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
+ * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
+ * above, instead of a single char each entry is a NUL-terminated array of
+ * chars. So, we have to implement STRING specially for STACK_OF. This is
+ * dealt with in the autogenerated macros below.
+ */
+DECLARE_SPECIAL_STACK_OF(OPENSSL_STRING, char)
+
+/*
+ * Similarly, we sometimes use a block of characters, NOT nul-terminated.
+ * These should also be distinguished from "normal" stacks.
+ */
+typedef void *OPENSSL_BLOCK;
+DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
+
+/*
+ * This file is automatically generated by util/mkstack.pl
+ * Do not edit!
+ */
+
+/*
+ * SKM_sk_... stack macros are internal to safestack.h: never use them
+ * directly, use sk_<type>_... instead
+ */
+# define SKM_sk_new(type, cmp) \
+        ((STACK_OF(type) *)sk_new(CHECKED_SK_CMP_FUNC(type, cmp)))
+# define SKM_sk_new_null(type) \
+        ((STACK_OF(type) *)sk_new_null())
+# define SKM_sk_free(type, st) \
+        sk_free(CHECKED_STACK_OF(type, st))
+# define SKM_sk_num(type, st) \
+        sk_num(CHECKED_STACK_OF(type, st))
+# define SKM_sk_value(type, st,i) \
+        ((type *)sk_value(CHECKED_STACK_OF(type, st), i))
+# define SKM_sk_set(type, st,i,val) \
+        sk_set(CHECKED_STACK_OF(type, st), i, CHECKED_PTR_OF(type, val))
+# define SKM_sk_zero(type, st) \
+        sk_zero(CHECKED_STACK_OF(type, st))
+# define SKM_sk_push(type, st, val) \
+        sk_push(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val))
+# define SKM_sk_unshift(type, st, val) \
+        sk_unshift(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val))
+# define SKM_sk_find(type, st, val) \
+        sk_find(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val))
+# define SKM_sk_find_ex(type, st, val) \
+        sk_find_ex(CHECKED_STACK_OF(type, st), \
+                   CHECKED_PTR_OF(type, val))
+# define SKM_sk_delete(type, st, i) \
+        (type *)sk_delete(CHECKED_STACK_OF(type, st), i)
+# define SKM_sk_delete_ptr(type, st, ptr) \
+        (type *)sk_delete_ptr(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, ptr))
+# define SKM_sk_insert(type, st,val, i) \
+        sk_insert(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val), i)
+# define SKM_sk_set_cmp_func(type, st, cmp) \
+        ((int (*)(const type * const *,const type * const *)) \
+        sk_set_cmp_func(CHECKED_STACK_OF(type, st), CHECKED_SK_CMP_FUNC(type, cmp)))
+# define SKM_sk_dup(type, st) \
+        (STACK_OF(type) *)sk_dup(CHECKED_STACK_OF(type, st))
+# define SKM_sk_pop_free(type, st, free_func) \
+        sk_pop_free(CHECKED_STACK_OF(type, st), CHECKED_SK_FREE_FUNC(type, free_func))
+# define SKM_sk_deep_copy(type, st, copy_func, free_func) \
+        (STACK_OF(type) *)sk_deep_copy(CHECKED_STACK_OF(type, st), CHECKED_SK_COPY_FUNC(type, copy_func), CHECKED_SK_FREE_FUNC(type, free_func))
+# define SKM_sk_shift(type, st) \
+        (type *)sk_shift(CHECKED_STACK_OF(type, st))
+# define SKM_sk_pop(type, st) \
+        (type *)sk_pop(CHECKED_STACK_OF(type, st))
+# define SKM_sk_sort(type, st) \
+        sk_sort(CHECKED_STACK_OF(type, st))
+# define SKM_sk_is_sorted(type, st) \
+        sk_is_sorted(CHECKED_STACK_OF(type, st))
+
+# define SKM_ASN1_SET_OF_d2i(type, st, pp, length, d2i_func, free_func, ex_tag, ex_class) \
+  (STACK_OF(type) *)d2i_ASN1_SET( \
+                                (STACK_OF(OPENSSL_BLOCK) **)CHECKED_PTR_OF(STACK_OF(type)*, st), \
+                                pp, length, \
+                                CHECKED_D2I_OF(type, d2i_func), \
+                                CHECKED_SK_FREE_FUNC(type, free_func), \
+                                ex_tag, ex_class)
+# define SKM_ASN1_SET_OF_i2d(type, st, pp, i2d_func, ex_tag, ex_class, is_set) \
+        i2d_ASN1_SET(CHECKED_STACK_OF(type, st), pp, \
+                                CHECKED_I2D_OF(type, i2d_func), \
+                                ex_tag, ex_class, is_set)
+
+# define SKM_ASN1_seq_pack(type, st, i2d_func, buf, len) \
+        ASN1_seq_pack(CHECKED_PTR_OF(STACK_OF(type), st), \
+                        CHECKED_I2D_OF(type, i2d_func), buf, len)
+# define SKM_ASN1_seq_unpack(type, buf, len, d2i_func, free_func) \
+        (STACK_OF(type) *)ASN1_seq_unpack(buf, \
+                              len, CHECKED_D2I_OF(type, d2i_func), \
+                              CHECKED_SK_FREE_FUNC(type, free_func))
+# define SKM_PKCS12_decrypt_d2i(type, algor, d2i_func, free_func, pass, passlen, oct, seq) \
+        (STACK_OF(type) *)PKCS12_decrypt_d2i(algor, \
+                                CHECKED_D2I_OF(type, d2i_func), \
+                                CHECKED_SK_FREE_FUNC(type, free_func), \
+                                pass, passlen, oct, seq)
+EOF
+
+my $old_stackfile;
+{
+    local $/ = undef;
+    open(IN, "$safestack") || die "Can't open $safestack, $!";
+    $old_stackfile = <IN>;
+    close(IN);
+}
 
-my $old_stackfile = "";
-my $new_stackfile = "";
-my $inside_block = 0;
 my $type_thing;
-
-open(IN, "< $safestack.h") || die "Can't open input file: $!";
-while(<IN>) {
-	$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 util/mkstack.pl block, you may now edit :-\) \*/|) {
-		$inside_block = 0;
-	} elsif ($inside_block == 0) {
-		$new_stackfile .= $_;
-	}
-	next if($inside_block != 1);
-	$new_stackfile .= "/* This block of defines is updated by util/mkstack.pl, please do not touch! */";
-		
 foreach $type_thing (sort @stacklst) {
     $new_stackfile .= <<EOF;
 
@@ -127,7 +326,6 @@ EOF
 # define sk_${t1}_pop(st) ($t2 *)sk_pop(CHECKED_STACK_OF($t1, st))
 # define sk_${t1}_sort(st) SKM_sk_sort($t1, (st))
 # define sk_${t1}_is_sorted(st) SKM_sk_is_sorted($t1, (st))
-
 EOF
 }
 
@@ -144,6 +342,7 @@ EOF
         SKM_ASN1_seq_unpack($type_thing, (buf), (len), (d2i_func), (free_func))
 EOF
 }
+
 foreach $type_thing (sort @p12stklst) {
     $new_stackfile .= <<EOF;
 
@@ -176,19 +375,22 @@ EOF
 EOF
 }
 
-	$new_stackfile .= "/* End of util/mkstack.pl block, you may now edit :-) */\n";
+$new_stackfile .= <<'EOF';
-	$inside_block = 2;
-}
 
+# ifdef  __cplusplus
+}
+# endif
+#endif
+EOF
 
 if ($new_stackfile eq $old_stackfile) {
-	print "No changes to $safestack.h.\n";
+    print "No changes to $safestack.\n";
-	exit 0; # avoid unnecessary rebuild
 }
-
+elsif ($do_write) {
-if ($do_write) {
+    print "Writing new $safestack.\n";
-	print "Writing new $safestack.h.\n";
+    open OUT, ">$safestack" || die "Can't open $safestack for writing, $!";
-	open OUT, ">$safestack.h" || die "Can't open output file";
     print OUT $new_stackfile;
     close OUT;
 }
+
+exit 0;