@@ -566,7 +566,7 @@ cl_error_t cli_bcomp_compare_check(const unsigned char *f_buffer, size_t buffer_

     uint16_t opt              = 0;

     uint16_t opt_val          = 0;

     int64_t value             = 0;

-    uint64_t bin_value        = 0;

+    int64_t bin_value         = 0;

     int16_t compare_check     = 0;

     unsigned char *end_buf    = NULL;

     unsigned char *buffer     = NULL;

@@ -716,16 +716,16 @@ cl_error_t cli_bcomp_compare_check(const unsigned char *f_buffer, size_t buffer_

             /* exact byte_length option is implied for binary extraction */

             switch (byte_len) {

                 case 1:

-                    bin_value = (*(uint8_t *)f_buffer);

+                    bin_value = (int64_t)(*(uint8_t *)f_buffer);

                     break;

                 case 2:

-                    bin_value = (uint16_t)le16_to_host(*(uint16_t *)f_buffer);

+                    bin_value = (int64_t)le16_to_host(*(uint16_t *)f_buffer);

                     break;

                 case 4:

-                    bin_value = (uint32_t)le32_to_host(*(uint32_t *)f_buffer);

+                    bin_value = (int64_t)le32_to_host(*(uint32_t *)f_buffer);

                     break;

                 case 8:

-                    bin_value = (uint64_t)le64_to_host(*(uint64_t *)f_buffer);

+                    bin_value = (int64_t)le64_to_host(*(uint64_t *)f_buffer);

                     break;

                 default:

@@ -740,16 +740,16 @@ cl_error_t cli_bcomp_compare_check(const unsigned char *f_buffer, size_t buffer_

             /* exact byte_length option is implied for binary extraction */

             switch (byte_len) {

                 case 1:

-                    bin_value = (*(uint8_t *)f_buffer);

+                    bin_value = (int64_t)(*(uint8_t *)f_buffer);

                     break;

                 case 2:

-                    bin_value = (uint16_t)be16_to_host(*(uint16_t *)f_buffer);

+                    bin_value = (int64_t)be16_to_host(*(uint16_t *)f_buffer);

                     break;

                 case 4:

-                    bin_value = (uint32_t)be32_to_host(*(uint32_t *)f_buffer);

+                    bin_value = (int64_t)be32_to_host(*(uint32_t *)f_buffer);

                     break;

                 case 8:

-                    bin_value = (uint64_t)be64_to_host(*(uint64_t *)f_buffer);

+                    bin_value = (int64_t)be64_to_host(*(uint64_t *)f_buffer);

                     break;

                 default:

@@ -4065,7 +4065,7 @@ do_multipart(message *mainMessage, message **messages, int i, mbox_status *rc, m

         fileblob *fb = messageToFileblob(aMessage, mctx->dir, 1);

 #if HAVE_JSON

         json_object *arrobj;

-        int arrlen = 0;

+        size_t arrlen = 0;

         if (thisobj != NULL) {

             /* attempt to determine container size - prevents incorrect type reporting */

@@ -4096,7 +4096,7 @@ do_multipart(message *mainMessage, message **messages, int i, mbox_status *rc, m

                 if (entry)

                     dtype = json_object_get_string(entry);

             }

-            cli_jsonint(thisobj, "ContainedObjectsIndex", arrlen);

+            cli_jsonint(thisobj, "ContainedObjectsIndex", (uint32_t)arrlen);

             cli_jsonstr(thisobj, "ClamAVFileType", dtype ? dtype : "UNKNOWN");

         }

 #endif

@@ -95,6 +95,8 @@ static void msxml_error_handler(void *arg, const char *msg, xmlParserSeverities

     int line     = xmlTextReaderLocatorLineNumber(locator);

     xmlChar *URI = xmlTextReaderLocatorBaseURI(locator);

+    UNUSEDPARAM(arg);

+

     switch (severity) {

         case XML_PARSER_SEVERITY_WARNING:

         case XML_PARSER_SEVERITY_VALIDITY_WARNING:

@@ -76,8 +76,6 @@

 struct pdf_struct;

-static int asciihexdecode(const char *buf, off_t len, char *output);

-static int ascii85decode(const char *buf, off_t len, unsigned char *output);

 static const char *pdf_nextlinestart(const char *ptr, size_t len);

 static const char *pdf_nextobject(const char *ptr, size_t len);

@@ -3205,7 +3203,7 @@ cl_error_t pdf_find_and_extract_objs(struct pdf_struct *pdf, uint32_t *alerts)

          * a password to decrypt */

         status = cli_append_virus(pdf->ctx, "Heuristics.Encrypted.PDF");

         if (status == CL_VIRUS) {

-            *alerts++;

+            *alerts += 1;

             if (SCAN_ALLMATCHES)

                 status = CL_CLEAN;

         }

@@ -3215,7 +3213,7 @@ cl_error_t pdf_find_and_extract_objs(struct pdf_struct *pdf, uint32_t *alerts)

         status = run_pdf_hooks(pdf, PDF_PHASE_PARSED, -1, -1);

         cli_dbgmsg("pdf_find_and_extract_objs: (parsed hooks) returned %d\n", status);

         if (status == CL_VIRUS) {

-            *alerts++;

+            *alerts += 1;

             if (SCAN_ALLMATCHES) {

                 status = CL_CLEAN;

             }

@@ -3243,7 +3241,7 @@ cl_error_t pdf_find_and_extract_objs(struct pdf_struct *pdf, uint32_t *alerts)

                 status = CL_CLEAN;

                 break;

             case CL_VIRUS:

-                *alerts++;

+                *alerts += 1;

                 if (SCAN_ALLMATCHES) {

                     status = CL_CLEAN;

                 }

@@ -196,7 +196,7 @@ cli_regcomp_real(regex_t *preg, const char *pattern, int cflags)

 		return(REG_ESPACE);

 	}

 	p->ssize = len/(size_t)2*(size_t)3 + (size_t)1;	/* ugh */

-	assert(p->ssize >= len);

+	assert((size_t)p->ssize >= len);

 	p->strip = (sop *)cli_calloc(p->ssize, sizeof(sop));

 	p->slen = 0;

@@ -2660,7 +2660,7 @@ static void get_thread_times(uint64_t *kt, uint64_t *ut)

     *ut         = ul.QuadPart / 10;

 #else

     struct tms tbuf;

-    if (times(&tbuf) != -1) {

+    if (times(&tbuf) != ((clock_t)-1)) {

         clock_t tck = sysconf(_SC_CLK_TCK);

         *kt         = ((uint64_t)1000000) * tbuf.tms_stime / tck;

         *ut         = ((uint64_t)1000000) * tbuf.tms_utime / tck;

@@ -3958,7 +3958,6 @@ static cl_error_t cli_base_scandesc(int desc, const char *filepath, cli_ctx *ctx

 {

     STATBUF sb;

     cl_error_t status = CL_CLEAN;

-    cl_error_t ret    = CL_CLEAN;

     if (!ctx) {

         return CL_EARG;

@@ -861,7 +861,7 @@ cl_error_t cli_strntoul_wrap(const char *buf, size_t buf_size,

                              unsigned long *result)

 {

     char *endptr = NULL;

-    long num;

+    unsigned long num;

     if (buf_size == 0 || !buf || !result) {

         /* invalid parameter */

@@ -869,7 +869,7 @@ cl_error_t cli_strntoul_wrap(const char *buf, size_t buf_size,

     }

     errno = 0;

     num   = cli_strntoul(buf, buf_size, &endptr, base);

-    if (num == ULONG_MAX && errno == ERANGE) {

+    if ((num == ULONG_MAX) && (errno == ERANGE)) {

         /* under- or overflow */

         return CL_EPARSE;

     }

@@ -887,7 +887,7 @@ cl_error_t cli_strntoul_wrap(const char *buf, size_t buf_size,

 }

 size_t cli_ldbtokenize(char *buffer, const char delim, const size_t token_count,

-                       const char **tokens, int token_skip)

+                       const char **tokens, size_t token_skip)

 {

     size_t tokens_found, i;

     int within_pcre = 0;

@@ -32,7 +32,7 @@

 #include "clamav.h"

 #include "clamav.h"

-#define SIZE_T_CHARLEN ( (sizeof(size_t) * CHAR_BIT + 2) / 3 + 1 )

+#define SIZE_T_CHARLEN ((sizeof(size_t) * CHAR_BIT + 2) / 3 + 1)

 #ifdef HAVE_STRCASESTR

 #define cli_strcasestr strcasestr

@@ -67,7 +67,7 @@ int cli_chomp(char *string);

 char *cli_strtok(const char *line, int field, const char *delim);

 int cli_realhex2ui(const char *hex, uint16_t *ptr, unsigned int len);

 uint16_t *cli_hex2ui(const char *hex);

-int  cli_hex2str_to(const char *hex, char *ptr, size_t len);

+int cli_hex2str_to(const char *hex, char *ptr, size_t len);

 char *cli_hex2str(const char *hex);

 int cli_hex2num(const char *hex);

 int cli_xtoi(const char *hex);

@@ -77,15 +77,15 @@ char *cli_strtokbuf(const char *input, int fieldno, const char *delim, char *out

 const char *cli_memstr(const char *haystack, size_t hs, const char *needle, size_t ns);

 char *cli_strrcpy(char *dest, const char *source);

 size_t cli_strtokenize(char *buffer, const char delim, const size_t token_count, const char **tokens);

-size_t cli_ldbtokenize(char *buffer, const char delim, const size_t token_count, const char **tokens, int token_skip);

-long cli_strntol(const char* nptr, size_t n, char** endptr, register int base);

-unsigned long cli_strntoul(const char* nptr, size_t n, char** endptr, register int base);

+size_t cli_ldbtokenize(char *buffer, const char delim, const size_t token_count, const char **tokens, size_t token_skip);

+long cli_strntol(const char *nptr, size_t n, char **endptr, register int base);

+unsigned long cli_strntoul(const char *nptr, size_t n, char **endptr, register int base);

 cl_error_t cli_strntol_wrap(const char *buf, size_t buf_size, int fail_at_nondigit, int base, long *result);

 cl_error_t cli_strntoul_wrap(const char *buf, size_t buf_size, int fail_at_nondigit, int base, unsigned long *result);

 int cli_isnumber(const char *str);

 char *cli_unescape(const char *str);

 struct text_buffer;

-int  cli_textbuffer_append_normalize(struct text_buffer *buf, const char *str, size_t len);

+int cli_textbuffer_append_normalize(struct text_buffer *buf, const char *str, size_t len);

 int cli_hexnibbles(char *str, int len);

 typedef enum {