diff --git a/asn1c/tests/check-22.c b/asn1c/tests/check-22.c
index c80f9881015f9ca01d3327f3ef9ea8bc65357635..022278220f6e96b75c5f38de662ed412b0d70076 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 b74ca16591bb85cfc03689f81efe81f0494ff8fc..79de91156c3409635756da52b5f1b21be9c58350 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 bd803da3a0398d25f6726d0c9e46d09b71276ef9..dad12ae109ffb6e752f8b2ef571baa53d2795ffe 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 9e5adf22dc86a0f18284ab05cd51fd66cae8a38e..4ac52120ef584aea75fdc1b11944e24d4032bf2d 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 53a90cbaf86d1c5a5e707b1bf536e5d7251f10ac..cfebedcd9f4967aa506f9c158535185e8aa0fb11 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 3cb0fdac9d2cdb34a2280da2f410f9cb4581593a..49ad2d603ec74af4dd2a6d8278442c6169b82a91 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 14f5377a578162391ce39841e518dc8b13b40163..616387135806377afbb8fbd07ce542f2db8658b7 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 6b6c04d65d55e30bdc40f2f5066d686489ba126f..f29d877ccfb47bf5adcdfea7ea9e0e6332051604 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 c2238cf5acc1d8d5d2bfd14bf6fddc263d3884d8..09a9d62a39d194b98eb5680ab47513a58f60ca7e 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 e44218d848164e2d3d474a0f84c58d213e2f6a81..c906f64dc832b2f1d1a8a2726f13386d0358edcc 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 b464b64cdf236c523e6bcf2239c3489f5d5baffd..257e02c5c29e739a83020cbf0293bf3601450ea8 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 8aab8c429ec3e32bcc1525659af57d16ee70cfa3..5e425d65fa3cc2f4c8368ff6eb7c1c8e6340ff9d 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 d647c05b6c8a98b09f79e88eea537705c735abaf..24e539a0844a0061eec4bd2371ebc7e58b8256c0 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 c541fd62c3e4a796665705a234adc62dca524aa4..f617c3180341f9f1f87b6447188942b14f074e7b 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 514ab70e7bf12f2add183ba2eb8922212759dbbd..c3a2a7b00d0af78e409fb8301087013ac57fc056 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 5fe69034f8b9449f515b7ded99288e9730988db8..a9a5378b8cdb4ce302ac8756a3af3a7492f5a1b4 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 02de131bd6bbf6bf4b3389ded4c8a50c121d4860..7d98a55c843d78f7028159e248b6b3637db713c4 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 4ac2b32d708703911c4ef8c9dca854430a80b47f..af6f6bb2627d84bc1d1c86a551337e6a7bf8b8c7 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 992dcfa04cb1be1cd2bbfd941cfb0c00235cd668..8e8049dc80febbc959b99e7502e1206c87d8bfe5 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 19b6ff2e388214ce0df5546b327570eda8852e78..4914b2074e193fe57a0384f5a9166fb49cf6c042 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 596974eafe09f7c7da090df70d1fb3545979543d..93584c8e012e24d4461a9fdfa174e2ebad969561 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 705d37e0f13ac440a6cb674525a4682d3a2186e6..9391316883249c7230d4f324a99a5653d35cacf2 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 1f1ae896108d31502f58a0918be9d9146ed5a85a..3fff3682911cc5dc88c073f6459a1eb081581227 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 d69c5f16f23020f14627a11d8a9b4fa2ee3b3f57..6bc7e4782819e81857f3f6db2446d937421283a5 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 01d7a736e17bf9bbd1d0b62b574ca67a07f4db61..1dadb92def92eae040ae8334214285ff13a97fa1 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 5c89685ef319f0e5fcbffecfbd81736e9bd3936a..412f3c740810d7d35c7efe00c1d7f46ec63917e7 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 c4afcb00d2e0444f43002a275f697e6880cb7a85..902de8556d0e7aafebbcc175294b3eb4b7233702 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 b1a8c29b9a709a7cd88167e7c33cbe1be3f19f96..d20379fb536688f640b4b0167ac37229d224f0e0 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 08b316987dfa43fdd91ed1b7e1986efcf2768dd0..2df623cfab3ee49502a8d17953131813dff274b0 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 9027e2c1d6728a08d6b9291fabd5ea6e21e7d8d2..4ea06693409d17995c8587b9b37ecca1d9d13966 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 b6d21ed25f19c3300c1abc3c2a3cc59e13daffb0..bfb2bff1ab78728e9bc160bef74a010d7c60a00a 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 d42540efb4e9b36783665da54527ba6e61cf4d66..8203695cce351db9cbafae3617b42cd22b334316 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 a007496cc861d2a75dd5c450e5e7081bb81e24d7..ba5892391b62362251dad2a1c11ee6bcd421e306 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 bcbcdcafa81a905e72cfdfbb53eeb06913c0a9d3..0a27c8cac1ac59feb10d1940346232f67ae8c4e0 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 fc5c532c5a861dc72f5888d109ca04ceef50a2e9..53a1a0d15644d5011537e7578bee0c214874b427 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 5a39380c41bc972386929711932aac736a00ee40..db699ca02670c0dd19fee9029d90117345fca93e 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 32ee7da548547dbbe7ab07964260cea4710d5c1d..8589bd225e2ebd39191c80033eb304a808f940af 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 f6572105bc29a89b0671512a44f7aceb808a9045..4fdad3d2610286027f64b511bdc80c663edfef6d 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 e6dceb78d3ce8d66c1d7b2e59791948458a9cb44..2ba5d324f15078bc232b23696a6a2ce594a7e4d3 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 1076c8af5df7b26aad4156057294909794c61948..dafbd5852cd10cc48bfa3827534ddcd333e78159 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 e2f758ecf96940fb4b08e3611926963eabb16c0c..5ce2708b49971879c9d9e7131e104a6a77db7dd5 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 fdd13d871e0b94bf34b1c68042ed1d7b02505a4c..4ec15b82687f3f719bdc984a04a45e11fad30d36 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 7d75e079bb7d80399acd1157972beefb2ea31ae6..1e3444eefada0c087385263dc476c4f5833978d2 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 ab92ebd99c7c926a560bbdd7b6246431932d8ee1..d9293beb8eb9abc0fb0da3c73f42780b87f2cf99 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 af9525f80b7ef9e2c59f8279fa2aa320da637c3d..4a335a3a12bb0d9a7fee62362caccfc5284ee589 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 135e7910eb70091dbe427bd441ee7f238f1e5b99..ab8d671c76e3dc8f847a0aec535e376250e062a8 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 cd08f6ab44343f2d27f962b197c371a260557fee..71850f09ea94ddacccb18f03b9fc21fa06a9efbc 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 50c9e69b64b36f59e5b924306ed10cd5a296e883..a6cccec847283e2ed6847b080a4f1b061abcf370 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 e6d08ba253edca45926bfb91ec8749607eaab70e..1ecbbce79f95cf3da50235a8190eb84b2cf4c3ee 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 6704dd843cff0840dd2acd569f773e5cd20f37c4..71689674aebf0e21ec7c989ba3e9703e5abf8b59 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 cdddf60766fcd4396833547bcc06fa11ead72878..a839949de09b60b81152f2ebbb887ddc6acc0182 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 f1df9c1b391ab57d9e7ad81786d4aa6cc3bfe975..d0cac1d0f8a02c6289880b9e5555efd107720dc2 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 9dcf638f9e06c9bf7c6ea77a76ab92be554d7e6f..e398db8be2f1483cd73d78e99d03587a657d953f 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 13a1b4022a073982312a3ce592a63fcfdc6e775f..cf31706134190d098587361a4fd40243a847a1d4 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 f275f9c1b35302caf09d2c3c2a502315ebc242eb..72a33ebcdc1f53774383d5c057957bac56a3da04 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 */