libressl *_namespace.h: adjust *_ALIAS() to require a semicolon

LCRYPTO_ALIAS() and LSSL_ALIAS() contained a trailing semicolon.
This does not conform to style(9), breaks editors and ctags and
(most importantly) my workflow. Fix this by neutering them with
asm("") so that -Wpedantic doesn't complain. There's precedent
in libc's namespace.h

fix suggested by & ok jsing

1 files changed, 24 insertions, 24 deletions

diff --git a/src/lib/libcrypto/x509/x509_genn.c b/src/lib/libcrypto/x509/x509_genn.c
index 395d487f8f..0c03396e0d 100644
--- a/src/lib/libcrypto/x509/x509_genn.c
+++ b/src/lib/libcrypto/x509/x509_genn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_genn.c,v 1.4 2023/02/07 15:46:58 tb Exp $ */
+/* $OpenBSD: x509_genn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -98,28 +98,28 @@ d2i_OTHERNAME(OTHERNAME **a, const unsigned char **in, long len)
         return (OTHERNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &OTHERNAME_it);
 }
-LCRYPTO_ALIAS(d2i_OTHERNAME)
+LCRYPTO_ALIAS(d2i_OTHERNAME);
 
 int
 i2d_OTHERNAME(OTHERNAME *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OTHERNAME_it);
 }
-LCRYPTO_ALIAS(i2d_OTHERNAME)
+LCRYPTO_ALIAS(i2d_OTHERNAME);
 
 OTHERNAME *
 OTHERNAME_new(void)
 {
         return (OTHERNAME *)ASN1_item_new(&OTHERNAME_it);
 }
-LCRYPTO_ALIAS(OTHERNAME_new)
+LCRYPTO_ALIAS(OTHERNAME_new);
 
 void
 OTHERNAME_free(OTHERNAME *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &OTHERNAME_it);
 }
-LCRYPTO_ALIAS(OTHERNAME_free)
+LCRYPTO_ALIAS(OTHERNAME_free);
 
 /* Uses explicit tagging since DIRECTORYSTRING is a CHOICE type */
 static const ASN1_TEMPLATE EDIPARTYNAME_seq_tt[] = {
@@ -156,28 +156,28 @@ d2i_EDIPARTYNAME(EDIPARTYNAME **a, const unsigned char **in, long len)
         return (EDIPARTYNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(d2i_EDIPARTYNAME)
+LCRYPTO_ALIAS(d2i_EDIPARTYNAME);
 
 int
 i2d_EDIPARTYNAME(EDIPARTYNAME *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(i2d_EDIPARTYNAME)
+LCRYPTO_ALIAS(i2d_EDIPARTYNAME);
 
 EDIPARTYNAME *
 EDIPARTYNAME_new(void)
 {
         return (EDIPARTYNAME *)ASN1_item_new(&EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(EDIPARTYNAME_new)
+LCRYPTO_ALIAS(EDIPARTYNAME_new);
 
 void
 EDIPARTYNAME_free(EDIPARTYNAME *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(EDIPARTYNAME_free)
+LCRYPTO_ALIAS(EDIPARTYNAME_free);
 
 static const ASN1_TEMPLATE GENERAL_NAME_ch_tt[] = {
         {
@@ -264,28 +264,28 @@ d2i_GENERAL_NAME(GENERAL_NAME **a, const unsigned char **in, long len)
         return (GENERAL_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(d2i_GENERAL_NAME)
+LCRYPTO_ALIAS(d2i_GENERAL_NAME);
 
 int
 i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(i2d_GENERAL_NAME)
+LCRYPTO_ALIAS(i2d_GENERAL_NAME);
 
 GENERAL_NAME *
 GENERAL_NAME_new(void)
 {
         return (GENERAL_NAME *)ASN1_item_new(&GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAME_new)
+LCRYPTO_ALIAS(GENERAL_NAME_new);
 
 void
 GENERAL_NAME_free(GENERAL_NAME *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAME_free)
+LCRYPTO_ALIAS(GENERAL_NAME_free);
 
 static const ASN1_TEMPLATE GENERAL_NAMES_item_tt = {
         .flags = ASN1_TFLG_SEQUENCE_OF,
@@ -312,35 +312,35 @@ d2i_GENERAL_NAMES(GENERAL_NAMES **a, const unsigned char **in, long len)
         return (GENERAL_NAMES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(d2i_GENERAL_NAMES)
+LCRYPTO_ALIAS(d2i_GENERAL_NAMES);
 
 int
 i2d_GENERAL_NAMES(GENERAL_NAMES *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(i2d_GENERAL_NAMES)
+LCRYPTO_ALIAS(i2d_GENERAL_NAMES);
 
 GENERAL_NAMES *
 GENERAL_NAMES_new(void)
 {
         return (GENERAL_NAMES *)ASN1_item_new(&GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAMES_new)
+LCRYPTO_ALIAS(GENERAL_NAMES_new);
 
 void
 GENERAL_NAMES_free(GENERAL_NAMES *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAMES_free)
+LCRYPTO_ALIAS(GENERAL_NAMES_free);
 
 GENERAL_NAME *
 GENERAL_NAME_dup(GENERAL_NAME *a)
 {
         return ASN1_item_dup(&GENERAL_NAME_it, a);
 }
-LCRYPTO_ALIAS(GENERAL_NAME_dup)
+LCRYPTO_ALIAS(GENERAL_NAME_dup);
 
 static int
 EDIPARTYNAME_cmp(const EDIPARTYNAME *a, const EDIPARTYNAME *b)
@@ -415,7 +415,7 @@ GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b)
         }
         return result;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_cmp)
+LCRYPTO_ALIAS(GENERAL_NAME_cmp);
 
 /* Returns 0 if they are equal, != 0 otherwise. */
 int
@@ -432,7 +432,7 @@ OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b)
         result = ASN1_TYPE_cmp(a->value, b->value);
         return result;
 }
-LCRYPTO_ALIAS(OTHERNAME_cmp)
+LCRYPTO_ALIAS(OTHERNAME_cmp);
 
 void
 GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
@@ -470,7 +470,7 @@ GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
         }
         a->type = type;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_set0_value)
+LCRYPTO_ALIAS(GENERAL_NAME_set0_value);
 
 void *
 GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
@@ -505,7 +505,7 @@ GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
                 return NULL;
         }
 }
-LCRYPTO_ALIAS(GENERAL_NAME_get0_value)
+LCRYPTO_ALIAS(GENERAL_NAME_get0_value);
 
 int
 GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
@@ -521,7 +521,7 @@ GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
         GENERAL_NAME_set0_value(gen, GEN_OTHERNAME, oth);
         return 1;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_set0_othername)
+LCRYPTO_ALIAS(GENERAL_NAME_set0_othername);
 
 int
 GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
@@ -535,4 +535,4 @@ GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
                 *pvalue = gen->d.otherName->value;
         return 1;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName)
+LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName);