From d9bd775af15aa7eacaea301de8344053221b3ba3 Mon Sep 17 00:00:00 2001
From: Lev Walkin <vlm@lionet.info>
Date: Sat, 5 Jun 2004 08:17:50 +0000
Subject: [PATCH] enforsed compilation with -W -Werror

---
 asn1c/tests/check-22.c         | 14 ++++++---
 asn1c/tests/check-24.c         |  5 +++-
 asn1c/tests/check-25.c         | 15 ++++++----
 asn1c/tests/check-30.c         |  5 +++-
 asn1c/tests/check-31.c         |  5 +++-
 asn1c/tests/check-32.c         |  3 ++
 asn1c/tests/check-33.c         |  3 ++
 asn1c/tests/check-35.c         |  5 +++-
 asn1c/tests/check-41.c         |  5 +++-
 asn1c/tests/check-43.c         |  3 ++
 libasn1compiler/asn1c_misc.c   |  2 ++
 libasn1compiler/asn1c_save.c   |  2 ++
 libasn1compiler/asn1compiler.c |  4 +--
 libasn1fix/asn1fix_class.c     |  2 ++
 libasn1fix/asn1fix_integer.c   |  2 +-
 libasn1fix/asn1fix_misc.c      |  6 ++--
 libasn1parser/asn1p_expr_str.h | 14 ++++-----
 libasn1parser/asn1p_ref.c      |  3 +-
 libasn1print/asn1print.c       |  6 ++++
 skeletons/BIT_STRING.c         |  2 ++
 skeletons/BMPString.c          |  4 +++
 skeletons/BOOLEAN.c            | 10 +++++--
 skeletons/ENUMERATED.c         |  3 +-
 skeletons/GeneralString.c      |  1 +
 skeletons/GeneralizedTime.c    |  6 +++-
 skeletons/GraphicString.c      |  1 +
 skeletons/IA5String.c          |  1 +
 skeletons/INTEGER.c            | 16 +++++++----
 skeletons/ISO646String.c       |  1 +
 skeletons/NULL.c               |  7 ++++-
 skeletons/NativeEnumerated.c   |  3 +-
 skeletons/NativeInteger.c      | 12 +++++---
 skeletons/NumericString.c      |  1 +
 skeletons/OBJECT_IDENTIFIER.c  | 12 +++++---
 skeletons/OCTET_STRING.c       | 52 +++++++++++++++++++---------------
 skeletons/ObjectDescriptor.c   |  1 +
 skeletons/PrintableString.c    |  1 +
 skeletons/RELATIVE-OID.c       |  6 +++-
 skeletons/T61String.c          |  1 +
 skeletons/TeletexString.c      |  1 +
 skeletons/UTCTime.c            |  9 ++++--
 skeletons/UTF8String.c         |  4 +++
 skeletons/UniversalString.c    |  4 +++
 skeletons/VideotexString.c     |  1 +
 skeletons/VisibleString.c      |  1 +
 skeletons/ber_decoder.c        |  2 +-
 skeletons/ber_tlv_length.c     |  6 ++--
 skeletons/ber_tlv_tag.c        |  6 ++--
 skeletons/constr_CHOICE.c      |  4 +--
 skeletons/constr_SEQUENCE.c    |  4 +--
 skeletons/constr_SEQUENCE_OF.c |  2 +-
 skeletons/constr_SET.c         |  4 +--
 skeletons/constr_SET_OF.c      | 10 +++----
 skeletons/constraints.c        | 16 +++++++++--
 skeletons/der_encoder.c        |  2 +-
 55 files changed, 223 insertions(+), 98 deletions(-)

