Use size_t rather than unsigned for base16, base64, nettle_bufer and sexp related functions.

23 files changed, 173 insertions, 164 deletions

diff --git a/base16-decode.c b/base16-decode.c
index 20ae2ab3..4dc8abd4 100644
--- a/base16-decode.c
+++ b/base16-decode.c
@@ -93,17 +93,17 @@ base16_decode_single(struct base16_decode_ctx *ctx,
 
 int
 base16_decode_update(struct base16_decode_ctx *ctx,
-		     unsigned *dst_length,
+		     size_t *dst_length,
 		     uint8_t *dst,
-		     unsigned src_length,
+		     size_t src_length,
 		     const uint8_t *src)
 {
-  unsigned done;
-  unsigned i;
+  size_t done;
+  size_t i;
 
   assert(*dst_length >= BASE16_DECODE_LENGTH(src_length));
   
-  for (i = 0, done = 0; i<src_length; i++)
+  for (i = done = 0; i<src_length; i++)
     switch(base16_decode_single(ctx, dst + done, src[i]))
       {
       case -1:
diff --git a/base16-encode.c b/base16-encode.c
index a4e1b68f..8d1e20b3 100644
--- a/base16-encode.c
+++ b/base16-encode.c
@@ -47,11 +47,11 @@ base16_encode_single(uint8_t *dst,
 /* Always stores BASE16_ENCODE_LENGTH(length) digits in dst. */
 void
 base16_encode_update(uint8_t *dst,
-		     unsigned length,
+		     size_t length,
 		     const uint8_t *src)
 {
-  unsigned i;
+  size_t i;
   
-  for (i = 0, dst; i<length; i++, dst += 2)
+  for (i = 0; i<length; i++, dst += 2)
     base16_encode_single(dst, src[i]);
 }
diff --git a/base16-meta.c b/base16-meta.c
index 2f7aa34a..a182871a 100644
--- a/base16-meta.c
+++ b/base16-meta.c
@@ -29,25 +29,29 @@
 #include "base16.h"
 
 /* Same as the macros with the same name */
-static unsigned
-base16_encode_length(unsigned length)
+static nettle_armor_length_func base16_encode_length;
+static size_t
+base16_encode_length(size_t length)
 {
   return BASE16_ENCODE_LENGTH(length);
 }
 
-static unsigned
-base16_decode_length(unsigned length)
+static nettle_armor_length_func base16_decode_length;
+static size_t
+base16_decode_length(size_t length)
 {
   return BASE16_DECODE_LENGTH(length);
 }
 
+static nettle_armor_init_func base16_encode_init;
 static void
-base16_encode_init(void *ctx)
-{ (void) ctx; }
+base16_encode_init(void *ctx UNUSED)
+{ }
 
-static unsigned
+static nettle_armor_encode_update_func base16_encode_update_wrapper;
+static size_t
 base16_encode_update_wrapper(void *ctx UNUSED, uint8_t *dst,
-			     unsigned length, const uint8_t *src)
+			     size_t length, const uint8_t *src)
 {
   base16_encode_update(dst, length, src);
   return BASE16_ENCODE_LENGTH(length);
@@ -56,9 +60,12 @@ base16_encode_update_wrapper(void *ctx UNUSED, uint8_t *dst,
 #undef base16_encode_update
 #define base16_encode_update base16_encode_update_wrapper
 
-static unsigned
-base16_encode_final(void *ctx, uint8_t *dst)
-{ (void) ctx; (void) dst; return 0; }
+static nettle_armor_encode_final_func base16_encode_final;
+static size_t
+base16_encode_final(void *ctx UNUSED, uint8_t *dst UNUSED)
+{
+  return 0;
+}
 
 
 #define BASE16_ENCODE_FINAL_LENGTH 0
diff --git a/base16.h b/base16.h
index 5eae3325..56422930 100644
--- a/base16.h
+++ b/base16.h
@@ -54,7 +54,7 @@ base16_encode_single(uint8_t *dst,
 /* Always stores BASE16_ENCODE_LENGTH(length) digits in dst. */
 void
 base16_encode_update(uint8_t *dst,
-		     unsigned length,
+		     size_t length,
 		     const uint8_t *src);
 
 
@@ -90,9 +90,9 @@ base16_decode_single(struct base16_decode_ctx *ctx,
  * too small. FIXME: Return some error instead? */
 int
 base16_decode_update(struct base16_decode_ctx *ctx,
-		     unsigned *dst_length,
+		     size_t *dst_length,
 		     uint8_t *dst,
-		     unsigned src_length,
+		     size_t src_length,
 		     const uint8_t *src);
 
 /* Returns 1 on success. */
diff --git a/base64-decode.c b/base64-decode.c
index 9624c07d..c7c739af 100644
--- a/base64-decode.c
+++ b/base64-decode.c
@@ -114,13 +114,13 @@ base64_decode_single(struct base64_decode_ctx *ctx,
 
 int
 base64_decode_update(struct base64_decode_ctx *ctx,
-		     unsigned *dst_length,
+		     size_t *dst_length,
 		     uint8_t *dst,
-		     unsigned src_length,
+		     size_t src_length,
 		     const uint8_t *src)
 {
-  unsigned done;
-  unsigned i;
+  size_t done;
+  size_t i;
 
   assert(*dst_length >= BASE64_DECODE_LENGTH(src_length));
   
diff --git a/base64-encode.c b/base64-encode.c
index b594923f..658c9b64 100644
--- a/base64-encode.c
+++ b/base64-encode.c
@@ -39,7 +39,7 @@ static const uint8_t encode_table[64] =
 #define ENCODE(x) (encode_table[0x3F & (x)])
 
 void
-base64_encode_raw(uint8_t *dst, unsigned length, const uint8_t *src)
+base64_encode_raw(uint8_t *dst, size_t length, const uint8_t *src)
 {
   const uint8_t *in = src + length;
   uint8_t *out = dst + BASE64_ENCODE_RAW_LENGTH(length);
@@ -140,7 +140,7 @@ base64_encode_init(struct base64_encode_ctx *ctx)
 }
 
 /* Encodes a single byte. */
-unsigned
+size_t
 base64_encode_single(struct base64_encode_ctx *ctx,
 		     uint8_t *dst,
 		     uint8_t src)
@@ -165,16 +165,16 @@ base64_encode_single(struct base64_encode_ctx *ctx,
 
 /* Returns the number of output characters. DST should point to an
  * area of size at least BASE64_ENCODE_LENGTH(length). */
-unsigned
+size_t
 base64_encode_update(struct base64_encode_ctx *ctx,
 		     uint8_t *dst,
-		     unsigned length,
+		     size_t length,
 		     const uint8_t *src)
 {
-  unsigned done = 0;
-  unsigned left = length;
+  size_t done = 0;
+  size_t left = length;
   unsigned left_over;
-  unsigned bulk;
+  size_t bulk;
   
   while (ctx->bits && left)
     {
@@ -208,7 +208,7 @@ base64_encode_update(struct base64_encode_ctx *ctx,
 
 /* DST should point to an area of size at least
  * BASE64_ENCODE_FINAL_SIZE */
-unsigned
+size_t
 base64_encode_final(struct base64_encode_ctx *ctx,
 		    uint8_t *dst)
 {
diff --git a/base64-meta.c b/base64-meta.c
index f1ccea0f..cb33c675 100644
--- a/base64-meta.c
+++ b/base64-meta.c
@@ -29,14 +29,16 @@
 #include "base64.h"
 
 /* Same as the macros with the same name */
-static unsigned
-base64_encode_length(unsigned length)
+static nettle_armor_length_func base64_encode_length;
+static size_t
+base64_encode_length(size_t length)
 {
   return BASE64_ENCODE_LENGTH(length);
 }
 
-static unsigned
-base64_decode_length(unsigned length)
+static nettle_armor_length_func base64_decode_length;
+static size_t
+base64_decode_length(size_t length)
 {
   return BASE64_DECODE_LENGTH(length);
 }
diff --git a/base64.h b/base64.h
index b2bd8a8b..94ed52ae 100644
--- a/base64.h
+++ b/base64.h
@@ -71,22 +71,22 @@ void
 base64_encode_init(struct base64_encode_ctx *ctx);
 
 /* Encodes a single byte. Returns amount of output (always 1 or 2). */
-unsigned
+size_t
 base64_encode_single(struct base64_encode_ctx *ctx,
 		     uint8_t *dst,
 		     uint8_t src);
 
 /* Returns the number of output characters. DST should point to an
  * area of size at least BASE64_ENCODE_LENGTH(length). */
-unsigned
+size_t
 base64_encode_update(struct base64_encode_ctx *ctx,
 		     uint8_t *dst,
-		     unsigned length,
+		     size_t length,
 		     const uint8_t *src);
 
 /* DST should point to an area of size at least
  * BASE64_ENCODE_FINAL_LENGTH */
-unsigned
+size_t
 base64_encode_final(struct base64_encode_ctx *ctx,
 		    uint8_t *dst);
 
@@ -96,7 +96,7 @@ base64_encode_final(struct base64_encode_ctx *ctx,
  * Generates exactly BASE64_ENCODE_RAW_LENGTH(length) bytes of output.
  * Supports overlapped operation, if src <= dst. */
 void
-base64_encode_raw(uint8_t *dst, unsigned length, const uint8_t *src);
+base64_encode_raw(uint8_t *dst, size_t length, const uint8_t *src);
 
 void
 base64_encode_group(uint8_t *dst, uint32_t group);
@@ -137,9 +137,9 @@ base64_decode_single(struct base64_decode_ctx *ctx,
  * too small. FIXME: Return some error instead? */
 int
 base64_decode_update(struct base64_decode_ctx *ctx,
-		     unsigned *dst_length,
+		     size_t *dst_length,
 		     uint8_t *dst,
-		     unsigned src_length,
+		     size_t src_length,
 		     const uint8_t *src);
 
 /* Returns 1 on success. */
diff --git a/buffer.c b/buffer.c
index 869e6a33..d2aeadef 100644
--- a/buffer.c
+++ b/buffer.c
@@ -35,13 +35,13 @@
 
 int
 nettle_buffer_grow(struct nettle_buffer *buffer,
-		   unsigned length)
+		   size_t length)
 {
   assert(buffer->size <= buffer->alloc);
   
   if (buffer->size + length > buffer->alloc)
     {
-      unsigned alloc;
+      size_t alloc;
       uint8_t *p;
       
       if (!buffer->realloc)
@@ -72,7 +72,7 @@ nettle_buffer_init_realloc(struct nettle_buffer *buffer,
 
 void
 nettle_buffer_init_size(struct nettle_buffer *buffer,
-			unsigned length, uint8_t *space)
+			size_t length, uint8_t *space)
 {
   buffer->contents = space;
   buffer->alloc = length;
@@ -100,7 +100,7 @@ nettle_buffer_reset(struct nettle_buffer *buffer)
 
 uint8_t *
 nettle_buffer_space(struct nettle_buffer *buffer,
-		    unsigned length)
+		    size_t length)
 {
   uint8_t *p;
 
@@ -114,7 +114,7 @@ nettle_buffer_space(struct nettle_buffer *buffer,
      
 int
 nettle_buffer_write(struct nettle_buffer *buffer,
-		    unsigned length, const uint8_t *data)
+		    size_t length, const uint8_t *data)
 {
   uint8_t *p = nettle_buffer_space(buffer, length);
   if (p)
diff --git a/buffer.h b/buffer.h
index 3bd37a2f..cbc691d3 100644
--- a/buffer.h
+++ b/buffer.h
@@ -36,13 +36,13 @@ struct nettle_buffer
 {
   uint8_t *contents;
   /* Allocated size */
-  unsigned alloc;
+  size_t alloc;
 
   void *realloc_ctx;
   nettle_realloc_func *realloc;
 
   /* Current size */
-  unsigned size;
+  size_t size;
 };
 
 /* Initializes a buffer that uses plain realloc */
@@ -57,7 +57,7 @@ nettle_buffer_init_realloc(struct nettle_buffer *buffer,
 /* Initializes a buffer of fix size */
 void
 nettle_buffer_init_size(struct nettle_buffer *buffer,
-			unsigned length, uint8_t *space);
+			size_t length, uint8_t *space);
 
 void
 nettle_buffer_clear(struct nettle_buffer *buffer);
@@ -68,7 +68,7 @@ nettle_buffer_reset(struct nettle_buffer *buffer);
 
 int
 nettle_buffer_grow(struct nettle_buffer *buffer,
-		   unsigned length);
+		   size_t length);
 
 #define NETTLE_BUFFER_PUTC(buffer, c) \
 ( (((buffer)->size < (buffer)->alloc) || nettle_buffer_grow((buffer), 1)) \
@@ -76,7 +76,7 @@ nettle_buffer_grow(struct nettle_buffer *buffer,
 
 int
 nettle_buffer_write(struct nettle_buffer *buffer,
-		    unsigned length, const uint8_t *data);
+		    size_t length, const uint8_t *data);
 
 /* Like nettle_buffer_write, but instead of copying data to the
  * buffer, it returns a pointer to the area where the caller can copy
@@ -84,7 +84,7 @@ nettle_buffer_write(struct nettle_buffer *buffer,
  * reallocate the buffer. */
 uint8_t *
 nettle_buffer_space(struct nettle_buffer *buffer,
-		    unsigned length);
+		    size_t length);
 
 /* Copy the contents of SRC to the end of DST. */
 int
diff --git a/examples/base16dec.c b/examples/base16dec.c
index 75c8ca59..4b124d28 100644
--- a/examples/base16dec.c
+++ b/examples/base16dec.c
@@ -65,7 +65,7 @@ main(int argc UNUSED, char **argv UNUSED)
   for (;;)
     {
       int nbytes; /* Number of bytes read frmo disk at each iteration */
-      unsigned decoded_bytes; /* Bytes actually generated at each iteration */
+      size_t decoded_bytes; /* Bytes actually generated at each iteration */
 
       nbytes = fread(buffer, 1, CHUNK_SIZE, stdin);
 
@@ -75,30 +75,30 @@ main(int argc UNUSED, char **argv UNUSED)
 	  return EXIT_FAILURE;
 	}
       
-    decoded_bytes = BASE16_DECODE_LENGTH(nbytes);
-
-    /* Decodes one chunk: */
-    if (!base16_decode_update(&b16_ctx, &decoded_bytes, result, nbytes, buffer))
-      {
-	werror ("Error decoding input (not base16?)\n");
-	return EXIT_FAILURE;
-      }
-
-    if (!write_string (stdout, decoded_bytes, result))
-      {
-	werror ("Error writing file: %s\n", strerror(errno));
-	return EXIT_FAILURE;
-      }
-    if (nbytes < CHUNK_SIZE)
-      {
-	/* Check if decoding finalized OK: */
-	if (!base16_decode_final(&b16_ctx))
-	  {
-	    werror("Decoding did not finish properly.\n");
-	    return EXIT_FAILURE;
-	  }
-	break;
-      }
+      decoded_bytes = BASE16_DECODE_LENGTH(nbytes);
+
+      /* Decodes one chunk: */
+      if (!base16_decode_update(&b16_ctx, &decoded_bytes, result, nbytes, buffer))
+	{
+	  werror ("Error decoding input (not base16?)\n");
+	  return EXIT_FAILURE;
+	}
+
+      if (!write_string (stdout, decoded_bytes, result))
+	{
+	  werror ("Error writing file: %s\n", strerror(errno));
+	  return EXIT_FAILURE;
+	}
+      if (nbytes < CHUNK_SIZE)
+	{
+	  /* Check if decoding finalized OK: */
+	  if (!base16_decode_final(&b16_ctx))
+	    {
+	      werror("Decoding did not finish properly.\n");
+	      return EXIT_FAILURE;
+	    }
+	  break;
+	}
     }
 
   if (fflush (stdout) != 0)
diff --git a/examples/base64dec.c b/examples/base64dec.c
index a2fbaedb..653940eb 100644
--- a/examples/base64dec.c
+++ b/examples/base64dec.c
@@ -65,7 +65,7 @@ main(int argc UNUSED, char **argv UNUSED)
   for (;;)
     {
       int nbytes; /* Number of bytes read frmo disk at each iteration */
-      unsigned decoded_bytes; /* Bytes actually generated at each iteration */
+      size_t decoded_bytes; /* Bytes actually generated at each iteration */
 
       nbytes = fread(buffer, 1, CHUNK_SIZE, stdin);
 
diff --git a/nettle-types.h b/nettle-types.h
index 0c372723..cd6ad15d 100644
--- a/nettle-types.h
+++ b/nettle-types.h
@@ -67,20 +67,20 @@ typedef void nettle_hash_digest_func(void *ctx,
 
 /* ASCII armor codecs. NOTE: Experimental and subject to change. */
 
-typedef unsigned nettle_armor_length_func(unsigned length);
+typedef size_t nettle_armor_length_func(size_t length);
 typedef void nettle_armor_init_func(void *ctx);
 
-typedef unsigned nettle_armor_encode_update_func(void *ctx,
-						 uint8_t *dst,
-						 unsigned src_length,
-						 const uint8_t *src);
+typedef size_t nettle_armor_encode_update_func(void *ctx,
+					       uint8_t *dst,
+					       size_t src_length,
+					       const uint8_t *src);
 
-typedef unsigned nettle_armor_encode_final_func(void *ctx, uint8_t *dst);
+typedef size_t nettle_armor_encode_final_func(void *ctx, uint8_t *dst);
 
 typedef int nettle_armor_decode_update_func(void *ctx,
-					    unsigned *dst_length,
+					    size_t *dst_length,
 					    uint8_t *dst,
-					    unsigned src_length,
+					    size_t src_length,
 					    const uint8_t *src);
 
 typedef int nettle_armor_decode_final_func(void *ctx);
diff --git a/sexp-format.c b/sexp-format.c
index 93d1fd98..548c5f1d 100644
--- a/sexp-format.c
+++ b/sexp-format.c
@@ -40,14 +40,14 @@
 
 static unsigned
 format_prefix(struct nettle_buffer *buffer,
-	      unsigned length)
+	      size_t length)
 {
-  unsigned digit = 1;
+  size_t digit = 1;
   unsigned prefix_length = 1;
   
   for (;;)
     {
-      unsigned next = digit * 10;
+      size_t next = digit * 10;
       if (next > length)
 	break;
 
@@ -68,9 +68,9 @@ format_prefix(struct nettle_buffer *buffer,
   return prefix_length + 1;
 }
 
-static unsigned
+static size_t
 format_string(struct nettle_buffer *buffer,
-	      unsigned length, const uint8_t *s)
+	      size_t length, const uint8_t *s)
 {
   unsigned prefix_length = format_prefix(buffer, length);
   if (!prefix_length)
@@ -82,11 +82,11 @@ format_string(struct nettle_buffer *buffer,
   return prefix_length + length;
 }
 
-unsigned
+size_t
 sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 {
   unsigned nesting = 0;
-  unsigned done = 0;
+  size_t done = 0;
 
   for (;;)
     switch (*format++)
@@ -94,8 +94,8 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
       default:
 	{
 	  const char *start = format - 1;
-	  unsigned length = 1 + strcspn(format, "()% \t");
-	  unsigned output_length = format_string(buffer, length, start);
+	  size_t length = 1 + strcspn(format, "()% \t");
+	  size_t output_length = format_string(buffer, length, start);
 	  if (!output_length)
 	    return 0;
 	  
@@ -154,8 +154,8 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 	    case 's':
 	      {
 		const char *s;
-		unsigned length;
-		unsigned output_length;
+		size_t length;
+		size_t output_length;
 		
 		if (nul_flag)
 		  {
@@ -164,7 +164,7 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 		  }
 		else
 		  {
-		    length = va_arg(args, unsigned);
+		    length = va_arg(args, size_t);
 		    s = va_arg(args, const char *);
 		  }
 		
@@ -178,8 +178,8 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 	    case 't':
 	      {
 		const char *s;
-		unsigned length;
-		unsigned output_length;
+		size_t length;
+		size_t output_length;
 		
 		if (nul_flag)
 		  {
@@ -191,7 +191,7 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 		  }
 		else
 		  {
-		    length = va_arg(args, unsigned);
+		    length = va_arg(args, size_t);
 		    s = va_arg(args, const char *);
 		    if (!s)
 		      break;
@@ -218,7 +218,7 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 	    case 'l':
 	      {
 		const char *s;
-		unsigned length;
+		size_t length;
 		
 		if (nul_flag)
 		  {
@@ -227,7 +227,7 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 		  }
 		else
 		  {
-		    length = va_arg(args, unsigned);
+		    length = va_arg(args, size_t);
 		    s = va_arg(args, const char *);
 		  }
 
@@ -291,7 +291,7 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
 	    case 'b':
 	      {
 		const MP_INT *n = va_arg(args, const MP_INT *);
-		unsigned length;
+		size_t length;
 		unsigned prefix_length;
 	      
 		length = nettle_mpz_sizeinbase_256_s(n);
@@ -319,11 +319,11 @@ sexp_vformat(struct nettle_buffer *buffer, const char *format, va_list args)
       }
 }
 
-unsigned
+size_t
 sexp_format(struct nettle_buffer *buffer, const char *format, ...)
 {
   va_list args;
-  unsigned done;
+  size_t done;
   
   va_start(args, format);
   done = sexp_vformat(buffer, format, args);
diff --git a/sexp-transport-format.c b/sexp-transport-format.c
index cb7f3f1f..7d83ac48 100644
--- a/sexp-transport-format.c
+++ b/sexp-transport-format.c
@@ -32,13 +32,13 @@
 #include "base64.h"
 #include "buffer.h"
 
-unsigned
+size_t
 sexp_transport_vformat(struct nettle_buffer *buffer,
 		       const char *format, va_list args)
 {
-  unsigned start = 0;
-  unsigned length;
-  unsigned base64_length;
+  size_t start = 0;
+  size_t length;
+  size_t base64_length;
 
   if (buffer)
     {
@@ -70,11 +70,11 @@ sexp_transport_vformat(struct nettle_buffer *buffer,
   return base64_length + 2;
 }
 
-unsigned
+size_t
 sexp_transport_format(struct nettle_buffer *buffer,
 		      const char *format, ...)
 {
-  unsigned done;
+  size_t done;
   va_list args;
 
   va_start(args, format);
diff --git a/sexp-transport.c b/sexp-transport.c
index 0adcac27..e65832f3 100644
--- a/sexp-transport.c
+++ b/sexp-transport.c
@@ -37,13 +37,13 @@
 /* NOTE: Decodes the input string in place */
 int
 sexp_transport_iterator_first(struct sexp_iterator *iterator,
-			      unsigned length, uint8_t *input)
+			      size_t length, uint8_t *input)
 {
   /* We first base64 decode any transport encoded sexp at the start of
    * the input. */
 
-  unsigned in = 0;
-  unsigned out = 0;
+  size_t in = 0;
+  size_t out = 0;
 
   while (in < length)
     switch(input[in])
@@ -64,8 +64,8 @@ sexp_transport_iterator_first(struct sexp_iterator *iterator,
 	{
 	  /* Found transport encoding */
 	  struct base64_decode_ctx ctx;
-	  unsigned coded_length;
-	  unsigned end;
+	  size_t coded_length;
+	  size_t end;
 
 	  for (end = ++in; end < length && input[end] != '}'; end++)
 	    ;
diff --git a/sexp.c b/sexp.c
index 69b83652..2d0017c2 100644
--- a/sexp.c
+++ b/sexp.c
@@ -57,7 +57,7 @@ sexp_iterator_init(struct sexp_iterator *iterator,
 
 static int
 sexp_iterator_simple(struct sexp_iterator *iterator,
-		     unsigned *size,
+		     size_t *size,
 		     const uint8_t **string)
 {
   unsigned length = 0;
@@ -156,7 +156,7 @@ sexp_iterator_parse(struct sexp_iterator *iterator)
 
 int
 sexp_iterator_first(struct sexp_iterator *iterator,
-		    unsigned length, const uint8_t *input)
+		    size_t length, const uint8_t *input)
 {
   sexp_iterator_init(iterator, length, input);
   return sexp_iterator_parse(iterator);
@@ -232,9 +232,9 @@ sexp_iterator_exit_lists(struct sexp_iterator *iterator,
 
 const uint8_t *
 sexp_iterator_subexpr(struct sexp_iterator *iterator,
-		      unsigned *length)
+		      size_t *length)
 {
-  unsigned start = iterator->start;
+  size_t start = iterator->start;
   if (!sexp_iterator_next(iterator))
     return 0;
 
@@ -251,7 +251,7 @@ sexp_iterator_get_uint32(struct sexp_iterator *iterator,
       && iterator->atom_length
       && iterator->atom[0] < 0x80)
     {
-      unsigned length = iterator->atom_length;
+      size_t length = iterator->atom_length;
       const uint8_t *p = iterator->atom;
 
       /* Skip leading zeros. */
diff --git a/sexp.h b/sexp.h
index 7b68358d..19700a46 100644
--- a/sexp.h
+++ b/sexp.h
@@ -55,22 +55,22 @@ enum sexp_type
 
 struct sexp_iterator
 {
-  unsigned length;
+  size_t length;
   const uint8_t *buffer;
 
   /* Points at the start of the current sub expression. */
-  unsigned start;
+  size_t start;
   /* If type is SEXP_LIST, pos points at the start of the current
    * element. Otherwise, it points at the end. */
-  unsigned pos;
+  size_t pos;
   unsigned level;
 
   enum sexp_type type;
   
-  unsigned display_length;
+  size_t display_length;
   const uint8_t *display;
 
-  unsigned atom_length;
+  size_t atom_length;
   const uint8_t *atom;
 };
 
@@ -80,12 +80,12 @@ struct sexp_iterator
 /* Initializes the iterator. */
 int
 sexp_iterator_first(struct sexp_iterator *iterator,
-		    unsigned length, const uint8_t *input);
+		    size_t length, const uint8_t *input);
 
 /* NOTE: Decodes the input string in place */
 int
 sexp_transport_iterator_first(struct sexp_iterator *iterator,
-			      unsigned length, uint8_t *input);
+			      size_t length, uint8_t *input);
 
 int
 sexp_iterator_next(struct sexp_iterator *iterator);
@@ -110,7 +110,7 @@ sexp_iterator_exit_lists(struct sexp_iterator *iterator,
  * sexp_iterator_next. */
 const uint8_t *
 sexp_iterator_subexpr(struct sexp_iterator *iterator,
-		      unsigned *length);
+		      size_t *length);
 
 int
 sexp_iterator_get_uint32(struct sexp_iterator *iterator,
@@ -160,10 +160,10 @@ struct nettle_buffer;
  * separates tokens but is otherwise ignored) and the following
  * formatting specifiers:
  *
- *   %s   String represented as unsigned length, const uint8_t *data.
+ *   %s   String represented as size_t length, const uint8_t *data.
  *
  *   %t   Optional display type, represented as
- *        unsigned display_length, const uint8_t *display,
+ *        size_t display_length, const uint8_t *display,
  *        display == NULL means no display type.
  *
  *   %i   Non-negative small integer, uint32_t.
@@ -171,7 +171,7 @@ struct nettle_buffer;
  *   %b   Non-negative bignum, mpz_t.
  *
  *   %l   Literal string (no length added), typically a balanced
- *        subexpression. Represented as unsigned length, const uint8_t
+ *        subexpression. Represented as size_t length, const uint8_t
  *        *data.
  *
  *   %(, %)  Allows insertion of unbalanced parenthesis.
@@ -183,19 +183,19 @@ struct nettle_buffer;
  *        const uint8_t * argument.
  */
  
-unsigned
+size_t
 sexp_format(struct nettle_buffer *buffer,
 	    const char *format, ...);
 
-unsigned
+size_t
 sexp_vformat(struct nettle_buffer *buffer,
 	     const char *format, va_list args);
 
-unsigned
+size_t
 sexp_transport_format(struct nettle_buffer *buffer,
 		      const char *format, ...);
 
-unsigned
+size_t
 sexp_transport_vformat(struct nettle_buffer *buffer,
 		       const char *format, va_list args);
 
diff --git a/testsuite/base64-test.c b/testsuite/base64-test.c
index b2388aee..f512d258 100644
--- a/testsuite/base64-test.c
+++ b/testsuite/base64-test.c
@@ -32,7 +32,7 @@ test_main(void)
     /* Test overlapping areas */
     uint8_t buffer[] = "Helloxxxx";
     struct base64_decode_ctx ctx;
-    unsigned dst_length;
+    size_t dst_length;
     
     ASSERT(BASE64_ENCODE_RAW_LENGTH(5) == 8);
     base64_encode_raw(buffer, 5, buffer);
diff --git a/testsuite/sexp-format-test.c b/testsuite/sexp-format-test.c
index 736922b0..54852796 100644
--- a/testsuite/sexp-format-test.c
+++ b/testsuite/sexp-format-test.c
@@ -62,7 +62,7 @@ test_main(void)
     
     nettle_buffer_init(&buffer);  
     ASSERT(sexp_format(&buffer, "(%0s%l)",
-		       "foo", 7, "(4:bar)")
+		       "foo", (size_t) 7, "(4:bar)")
 	   == strlen(e));
     
     ASSERT(buffer.size == strlen(e));
@@ -121,10 +121,10 @@ test_main(void)
     const uint8_t e[] = ")3:foo(3:bar";
 
     nettle_buffer_init(&buffer);
-    ASSERT(sexp_format(&buffer, "%)foo%(%s", 3, "bar")
+    ASSERT(sexp_format(&buffer, "%)foo%(%s", (size_t) 3, "bar")
 	   == strlen(e));
     
-    ASSERT(sexp_format(NULL, "%)foo%(%s", 3, "bar")
+    ASSERT(sexp_format(NULL, "%)foo%(%s", (size_t) 3, "bar")
 	   == strlen(e));
     
     ASSERT(buffer.size == strlen(e));
diff --git a/testsuite/testutils.c b/testsuite/testutils.c
index a264b4ca..c757c75d 100644
--- a/testsuite/testutils.c
+++ b/testsuite/testutils.c
@@ -607,12 +607,12 @@ test_armor(const struct nettle_armor *armor,
            const uint8_t *data,
            const uint8_t *ascii)
 {
-  unsigned ascii_length = strlen(ascii);
+  size_t ascii_length = strlen(ascii);
   uint8_t *buffer = xalloc(1 + ascii_length);
   uint8_t *check = xalloc(1 + armor->decode_length(ascii_length));
   void *encode = xalloc(armor->encode_context_size);
   void *decode = xalloc(armor->decode_context_size);
-  unsigned done;
+  size_t done;
 
   ASSERT(ascii_length
 	 <= (armor->encode_length(data_length) + armor->encode_final_length));
diff --git a/tools/input.c b/tools/input.c
index 2069e07c..f12788de 100644
--- a/tools/input.c
+++ b/tools/input.c
@@ -63,7 +63,7 @@ sexp_get_char(struct sexp_input *input)
   if (input->coding)
     for (;;)
       {
-	unsigned done;
+	size_t done;
 
 	sexp_get_raw_char(input);
 	if (input->ctype == SEXP_EOF_CHAR)
diff --git a/tools/pkcs1-conv.c b/tools/pkcs1-conv.c
index 231b2acd..13b9ba05 100644
--- a/tools/pkcs1-conv.c
+++ b/tools/pkcs1-conv.c
@@ -128,9 +128,9 @@ pem_ws[33] = {
 
 /* Returns 1 on match, otherwise 0. */ 
 static int
-match_pem_start(unsigned length, const uint8_t *line,
-		unsigned *marker_start,
-		unsigned *marker_length)
+match_pem_start(size_t length, const uint8_t *line,
+		size_t *marker_start,
+		size_t *marker_length)
 {
   while (length > 0 && PEM_IS_SPACE(line[length - 1]))
     length--;
@@ -152,8 +152,8 @@ match_pem_start(unsigned length, const uint8_t *line,
 /* Returns 1 on match, -1 if the line is of the right form except for
    the marker, otherwise 0. */ 
 static int
-match_pem_end(unsigned length, const uint8_t *line,
-	      unsigned marker_length,
+match_pem_end(size_t length, const uint8_t *line,
+	      size_t marker_length,
 	      const uint8_t *marker)
 {
   while (length > 0 && PEM_IS_SPACE(line[length - 1]))
@@ -178,10 +178,10 @@ match_pem_end(unsigned length, const uint8_t *line,
 struct pem_info
 {
   /* The FOO part in "-----BEGIN FOO-----" */
-  unsigned marker_start;
-  unsigned marker_length;
-  unsigned data_start;
-  unsigned data_length;
+  size_t marker_start;
+  size_t marker_length;
+  size_t data_start;
+  size_t data_length;
 };
 
 static int
@@ -211,7 +211,7 @@ read_pem(struct nettle_buffer *buffer, FILE *f,
 
   for (;;)
     {
-      unsigned line_start = buffer->size;
+      size_t line_start = buffer->size;
 
       if (read_line(buffer, f) != 1)
 	return 0;
@@ -236,7 +236,7 @@ read_pem(struct nettle_buffer *buffer, FILE *f,
 
 static int
 decode_base64(struct nettle_buffer *buffer,
-	      unsigned start, unsigned *length)
+	      size_t start, size_t *length)
 {
   struct base64_decode_ctx ctx;
   
@@ -257,7 +257,7 @@ decode_base64(struct nettle_buffer *buffer,
 }
 
 static int
-convert_rsa_public_key(struct nettle_buffer *buffer, unsigned length, const uint8_t *data)
+convert_rsa_public_key(struct nettle_buffer *buffer, size_t length, const uint8_t *data)
 {
   struct rsa_public_key pub;
   int res;
@@ -281,7 +281,7 @@ convert_rsa_public_key(struct nettle_buffer *buffer, unsigned length, const uint
 }
 
 static int
-convert_rsa_private_key(struct nettle_buffer *buffer, unsigned length, const uint8_t *data)
+convert_rsa_private_key(struct nettle_buffer *buffer, size_t length, const uint8_t *data)
 {
   struct rsa_public_key pub;
   struct rsa_private_key priv;
@@ -309,7 +309,7 @@ convert_rsa_private_key(struct nettle_buffer *buffer, unsigned length, const uin
 }
 
 static int
-convert_dsa_private_key(struct nettle_buffer *buffer, unsigned length, const uint8_t *data)
+convert_dsa_private_key(struct nettle_buffer *buffer, size_t length, const uint8_t *data)
 {
   struct dsa_public_key pub;
   struct dsa_private_key priv;
@@ -338,7 +338,7 @@ convert_dsa_private_key(struct nettle_buffer *buffer, unsigned length, const uin
 
 /* Returns 1 on success, 0 on error, and -1 for unsupported algorithms. */
 static int
-convert_public_key(struct nettle_buffer *buffer, unsigned length, const uint8_t *data)
+convert_public_key(struct nettle_buffer *buffer, size_t length, const uint8_t *data)
 {
   /* SubjectPublicKeyInfo ::= SEQUENCE {
          algorithm		AlgorithmIdentifier,
@@ -459,7 +459,7 @@ convert_public_key(struct nettle_buffer *buffer, unsigned length, const uint8_t
 static int
 convert_type(struct nettle_buffer *buffer,
 	     enum object_type type,
-	     unsigned length, const uint8_t *data)
+	     size_t length, const uint8_t *data)
 {
   int res;