Make modp_b64 and base::base64 compile on Win64

third_party/modp_b64/modp_b64.h

 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 /* vi: set expandtab shiftwidth=4 tabstop=4: */
 
 /**
  * \file
  * <PRE>
  * High performance base64 encoder / decoder
  * Version 1.3 -- 17-Mar-2006
  *
  * Copyright &copy; 2005, 2006, Nick Galbreath -- nickg [at] modp [dot] com
  * All rights reserved.
  *
  * http://modp.com/release/base64
  *
  * Released under bsd license.  See modp_b64.c for details.
  * </pre>
  *
  * The default implementation is the standard b64 encoding with padding.
  * It's easy to change this to use "URL safe" characters and to remove
  * padding.  See the modp_b64.c source code for details.
  *
  */
 
 #ifndef MODP_B64
 #define MODP_B64
 
+#include <stddef.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
  * Encode a raw binary string into base 64.
  * src contains the bytes
  * len contains the number of bytes in the src
  * dest should be allocated by the caller to contain
  *   at least modp_b64_encode_len(len) bytes (see below)
  *   This will contain the null-terminated b64 encoded result
  * returns length of the destination string plus the ending null byte
  *    i.e.  the result will be equal to strlen(dest) + 1
  *
  * Example
  * 
  * \code
  * char* src = ...;
  * int srclen = ...; //the length of number of bytes in src
  * char* dest = (char*) malloc(modp_b64_encode_len);
  * int len = modp_b64_encode(dest, src, sourcelen);
  * if (len == -1) {
  *   printf("Error\n");
  * } else {
  *   printf("b64 = %s\n", dest);
  * }
  * \endcode
  *
  */
-int modp_b64_encode(char* dest, const char* str, int len);
+size_t modp_b64_encode(char* dest, const char* str, size_t len);
 
 /**
  * Decode a base64 encoded string
  *
  * src should contain exactly len bytes of b64 characters.
  *     if src contains -any- non-base characters (such as white
  *     space, -1 is returned.
  *
  * dest should be allocated by the caller to contain at least
  *    len * 3 / 4 bytes.
  *
  * Returns the length (strlen) of the output, or -1 if unable to
  * decode
  *
  * \code
  * char* src = ...;
  * int srclen = ...; // or if you don't know use strlen(src)
  * char* dest = (char*) malloc(modp_b64_decode_len(srclen));
  * int len = modp_b64_decode(dest, src, sourcelen);
  * if (len == -1) { error }
  * \endcode
  */
-int modp_b64_decode(char* dest, const char* src, int len);
+size_t modp_b64_decode(char* dest, const char* src, size_t len);
 
 /**
  * Given a source string of length len, this returns the amount of
  * memory the destination string should have.
  *
  * remember, this is integer math
  * 3 bytes turn into 4 chars
  * ceiling[len / 3] * 4 + 1
  *
  * +1 is for any extra null.
@@ skipping 29 matching lines @@
  *    if (modp_b64_decode((char*) &foo, b64encoded, len) == -1) {
  *      // bad characters
  *      return false;
  *    }
  * }
  * // foo is filled out now
  * \endcode
  */
 #define modp_b64_encode_strlen(A) ((A + 2)/ 3 * 4)
 
+#define MODP_B64_ERROR ((size_t)-1)
+
 #ifdef __cplusplus
 }
 
 #include <string>
 
 inline std::string& modp_b64_encode(std::string& s)
 {
     std::string x(modp_b64_encode_len(s.size()), '\0');
-    int d = modp_b64_encode(const_cast<char*>(x.data()), s.data(), s.size());
+    size_t d = modp_b64_encode(const_cast<char*>(x.data()), s.data(), (int)s.size());
     x.erase(d, std::string::npos);
     s.swap(x);
     return s;
 }
 
 /**
  * base 64 decode a string (self-modifing)
  * On failure, the string is empty.
  *
  * This function is for C++ only (duh)
  *
  * \param[in,out] s the string to be decoded
  * \return a reference to the input string
  */
 inline std::string& modp_b64_decode(std::string& s)
 {
     std::string x(modp_b64_decode_len(s.size()), '\0');
-    int d = modp_b64_decode(const_cast<char*>(x.data()), s.data(), s.size());
-    if (d < 0) {
+    size_t d = modp_b64_decode(const_cast<char*>(x.data()), s.data(), (int)s.size());
+    if (d == MODP_B64_ERROR) {
         x.clear();
     } else {
         x.erase(d, std::string::npos);
     }
     s.swap(x);
     return s;
 }
 
 #endif /* __cplusplus */
 
 #endif /* MODP_B64 */