diff --git a/asn1c/tests/check-22.c b/asn1c/tests/check-22.c
index c80f9881..02227822 100644
--- a/asn1c/tests/check-22.c
+++ b/asn1c/tests/check-22.c
@@ -32,6 +32,9 @@ int buf2_pos;
 
 static int
 buf2_fill(const void *buffer, size_t size, void *app_key) {
+
+	(void)app_key;
+
 	if(buf2_pos + size > sizeof(buf2))
 		return -1;
 
@@ -42,7 +45,7 @@ buf2_fill(const void *buffer, size_t size, void *app_key) {
 }
 
 static void
-check(int is_ok, uint8_t *buf, int size, int consumed) {
+check(int is_ok, uint8_t *buf, int size, size_t consumed) {
 	T1_t t, *tp;
 	ber_dec_rval_t rval;
 	der_enc_rval_t erval;
@@ -57,7 +60,7 @@ check(int is_ok, uint8_t *buf, int size, int consumed) {
 
 	if(is_ok) {
 		assert(rval.code == RC_OK);
-		assert(rval.consumed == consumed);
+		assert(rval.consumed == (size_t)consumed);
 		assert(t.a.size == 2);
 		assert(t.b.present == b_PR_n);
 		assert(t.b.choice.n.size == 1);
@@ -73,7 +76,7 @@ check(int is_ok, uint8_t *buf, int size, int consumed) {
 				|| t.c.size != 1
 			);
 		}
-		assert(rval.consumed <= consumed);
+		assert(rval.consumed <= (size_t)consumed);
 		return;
 	}
 
@@ -89,7 +92,7 @@ check(int is_ok, uint8_t *buf, int size, int consumed) {
 		printf("%d != %d\n", (int)erval.encoded, (int)sizeof(buf1));
 	}
 	assert(erval.encoded == sizeof(buf1));
-	for(i = 0; i < sizeof(buf1); i++) {
+	for(i = 0; i < (ssize_t)sizeof(buf1); i++) {
 		if(buf1[i] != buf2[i]) {
 			fprintf(stderr, "Recreated buffer content mismatch:\n");
 			fprintf(stderr, "Byte %d, %x != %x (%d != %d)\n",
@@ -133,6 +136,9 @@ try_corrupt(uint8_t *buf, int size) {
 int
 main(int ac, char **av) {
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	check(1, buf1, sizeof(buf1), sizeof(buf1));
 	try_corrupt(buf1, sizeof(buf1));
 	check(1, buf1, sizeof(buf1) + 10, sizeof(buf1));
diff --git a/asn1c/tests/check-24.c b/asn1c/tests/check-24.c
index b74ca165..79de9115 100644
--- a/asn1c/tests/check-24.c
+++ b/asn1c/tests/check-24.c
@@ -34,7 +34,7 @@ uint8_t buf1[] = {
 };
 
 static void
-check(int is_ok, uint8_t *buf, int size, int consumed) {
+check(int is_ok, uint8_t *buf, int size, size_t consumed) {
 	T_t t, *tp;
 	ber_dec_rval_t rval;
 
@@ -87,6 +87,9 @@ try_corrupt(uint8_t *buf, int size) {
 int
 main(int ac, char **av) {
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	check(1, buf1, sizeof(buf1), sizeof(buf1));
 	try_corrupt(buf1, sizeof(buf1));
 
diff --git a/asn1c/tests/check-25.c b/asn1c/tests/check-25.c
index bd803da3..dad12ae1 100644
--- a/asn1c/tests/check-25.c
+++ b/asn1c/tests/check-25.c
@@ -82,7 +82,7 @@ uint8_t buf1[] = {
 };
 
 static void
-check(int is_ok, uint8_t *buf, int size, int consumed) {
+check(int is_ok, uint8_t *buf, int size, size_t consumed) {
 	T_t t, *tp;
 	ber_dec_rval_t rval;
 
@@ -164,10 +164,10 @@ try_corrupt(uint8_t *buf, int size, int allow_consume) {
 }
 
 static void
-partial_read(uint8_t *buf, int size) {
+partial_read(uint8_t *buf, size_t size) {
 	T_t t, *tp;
 	ber_dec_rval_t rval;
-	int i1, i2;
+	size_t i1, i2;
 	uint8_t *buf1 = alloca(size);
 	uint8_t *buf2 = alloca(size);
 	uint8_t *buf3 = alloca(size);
@@ -183,11 +183,11 @@ partial_read(uint8_t *buf, int size) {
 	for(i1 = 0; i1 < size; i1++) {
 		for(i2 = i1; i2 < size; i2++) {
 			uint8_t *chunk1 = buf;
-			int size1 = i1;
+			size_t size1 = i1;
 			uint8_t *chunk2 = buf + size1;
-			int size2 = i2 - i1;
+			size_t size2 = i2 - i1;
 			uint8_t *chunk3 = buf + size1 + size2;
-			int size3 = size - size1 - size2;
+			size_t size3 = size - size1 - size2;
 
 			fprintf(stderr, "\n%d:{%d, %d, %d}...\n",
 				size, size1, size2, size3);
@@ -239,6 +239,9 @@ partial_read(uint8_t *buf, int size) {
 int
 main(int ac, char **av) {
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	/* Check that the full buffer may be decoded normally */
 	check(1, buf1, sizeof(buf1), sizeof(buf1) - 3);
 
diff --git a/asn1c/tests/check-30.c b/asn1c/tests/check-30.c
index 9e5adf22..4ac52120 100644
--- a/asn1c/tests/check-30.c
+++ b/asn1c/tests/check-30.c
@@ -43,7 +43,7 @@ uint8_t buf2[] = {
 };
 
 static void
-check(int is_ok, uint8_t *buf, int size, int consumed) {
+check(int is_ok, uint8_t *buf, int size, size_t consumed) {
 	T_t t, *tp;
 	ber_dec_rval_t rval;
 
@@ -103,6 +103,9 @@ try_corrupt(uint8_t *buf, int size) {
 int
 main(int ac, char **av) {
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	fprintf(stderr, "Must succeed:\n");
 	check(1, buf1, sizeof(buf1) + 20, sizeof(buf1));
 
diff --git a/asn1c/tests/check-31.c b/asn1c/tests/check-31.c
index 53a90cba..cfebedcd 100644
--- a/asn1c/tests/check-31.c
+++ b/asn1c/tests/check-31.c
@@ -92,7 +92,7 @@ int bytes_compare(const void *bufferp, size_t size, void *key) {
 }
 
 static void
-check(int is_ok, uint8_t *buf, int size, int consumed) {
+check(int is_ok, uint8_t *buf, int size, size_t consumed) {
 	Forest_t t, *tp;
 	ber_dec_rval_t rval;
 
@@ -167,6 +167,9 @@ try_corrupt(uint8_t *buf, int size) {
 int
 main(int ac, char **av) {
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	check(1, buf1, sizeof(buf1), sizeof(buf1));
 	try_corrupt(buf1, sizeof(buf1));
 	check(1, buf1, sizeof(buf1) + 20, sizeof(buf1));
diff --git a/asn1c/tests/check-32.c b/asn1c/tests/check-32.c
index 3cb0fdac..49ad2d60 100644
--- a/asn1c/tests/check-32.c
+++ b/asn1c/tests/check-32.c
@@ -11,6 +11,9 @@ int
 main(int ac, char **av) {
 	Programming_t p;
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	memset(&p, 0, sizeof(p));
 
 	/*
diff --git a/asn1c/tests/check-33.c b/asn1c/tests/check-33.c
index 14f5377a..61638713 100644
--- a/asn1c/tests/check-33.c
+++ b/asn1c/tests/check-33.c
@@ -11,6 +11,9 @@ int
 main(int ac, char **av) {
 	T_t t;
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	memset(&t, 0, sizeof(t));
 
 	/*
diff --git a/asn1c/tests/check-35.c b/asn1c/tests/check-35.c
index 6b6c04d6..f29d877c 100644
--- a/asn1c/tests/check-35.c
+++ b/asn1c/tests/check-35.c
@@ -115,7 +115,7 @@ uint8_t buf2_reconstr[] = {
 };
 
 static void
-check(T_t *tp, uint8_t *buf, int size, int consumed) {
+check(T_t *tp, uint8_t *buf, int size, size_t consumed) {
 	ber_dec_rval_t rval;
 
 	tp = memset(tp, 0, sizeof(*tp));
@@ -260,6 +260,9 @@ int
 main(int ac, char **av) {
 	T_t t;
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1));
 	compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
 	asn_fprint(stderr, &asn1_DEF_T, &t);
diff --git a/asn1c/tests/check-41.c b/asn1c/tests/check-41.c
index c2238cf5..09a9d62a 100644
--- a/asn1c/tests/check-41.c
+++ b/asn1c/tests/check-41.c
@@ -130,7 +130,7 @@ uint8_t buf2_reconstr[] = {
 
 
 static void
-check(T_t *tp, uint8_t *buf, int size, int consumed) {
+check(T_t *tp, uint8_t *buf, int size, size_t consumed) {
 	ber_dec_rval_t rval;
 
 	tp = memset(tp, 0, sizeof(*tp));
@@ -278,6 +278,9 @@ int
 main(int ac, char **av) {
 	T_t t;
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	/* Check exact buf0 */
 	check(&t, buf0, sizeof(buf0), sizeof(buf0));
 	compare(&t, buf0_reconstr, sizeof(buf0_reconstr));
diff --git a/asn1c/tests/check-43.c b/asn1c/tests/check-43.c
index e44218d8..c906f64d 100644
--- a/asn1c/tests/check-43.c
+++ b/asn1c/tests/check-43.c
@@ -13,6 +13,9 @@ main(int ac, char **av) {
 	Test_structure_1_t ts1;
 	Sets_t s1;
 
+	(void)ac;	/* Unused argument */
+	(void)av;	/* Unused argument */
+
 	memset(&ts1, 0, sizeof(ts1));
 	memset(&s1, 0, sizeof(s1));
 
diff --git a/libasn1compiler/asn1c_misc.c b/libasn1compiler/asn1c_misc.c
index b464b64c..257e02c5 100644
--- a/libasn1compiler/asn1c_misc.c
+++ b/libasn1compiler/asn1c_misc.c
@@ -94,6 +94,8 @@ asn1c_open_file(arg_t *arg, const char *name, const char *ext) {
 	FILE *fp;
 	int fd;
 
+	(void)arg;	/* Unused argument */
+
 	/*
 	 * Compute filenames.
 	 */
diff --git a/libasn1compiler/asn1c_save.c b/libasn1compiler/asn1c_save.c
index 8aab8c42..5e425d65 100644
--- a/libasn1compiler/asn1c_save.c
+++ b/libasn1compiler/asn1c_save.c
@@ -208,6 +208,8 @@ static int
 asn1c_copy_over(arg_t *arg, char *path) {
 	char *fname = basename(path);
 
+	(void)arg;	/* Unused argument */
+
 	if(symlink(path, fname)) {
 		if(errno == EEXIST) {
 			struct stat sb1, sb2;
diff --git a/libasn1compiler/asn1compiler.c b/libasn1compiler/asn1compiler.c
index d647c05b..24e539a0 100644
--- a/libasn1compiler/asn1compiler.c
+++ b/libasn1compiler/asn1compiler.c
@@ -65,9 +65,9 @@ asn1c_compile_expr(arg_t *arg) {
 	int (*type_cb)(arg_t *);
 	int ret;
 
-	assert(expr->meta_type >= AMT_INVALID);
+	assert((int)expr->meta_type >= AMT_INVALID);
 	assert(expr->meta_type < AMT_EXPR_META_MAX);
-	assert(expr->expr_type >= A1TC_INVALID);
+	assert((int)expr->expr_type >= A1TC_INVALID);
 	assert(expr->expr_type < ASN_EXPR_TYPE_MAX);
 
 	type_cb = asn1_lang_map[expr->meta_type][expr->expr_type].type_cb;
diff --git a/libasn1fix/asn1fix_class.c b/libasn1fix/asn1fix_class.c
index c541fd62..f617c318 100644
--- a/libasn1fix/asn1fix_class.c
+++ b/libasn1fix/asn1fix_class.c
@@ -30,6 +30,8 @@ asn1f_class_access(arg_t *arg, asn1p_ref_t *ref, asn1p_module_t **mod_r) {
 	asn1p_expr_t *result;
 	asn1p_ref_t tmpref;
 
+	(void)mod_r;	/* Unused argument */
+
 	assert(ref->comp_count > 1);
 
 	DEBUG("%s(%s) for line %d", __func__,
diff --git a/libasn1fix/asn1fix_integer.c b/libasn1fix/asn1fix_integer.c
index 514ab70e..c3a2a7b0 100644
--- a/libasn1fix/asn1fix_integer.c
+++ b/libasn1fix/asn1fix_integer.c
@@ -114,7 +114,7 @@ static int
 _asn1f_make_sure_type_is(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_type_e type) {
 	asn1p_module_t *mod = NULL;
 	asn1p_expr_t *next_expr;
-	int expr_type;
+	asn1p_expr_type_e expr_type;
 	int ret;
 
 	expr_type = expr->expr_type;
diff --git a/libasn1fix/asn1fix_misc.c b/libasn1fix/asn1fix_misc.c
index 5fe69034..a9a5378b 100644
--- a/libasn1fix/asn1fix_misc.c
+++ b/libasn1fix/asn1fix_misc.c
@@ -75,13 +75,13 @@ asn1f_printable_value(asn1p_value_t *v) {
 		}
 	case ATV_REAL:
 		ret = snprintf(buf, sizeof(buf), "%f", v->value.v_double);
-		if(ret >= sizeof(buf))
+		if(ret >= (ssize_t)sizeof(buf))
 			memcpy(buf + sizeof(buf) - 4, "...", 4);
 		return buf;
 	case ATV_INTEGER:
 		ret = snprintf(buf, sizeof(buf), "%lld",
 			(long long)v->value.v_integer);
-		if(ret >= sizeof(buf))
+		if(ret >= (ssize_t)sizeof(buf))
 			memcpy(buf + sizeof(buf) - 4, "...", 4);
 		return buf;
 	case ATV_MIN: return "MIN";
@@ -126,7 +126,7 @@ asn1f_printable_value(asn1p_value_t *v) {
 					*ptr++ = ((uc >> (7-(i%8)))&1)?'1':'0';
 				}
 			} else {
-				char hextable[16] = "0123456789ABCDEF";
+				static const char *hextable="0123456789ABCDEF";
 				/*
 				 * Dump byte by byte.
 				 */
diff --git a/libasn1parser/asn1p_expr_str.h b/libasn1parser/asn1p_expr_str.h
index 02de131b..7d98a55c 100644
--- a/libasn1parser/asn1p_expr_str.h
+++ b/libasn1parser/asn1p_expr_str.h
@@ -45,13 +45,13 @@ static char *asn1p_expr_type2str[] __attribute__ ((unused)) = {
 /*
  * Convert the ASN.1 expression type back into the string representation.
  */
-#define	ASN_EXPR_TYPE2STR(type)				\
-	(						\
-	((type) < 0					\
-	|| (type) >= sizeof(asn1p_expr_type2str)	\
-		/ sizeof(asn1p_expr_type2str[0]))	\
-		? (char *)0				\
-		: asn1p_expr_type2str[(type)]		\
+#define	ASN_EXPR_TYPE2STR(type)					\
+	(							\
+	(((ssize_t)type) < 0					\
+	|| ((size_t)type) >= sizeof(asn1p_expr_type2str)	\
+		/ sizeof(asn1p_expr_type2str[0]))		\
+		? (char *)0					\
+		: asn1p_expr_type2str[(type)]			\
 	)
 
 #endif	/* ASN1_PARSER_EXPR_STR_H */
diff --git a/libasn1parser/asn1p_ref.c b/libasn1parser/asn1p_ref.c
index 4ac2b32d..af6f6bb2 100644
--- a/libasn1parser/asn1p_ref.c
+++ b/libasn1parser/asn1p_ref.c
@@ -80,7 +80,8 @@ asn1p_ref_name2lextype(char *name) {
 int
 asn1p_ref_add_component(asn1p_ref_t *ref, char *name, enum asn1p_ref_lex_type_e lex_type) {
 
-	if(!ref || !name || lex_type < RLT_UNKNOWN || lex_type >= RLT_MAX) {
+	if(!ref || !name
+	|| (int)lex_type < RLT_UNKNOWN || lex_type >= RLT_MAX) {
 		errno = EINVAL;
 		return -1;
 	}
diff --git a/libasn1print/asn1print.c b/libasn1print/asn1print.c
index 992dcfa0..8e8049dc 100644
--- a/libasn1print/asn1print.c
+++ b/libasn1print/asn1print.c
@@ -84,6 +84,8 @@ asn1print_oid(asn1p_oid_t *oid, enum asn1print_flags_e flags) {
 	int ac;
 	int accum = 0;
 
+	(void)flags;	/* Unused argument */
+
 	printf("{");
 	for(ac = 0; ac < oid->arcs_count; ac++) {
 		if(accum + strlen(oid->arcs[ac].name?:"") > 50) {
@@ -111,6 +113,8 @@ static int
 asn1print_ref(asn1p_ref_t *ref, enum asn1print_flags_e flags) {
 	int cc;
 
+	(void)flags;	/* Unused argument */
+
 	for(cc = 0; cc < ref->comp_count; cc++) {
 		if(cc) printf(".");
 		printf("%s", ref->components[cc].name);
@@ -123,6 +127,8 @@ static int
 asn1print_tag(asn1p_expr_t *tc, enum asn1print_flags_e flags) {
 	struct asn1p_type_tag_s *tag = &tc->tag;
 
+	(void)flags;	/* Unused argument */
+
 	if(tag->tag_class == TC_NOCLASS)
 		return 0;
 
diff --git a/skeletons/BIT_STRING.c b/skeletons/BIT_STRING.c
index 19b6ff2e..4914b207 100644
--- a/skeletons/BIT_STRING.c
+++ b/skeletons/BIT_STRING.c
@@ -66,6 +66,8 @@ BIT_STRING_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	uint8_t *end;
 	char *p = scratch;
 
+	(void)td;	/* Unused argument */
+
 	if(!st || !st->buf) return cb("<absent>", 8, app_key);
 
 	ilevel += 4;
diff --git a/skeletons/BMPString.c b/skeletons/BMPString.c
index 596974ea..93584c8e 100644
--- a/skeletons/BMPString.c
+++ b/skeletons/BMPString.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_BMPString = {
 	  / sizeof(asn1_DEF_BMPString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 /*
@@ -37,6 +38,9 @@ BMPString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	char scratch[128];			/* Scratchpad buffer */
 	char *p;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(!st || !st->buf) return cb("<absent>", 8, app_key);
 
 	wchar = (uint16_t *)st->buf;
diff --git a/skeletons/BOOLEAN.c b/skeletons/BOOLEAN.c
index 705d37e0..93913168 100644
--- a/skeletons/BOOLEAN.c
+++ b/skeletons/BOOLEAN.c
@@ -21,7 +21,8 @@ asn1_TYPE_descriptor_t asn1_DEF_BOOLEAN = {
 	asn1_DEF_BOOLEAN_tags,
 	sizeof(asn1_DEF_BOOLEAN_tags)/sizeof(asn1_DEF_BOOLEAN_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
 
 /*
@@ -33,7 +34,7 @@ BOOLEAN_decode_ber(asn1_TYPE_descriptor_t *td,
 		int tag_mode) {
 	BOOLEAN_t *st = *bool_structure;
 	ber_dec_rval_t rval;
-	ber_dec_ctx_t ctx = { 0 };
+	ber_dec_ctx_t ctx = { 0, 0, 0, 0 };
 	ber_tlv_len_t length;
 	ber_tlv_len_t lidx;
 
@@ -61,7 +62,7 @@ BOOLEAN_decode_ber(asn1_TYPE_descriptor_t *td,
 
 	buf_ptr += rval.consumed;
 	size -= rval.consumed;
-	if(length > size) {
+	if(length > (ber_tlv_len_t)size) {
 		rval.code = RC_WMORE;
 		rval.consumed = 0;
 		return rval;
@@ -128,6 +129,9 @@ BOOLEAN_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	asn_app_consume_bytes_f *cb, void *app_key) {
 	const BOOLEAN_t *st = sptr;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(st) {
 		if(st->value)
 			return cb("TRUE", 4, app_key);
diff --git a/skeletons/ENUMERATED.c b/skeletons/ENUMERATED.c
index 1f1ae896..3fff3682 100644
--- a/skeletons/ENUMERATED.c
+++ b/skeletons/ENUMERATED.c
@@ -21,6 +21,7 @@ asn1_TYPE_descriptor_t asn1_DEF_ENUMERATED = {
 	asn1_DEF_ENUMERATED_tags,
 	sizeof(asn1_DEF_ENUMERATED_tags)/sizeof(asn1_DEF_ENUMERATED_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Primitive */
+	0,	/* Primitive */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/GeneralString.c b/skeletons/GeneralString.c
index d69c5f16..6bc7e478 100644
--- a/skeletons/GeneralString.c
+++ b/skeletons/GeneralString.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_GeneralString = {
 	  / sizeof(asn1_DEF_GeneralString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/GeneralizedTime.c b/skeletons/GeneralizedTime.c
index 01d7a736..1dadb92d 100644
--- a/skeletons/GeneralizedTime.c
+++ b/skeletons/GeneralizedTime.c
@@ -30,6 +30,7 @@ asn1_TYPE_descriptor_t asn1_DEF_GeneralizedTime = {
 	  / sizeof(asn1_DEF_GeneralizedTime_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 #endif	/* __NO_ASN_TABLE__ */
@@ -59,6 +60,9 @@ GeneralizedTime_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	asn_app_consume_bytes_f *cb, void *app_key) {
 	const GeneralizedTime_t *st = sptr;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(st && st->buf) {
 		char buf[32];
 		struct tm tm;
@@ -72,7 +76,7 @@ GeneralizedTime_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 			"%04d-%02d-%02d %02d:%02d%02d",
 			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 			tm.tm_hour, tm.tm_min, tm.tm_sec);
-		assert(ret > 0 && ret < sizeof(buf));
+		assert(ret > 0 && ret < (int)sizeof(buf));
 		return cb(buf, ret, app_key);
 	} else {
 		return cb("<absent>", 8, app_key);
diff --git a/skeletons/GraphicString.c b/skeletons/GraphicString.c
index 5c89685e..412f3c74 100644
--- a/skeletons/GraphicString.c
+++ b/skeletons/GraphicString.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_GraphicString = {
 	  / sizeof(asn1_DEF_GraphicString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/IA5String.c b/skeletons/IA5String.c
index c4afcb00..902de855 100644
--- a/skeletons/IA5String.c
+++ b/skeletons/IA5String.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_IA5String = {
 	  / sizeof(asn1_DEF_IA5String_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 int
diff --git a/skeletons/INTEGER.c b/skeletons/INTEGER.c
index b1a8c29b..d20379fb 100644
--- a/skeletons/INTEGER.c
+++ b/skeletons/INTEGER.c
@@ -23,7 +23,8 @@ asn1_TYPE_descriptor_t asn1_DEF_INTEGER = {
 	asn1_DEF_INTEGER_tags,
 	sizeof(asn1_DEF_INTEGER_tags)/sizeof(asn1_DEF_INTEGER_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
 
 /*
@@ -34,7 +35,7 @@ INTEGER_decode_ber(asn1_TYPE_descriptor_t *td,
 	void **int_structure, void *buf_ptr, size_t size, int tag_mode) {
 	INTEGER_t *st = *int_structure;
 	ber_dec_rval_t rval;
-	ber_dec_ctx_t ctx = { 0 };
+	ber_dec_ctx_t ctx = { 0, 0, 0, 0 };
 	ber_tlv_len_t length;
 
 	/*
@@ -67,7 +68,7 @@ INTEGER_decode_ber(asn1_TYPE_descriptor_t *td,
 	 */
 	buf_ptr += rval.consumed;
 	size -= rval.consumed;
-	if(length > size) {
+	if(length > (ber_tlv_len_t)size) {
 		rval.code = RC_WMORE;
 		rval.consumed = 0;
 		return rval;
@@ -193,25 +194,28 @@ INTEGER_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	char *p;
 	int ret;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(!st && !st->buf) return cb("<absent>", 8, app_key);
 
 	if(st->size == 0)
 		return cb("0", 1, app_key);
 
 	/* Simple case: the integer size is small */
-	if(st->size < sizeof(accum) || (st->buf[0] & 0x80)) {
+	if((size_t)st->size < sizeof(accum) || (st->buf[0] & 0x80)) {
 		accum = (st->buf[0] & 0x80) ? -1 : 0;
 		for(; buf < buf_end; buf++)
 			accum = (accum << 8) | *buf;
 		ret = snprintf(scratch, sizeof(scratch), "%ld", accum);
-		assert(ret > 0 && ret < sizeof(scratch));
+		assert(ret > 0 && ret < (int)sizeof(scratch));
 		return cb(scratch, ret, app_key);
 	}
 
 	/* Output in the long xx:yy:zz... format */
 	for(p = scratch; buf < buf_end; buf++) {
 		static char h2c[16] = "0123456789ABCDEF";
-		if((p - scratch) >= (sizeof(scratch) / 2)) {
+		if((p - scratch) >= (ssize_t)(sizeof(scratch) / 2)) {
 			/* Flush buffer */
 			if(cb(scratch, p - scratch, app_key))
 				return -1;
diff --git a/skeletons/ISO646String.c b/skeletons/ISO646String.c
index 08b31698..2df623cf 100644
--- a/skeletons/ISO646String.c
+++ b/skeletons/ISO646String.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_ISO646String = {
 	  / sizeof(asn1_DEF_ISO646String_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/NULL.c b/skeletons/NULL.c
index 9027e2c1..4ea06693 100644
--- a/skeletons/NULL.c
+++ b/skeletons/NULL.c
@@ -22,7 +22,8 @@ asn1_TYPE_descriptor_t asn1_DEF_NULL = {
 	asn1_DEF_NULL_tags,
 	sizeof(asn1_DEF_NULL_tags)/sizeof(asn1_DEF_NULL_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
 
 der_enc_rval_t
@@ -43,6 +44,10 @@ NULL_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr,
 int
 NULL_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	asn_app_consume_bytes_f *cb, void *app_key) {
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(sptr) {
 		return cb("<present>", 9, app_key);
 	} else {
diff --git a/skeletons/NativeEnumerated.c b/skeletons/NativeEnumerated.c
index b6d21ed2..bfb2bff1 100644
--- a/skeletons/NativeEnumerated.c
+++ b/skeletons/NativeEnumerated.c
@@ -28,5 +28,6 @@ asn1_TYPE_descriptor_t asn1_DEF_NativeEnumerated = {
 	asn1_DEF_NativeEnumerated_tags,
 	sizeof(asn1_DEF_NativeEnumerated_tags)/sizeof(asn1_DEF_NativeEnumerated_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
diff --git a/skeletons/NativeInteger.c b/skeletons/NativeInteger.c
index d42540ef..8203695c 100644
--- a/skeletons/NativeInteger.c
+++ b/skeletons/NativeInteger.c
@@ -30,7 +30,8 @@ asn1_TYPE_descriptor_t asn1_DEF_NativeInteger = {
 	asn1_DEF_NativeInteger_tags,
 	sizeof(asn1_DEF_NativeInteger_tags)/sizeof(asn1_DEF_NativeInteger_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
 
 /*
@@ -41,7 +42,7 @@ NativeInteger_decode_ber(asn1_TYPE_descriptor_t *td,
 	void **int_ptr, void *buf_ptr, size_t size, int tag_mode) {
 	int *Int = *int_ptr;
 	ber_dec_rval_t rval;
-	ber_dec_ctx_t ctx = { 0 };
+	ber_dec_ctx_t ctx = { 0, 0, 0, 0 };
 	ber_tlv_len_t length;
 
 	/*
@@ -74,7 +75,7 @@ NativeInteger_decode_ber(asn1_TYPE_descriptor_t *td,
 	 */
 	buf_ptr += rval.consumed;
 	size -= rval.consumed;
-	if(length > size) {
+	if(length > (ber_tlv_len_t)size) {
 		rval.code = RC_WMORE;
 		rval.consumed = 0;
 		return rval;
@@ -168,9 +169,12 @@ NativeInteger_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	char scratch[32];
 	int ret;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(Int) {
 		ret = snprintf(scratch, sizeof(scratch), "%d", *Int);
-		assert(ret > 0 && ret < sizeof(scratch));
+		assert(ret > 0 && ret < (int)sizeof(scratch));
 		return cb(scratch, ret, app_key);
 	} else {
 		return cb("<absent>", 8, app_key);
diff --git a/skeletons/NumericString.c b/skeletons/NumericString.c
index a007496c..ba589239 100644
--- a/skeletons/NumericString.c
+++ b/skeletons/NumericString.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_NumericString = {
 	  / sizeof(asn1_DEF_NumericString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 int
diff --git a/skeletons/OBJECT_IDENTIFIER.c b/skeletons/OBJECT_IDENTIFIER.c
index bcbcdcaf..0a27c8ca 100644
--- a/skeletons/OBJECT_IDENTIFIER.c
+++ b/skeletons/OBJECT_IDENTIFIER.c
@@ -24,7 +24,8 @@ asn1_TYPE_descriptor_t asn1_DEF_OBJECT_IDENTIFIER = {
 	sizeof(asn1_DEF_OBJECT_IDENTIFIER_tags)
 	    / sizeof(asn1_DEF_OBJECT_IDENTIFIER_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
 
 
@@ -94,8 +95,8 @@ OBJECT_IDENTIFIER_get_arc_l(uint8_t *arcbuf, int arclen, int add, unsigned long
 	unsigned long accum;
 	uint8_t *arcend = arcbuf + arclen;
 
-	if(arclen * 7 > 8 * sizeof(accum)) {
-		if(arclen * 7 <= 8 * (sizeof(accum) + 1)) {
+	if((size_t)arclen * 7 > 8 * sizeof(accum)) {
+		if((size_t)arclen * 7 <= 8 * (sizeof(accum) + 1)) {
 			if((*arcbuf & ~0x8f)) {
 				errno = ERANGE;	/* Overflow */
 				return -1;
@@ -110,8 +111,8 @@ OBJECT_IDENTIFIER_get_arc_l(uint8_t *arcbuf, int arclen, int add, unsigned long
 	for(accum = 0; arcbuf < arcend; arcbuf++)
 		accum = (accum << 7) | (*arcbuf & ~0x80);
 
+	assert(accum >= (unsigned long)-add);
 	accum += add;	/* Actually, a negative value */
-	assert(accum >= 0);
 
 	*rvalue = accum;
 
@@ -144,6 +145,9 @@ OBJECT_IDENTIFIER_print(asn1_TYPE_descriptor_t *td, const void *sptr,
 	int add = 0;
 	int i;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(!st || !st->buf)
 		return cb("<absent>", 8, app_key);
 
diff --git a/skeletons/OCTET_STRING.c b/skeletons/OCTET_STRING.c
index fc5c532c..53a1a0d1 100644
--- a/skeletons/OCTET_STRING.c
+++ b/skeletons/OCTET_STRING.c
@@ -25,6 +25,7 @@ asn1_TYPE_descriptor_t asn1_DEF_OCTET_STRING = {
 	  / sizeof(asn1_DEF_OCTET_STRING_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine (primitive and constructed) */
+	0	/* No specifics */
 };
 
 #define	_CH_PHASE(ctx, inc) do {	\
@@ -48,27 +49,27 @@ asn1_TYPE_descriptor_t asn1_DEF_OCTET_STRING = {
 		return rval;			\
 	} while(0)
 
-#define	APPEND(bufptr, bufsize)	do {			\
-		int _ns = ctx->step;	/* Allocated */	\
-		if(_ns <= (st->size + bufsize)) {	\
-			void *ptr;			\
-			do { _ns = _ns ? _ns<<2 : 16; }	\
-				while(_ns <= (st->size + bufsize));	\
-			ptr = REALLOC(st->buf, _ns);	\
-			if(ptr) {			\
-				st->buf = ptr;		\
-				ctx->step = _ns;	\
-			} else {			\
-				RETURN(RC_FAIL);	\
-			}				\
-		}					\
-		memcpy(st->buf + st->size, bufptr, bufsize);	\
-		st->size += bufsize;			\
-		if(st->size < 0)			\
-			/* Why even care?.. JIC */	\
-			RETURN(RC_FAIL);		\
-		/* Convenient nul-termination */	\
-		st->buf[st->size] = '\0';		\
+#define	APPEND(bufptr, bufsize)	do {					\
+		size_t _ns = ctx->step;	/* Allocated */			\
+		if(_ns <= (size_t)(st->size + bufsize)) {		\
+			void *ptr;					\
+			do { _ns = _ns ? _ns<<2 : 16; }			\
+				while(_ns <= (size_t)(st->size + bufsize));	\
+			ptr = REALLOC(st->buf, _ns);			\
+			if(ptr) {					\
+				st->buf = ptr;				\
+				ctx->step = _ns;			\
+			} else {					\
+				RETURN(RC_FAIL);			\
+			}						\
+		}							\
+		memcpy(st->buf + st->size, bufptr, bufsize);		\
+		st->size += bufsize;					\
+		if(st->size < 0)					\
+			/* Why even care?.. JIC */			\
+			RETURN(RC_FAIL);				\
+		/* Convenient nul-termination */			\
+		st->buf[st->size] = '\0';				\
 	} while(0)
 
 /*
@@ -315,7 +316,7 @@ OCTET_STRING_decode_ber(asn1_TYPE_descriptor_t *td,
 
 		assert(sel->left >= 0);
 
-		len = (size < sel->left) ? size : sel->left;
+		len = ((ber_tlv_len_t)size < sel->left) ? size : sel->left;
 		if(len > 0) {
 			if(is_bit_str && sel->bits_chopped == 0) {
 				/*
@@ -350,7 +351,7 @@ OCTET_STRING_decode_ber(asn1_TYPE_descriptor_t *td,
 		/*
 		 * Primitive form, no stack required.
 		 */
-		if(size < ctx->left) {
+		if(size < (size_t)ctx->left) {
 			APPEND(buf_ptr, size);
 			ctx->left -= size;
 			ADVANCE(size);
@@ -465,6 +466,8 @@ OCTET_STRING_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	size_t i;
 	int ret;
 
+	(void)td;	/* Unused argument */
+
 	if(!st || !st->buf) return cb("<absent>", 8, app_key);
 
 	/*
@@ -494,6 +497,9 @@ OCTET_STRING_print_ascii(asn1_TYPE_descriptor_t *td, const void *sptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
 	const OCTET_STRING_t *st = sptr;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(st && st->buf) {
 		return cb(st->buf, st->size, app_key);
 	} else {
diff --git a/skeletons/ObjectDescriptor.c b/skeletons/ObjectDescriptor.c
index 5a39380c..db699ca0 100644
--- a/skeletons/ObjectDescriptor.c
+++ b/skeletons/ObjectDescriptor.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_ObjectDescriptor = {
 	  / sizeof(asn1_DEF_ObjectDescriptor_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/PrintableString.c b/skeletons/PrintableString.c
index 32ee7da5..8589bd22 100644
--- a/skeletons/PrintableString.c
+++ b/skeletons/PrintableString.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_PrintableString = {
 	  / sizeof(asn1_DEF_PrintableString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 
diff --git a/skeletons/RELATIVE-OID.c b/skeletons/RELATIVE-OID.c
index f6572105..4fdad3d2 100644
--- a/skeletons/RELATIVE-OID.c
+++ b/skeletons/RELATIVE-OID.c
@@ -24,7 +24,8 @@ asn1_TYPE_descriptor_t asn1_DEF_RELATIVE_OID = {
 	sizeof(asn1_DEF_RELATIVE_OID_tags)
 	    / sizeof(asn1_DEF_RELATIVE_OID_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
-	0	/* Always in primitive form */
+	0,	/* Always in primitive form */
+	0	/* No specifics */
 };
 
 int
@@ -34,6 +35,9 @@ RELATIVE_OID_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	int startn;
 	int i;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(!st || !st->buf)
 		return cb("<absent>", 8, app_key);
 
diff --git a/skeletons/T61String.c b/skeletons/T61String.c
index e6dceb78..2ba5d324 100644
--- a/skeletons/T61String.c
+++ b/skeletons/T61String.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_T61String = {
 	  / sizeof(asn1_DEF_T61String_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/TeletexString.c b/skeletons/TeletexString.c
index 1076c8af..dafbd585 100644
--- a/skeletons/TeletexString.c
+++ b/skeletons/TeletexString.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_TeletexString = {
 	  / sizeof(asn1_DEF_TeletexString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/UTCTime.c b/skeletons/UTCTime.c
index e2f758ec..5ce2708b 100644
--- a/skeletons/UTCTime.c
+++ b/skeletons/UTCTime.c
@@ -29,6 +29,7 @@ asn1_TYPE_descriptor_t asn1_DEF_UTCTime = {
 	  / sizeof(asn1_DEF_UTCTime_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 #endif	/* __NO_ASN_TABLE__ */
@@ -58,6 +59,9 @@ UTCTime_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 		asn_app_consume_bytes_f *cb, void *app_key) {
 	const UTCTime_t *st = sptr;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(st && st->buf) {
 		char buf[32];
 		struct tm tm;
@@ -71,7 +75,7 @@ UTCTime_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 			"%04d-%02d-%02d %02d:%02d%02d",
 			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 			tm.tm_hour, tm.tm_min, tm.tm_sec);
-		assert(ret > 0 && ret < sizeof(buf));
+		assert(ret > 0 && ret < (int)sizeof(buf));
 		return cb(buf, ret, app_key);
 	} else {
 		return cb("<absent>", 8, app_key);
@@ -83,7 +87,8 @@ asn_UT2time(const UTCTime_t *st, struct tm *_tm) {
 	char buf[17+2];	/* "AAMMJJhhmmss+hhmm" = 17, + 2 = 19 */
 	GeneralizedTime_t gt;
 
-	if(!st || !st->buf || st->size < 11 || st->size > (sizeof(buf) - 2)) {
+	if(!st || !st->buf
+	|| st->size < 11 || st->size > ((int)sizeof(buf) - 2)) {
 		errno = EINVAL;
 		return -1;
 	}
diff --git a/skeletons/UTF8String.c b/skeletons/UTF8String.c
index fdd13d87..4ec15b82 100644
--- a/skeletons/UTF8String.c
+++ b/skeletons/UTF8String.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_UTF8String = {
 	  / sizeof(asn1_DEF_UTF8String_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 static int _UTF8String_h1[16] = {
@@ -104,6 +105,9 @@ UTF8String_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	asn_app_consume_bytes_f *cb, void *app_key) {
 	const UTF8String_t *st = sptr;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(st && st->buf) {
 		return cb(st->buf, st->size, app_key);
 	} else {
diff --git a/skeletons/UniversalString.c b/skeletons/UniversalString.c
index 7d75e079..1e3444ee 100644
--- a/skeletons/UniversalString.c
+++ b/skeletons/UniversalString.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_UniversalString = {
 	  / sizeof(asn1_DEF_UniversalString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 
@@ -35,6 +36,9 @@ UniversalString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 	char scratch[128];			/* Scratchpad buffer */
 	char *p;
 
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
 	if(!st || !st->buf) return cb("<absent>", 8, app_key);
 
 	wchar = (uint32_t *)st->buf;
diff --git a/skeletons/VideotexString.c b/skeletons/VideotexString.c
index ab92ebd9..d9293beb 100644
--- a/skeletons/VideotexString.c
+++ b/skeletons/VideotexString.c
@@ -23,5 +23,6 @@ asn1_TYPE_descriptor_t asn1_DEF_VideotexString = {
 	  / sizeof(asn1_DEF_VideotexString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
diff --git a/skeletons/VisibleString.c b/skeletons/VisibleString.c
index af9525f8..4a335a3a 100644
--- a/skeletons/VisibleString.c
+++ b/skeletons/VisibleString.c
@@ -23,6 +23,7 @@ asn1_TYPE_descriptor_t asn1_DEF_VisibleString = {
 	  / sizeof(asn1_DEF_VisibleString_tags[0]),
 	1,	/* Single UNIVERSAL tag may be implicitly overriden */
 	-1,	/* Both ways are fine */
+	0	/* No specifics */
 };
 
 
diff --git a/skeletons/ber_decoder.c b/skeletons/ber_decoder.c
index 135e7910..ab8d671c 100644
--- a/skeletons/ber_decoder.c
+++ b/skeletons/ber_decoder.c
@@ -210,7 +210,7 @@ ber_check_tags(asn1_TYPE_descriptor_t *head, ber_dec_ctx_t *ctx,
 		ADVANCE(tag_len + len_len);
 
 		limit_len -= (tag_len + len_len);
-		if(size > limit_len) {
+		if((ssize_t)size > limit_len) {
 			/*
 			 * Make sure that we won't consume more bytes
 			 * from the large buffer than the inferred limit.
diff --git a/skeletons/ber_tlv_length.c b/skeletons/ber_tlv_length.c
index cd08f6ab..71850f09 100644
--- a/skeletons/ber_tlv_length.c
+++ b/skeletons/ber_tlv_length.c
@@ -24,7 +24,7 @@ ber_fetch_length(int _is_constructed, void *bufptr, size_t size,
 		return 1;
 	} else {
 		ber_tlv_len_t len;
-		ssize_t skipped;
+		size_t skipped;
 
 		if(_is_constructed && oct == 0x80) {
 			*len_r = -1;	/* Indefinite length */
@@ -65,7 +65,7 @@ ber_skip_length(int _is_constructed, void *ptr, size_t size) {
 	ber_tlv_len_t vlen;	/* Length of V in TLV */
 	ssize_t tl;		/* Length of L in TLV */
 	ssize_t ll;		/* Length of L in TLV */
-	ssize_t skip;
+	size_t skip;
 
 	/*
 	 * Determine the size of L in TLV.
@@ -118,7 +118,7 @@ ber_skip_length(int _is_constructed, void *ptr, size_t size) {
 
 ssize_t
 der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size) {
-	ssize_t computed_size;	/* Size of len encoding */
+	size_t computed_size;	/* Size of len encoding */
 	uint8_t *buf = bufp;
 	uint8_t *end;
 	int i;
diff --git a/skeletons/ber_tlv_tag.c b/skeletons/ber_tlv_tag.c
index 50c9e69b..a6cccec8 100644
--- a/skeletons/ber_tlv_tag.c
+++ b/skeletons/ber_tlv_tag.c
@@ -10,7 +10,7 @@ ssize_t
 ber_fetch_tag(void *ptr, size_t size, ber_tlv_tag_t *tag_r) {
 	ber_tlv_tag_t val;
 	ber_tlv_tag_t tclass;
-	ssize_t skipped;
+	size_t skipped;
 
 	if(size == 0)
 		return 0;
@@ -61,7 +61,7 @@ ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f) {
 	ssize_t ret;
 
 	ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf));
-	if(ret >= sizeof(buf) || ret < 2) {
+	if(ret >= (ssize_t)sizeof(buf) || ret < 2) {
 		errno = EPERM;
 		return -1;
 	}
@@ -103,7 +103,7 @@ der_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size) {
 	ber_tlv_tag_t tval = BER_TAG_VALUE(tag);
 	uint8_t *buf = bufp;
 	uint8_t *end;
-	ssize_t computed_size;
+	size_t computed_size;
 	int i;
 
 	if(tval <= 30) {
diff --git a/skeletons/constr_CHOICE.c b/skeletons/constr_CHOICE.c
index e6d08ba2..1ecbbce7 100644
--- a/skeletons/constr_CHOICE.c
+++ b/skeletons/constr_CHOICE.c
@@ -11,7 +11,7 @@
  * (ctx->left) indicates the number of bytes _transferred_ for the structure.
  * (size) contains the number of bytes in the buffer passed.
  */
-#define	LEFT	((size<ctx->left)?size:ctx->left)
+#define	LEFT	((size<(size_t)ctx->left)?size:ctx->left)
 
 /*
  * If the subprocessor function returns with an indication that it wants
@@ -24,7 +24,7 @@
  * if the V processor returns with "want more data" even if the buffer
  * contains way more data than the V processor have seen.
  */
-#define	SIZE_VIOLATION	(ctx->left >= 0 && ctx->left <= size)
+#define	SIZE_VIOLATION	(ctx->left >= 0 && (size_t)ctx->left <= size)
 
 /*
  * This macro "eats" the part of the buffer which is definitely "consumed",
diff --git a/skeletons/constr_SEQUENCE.c b/skeletons/constr_SEQUENCE.c
index 6704dd84..71689674 100644
--- a/skeletons/constr_SEQUENCE.c
+++ b/skeletons/constr_SEQUENCE.c
@@ -9,7 +9,7 @@
  * (ctx->left) indicates the number of bytes _transferred_ for the structure.
  * (size) contains the number of bytes in the buffer passed.
  */
-#define	LEFT	((size<ctx->left)?size:ctx->left)
+#define	LEFT	((size<(size_t)ctx->left)?size:ctx->left)
 
 /*
  * If the subprocessor function returns with an indication that it wants
@@ -22,7 +22,7 @@
  * if the V processor returns with "want more data" even if the buffer
  * contains way more data than the V processor have seen.
  */
-#define	SIZE_VIOLATION	(ctx->left >= 0 && ctx->left <= size)
+#define	SIZE_VIOLATION	(ctx->left >= 0 && (size_t)ctx->left <= size)
 
 /*
  * This macro "eats" the part of the buffer which is definitely "consumed",
diff --git a/skeletons/constr_SEQUENCE_OF.c b/skeletons/constr_SEQUENCE_OF.c
index cdddf607..a839949d 100644
--- a/skeletons/constr_SEQUENCE_OF.c
+++ b/skeletons/constr_SEQUENCE_OF.c
@@ -68,7 +68,7 @@ SEQUENCE_OF_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr,
 		encoding_size += erval.encoded;
 	}
 
-	if(computed_size != encoding_size) {
+	if(computed_size != (size_t)encoding_size) {
 		/*
 		 * Encoded size is not equal to the computed size.
 		 */
diff --git a/skeletons/constr_SET.c b/skeletons/constr_SET.c
index f1df9c1b..d0cac1d0 100644
--- a/skeletons/constr_SET.c
+++ b/skeletons/constr_SET.c
@@ -11,7 +11,7 @@
  * (ctx->left) indicates the number of bytes _transferred_ for the structure.
  * (size) contains the number of bytes in the buffer passed.
  */
-#define	LEFT	((size<ctx->left)?size:ctx->left)
+#define	LEFT	((size<(size_t)ctx->left)?size:ctx->left)
 
 /*
  * If the subprocessor function returns with an indication that it wants
@@ -24,7 +24,7 @@
  * if the V processor returns with "want more data" even if the buffer
  * contains way more data than the V processor have seen.
  */
-#define	SIZE_VIOLATION	(ctx->left >= 0 && ctx->left <= size)
+#define	SIZE_VIOLATION	(ctx->left >= 0 && (size_t)ctx->left <= size)
 
 /*
  * This macro "eats" the part of the buffer which is definitely "consumed",
diff --git a/skeletons/constr_SET_OF.c b/skeletons/constr_SET_OF.c
index 9dcf638f..e398db8b 100644
--- a/skeletons/constr_SET_OF.c
+++ b/skeletons/constr_SET_OF.c
@@ -10,7 +10,7 @@
  * (ctx->left) indicates the number of bytes _transferred_ for the structure.
  * (size) contains the number of bytes in the buffer passed.
  */
-#define	LEFT	((size<ctx->left)?size:ctx->left)
+#define	LEFT	((size<(size_t)ctx->left)?size:ctx->left)
 
 /*
  * If the subprocessor function returns with an indication that it wants
@@ -23,7 +23,7 @@
  * if the V processor returns with "want more data" even if the buffer
  * contains way more data than the V processor have seen.
  */
-#define	SIZE_VIOLATION	(ctx->left != -1 && ctx->left <= size)
+#define	SIZE_VIOLATION	(ctx->left != -1 && (size_t)ctx->left <= size)
 
 /*
  * This macro "eats" the part of the buffer which is definitely "consumed",
@@ -178,7 +178,7 @@ SET_OF_decode_ber(asn1_TYPE_descriptor_t *sd,
 		}
 
 		/* Outmost tag may be unknown and cannot be fetched/compared */
-		if(element->tag != -1) {
+		if(element->tag != (ber_tlv_tag_t)-1) {
 		    if(BER_TAGS_EQUAL(tlv_tag, element->tag)) {
 			/*
 			 * The new list member of expected type has arrived.
@@ -334,7 +334,7 @@ SET_OF_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr,
 		computed_size += erval.encoded;
 
 		/* Compute maximum encoding's size */
-		if(max_encoded_len < erval.encoded)
+		if(max_encoded_len < (size_t)erval.encoded)
 			max_encoded_len = erval.encoded;
 	}
 
@@ -429,7 +429,7 @@ SET_OF_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr,
 	}
 	FREEMEM(encoded_els);
 
-	if(ret || computed_size != encoding_size) {
+	if(ret || computed_size != (size_t)encoding_size) {
 		/*
 		 * Standard callback failed, or
 		 * encoded size is not equal to the computed size.
diff --git a/skeletons/constraints.c b/skeletons/constraints.c
index 13a1b402..cf317061 100644
--- a/skeletons/constraints.c
+++ b/skeletons/constraints.c
@@ -4,6 +4,12 @@
 int
 asn_generic_no_constraint(asn1_TYPE_descriptor_t *type_descriptor,
 	const void *struct_ptr, asn_app_consume_bytes_f *cb, void *key) {
+
+	(void)type_descriptor;	/* Unused argument */
+	(void)struct_ptr;	/* Unused argument */
+	(void)cb;	/* Unused argument */
+	(void)key;	/* Unused argument */
+
 	/* Nothing to check */
 	return 0;
 }
@@ -11,6 +17,12 @@ asn_generic_no_constraint(asn1_TYPE_descriptor_t *type_descriptor,
 int
 asn_generic_unknown_constraint(asn1_TYPE_descriptor_t *type_descriptor,
 	const void *struct_ptr, asn_app_consume_bytes_f *cb, void *key) {
+
+	(void)type_descriptor;	/* Unused argument */
+	(void)struct_ptr;	/* Unused argument */
+	(void)cb;	/* Unused argument */
+	(void)key;	/* Unused argument */
+
 	/* Unknown how to check */
 	return 0;
 }
@@ -86,7 +98,7 @@ _asn_i_log_error(asn_app_consume_bytes_f *cb, void *key, const char *fmt, ...) {
 		/* Fall through */
 	}
 
-	if(ret < sizeof(buf)) {
+	if(ret < (ssize_t)sizeof(buf)) {
 		cb(buf, ret, key);
 		return;
 	}
@@ -102,7 +114,7 @@ _asn_i_log_error(asn_app_consume_bytes_f *cb, void *key, const char *fmt, ...) {
 	va_start(ap, fmt);
 	ret = vsnprintf(buf, len, fmt, ap);
 	va_end(ap);
-	if(ret < 0 || ret >= len) {
+	if(ret < 0 || ret >= (ssize_t)len) {
 		ret = sizeof("<broken vsnprintf>") - 1;
 		memcpy(buf, "<broken vsnprintf>", ret + 1);
 	}
diff --git a/skeletons/der_encoder.c b/skeletons/der_encoder.c
index f275f9c1..72a33ebc 100644
--- a/skeletons/der_encoder.c
+++ b/skeletons/der_encoder.c
@@ -118,7 +118,7 @@ der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
 
 	/* Serialize tag (T from TLV) into possibly zero-length buffer */
 	tmp = der_tlv_tag_serialize(tag, buf, buf_size);
-	if(tmp == -1 || tmp > sizeof(buf)) return -1;
+	if(tmp == -1 || tmp > (ssize_t)sizeof(buf)) return -1;
 	size += tmp;
 
 	/* Serialize length (L from TLV) into possibly zero-length buffer */
-- 
GitLab