Make modp_b64 and base::base64 compile on Win64

third_party/modp_b64/modp_b64.cc

 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 /* vi: set expandtab shiftwidth=4 tabstop=4: */
 /**
  * \file
  * <PRE>
  * MODP_B64 - High performance base64 encoder/decoder
  * Version 1.3 -- 17-Mar-2006
  * http://modp.com/release/base64
  *
  * Copyright &copy; 2005, 2006  Nick Galbreath -- nickg [at] modp [dot] com
@@ skipping 59 matching lines @@
 
 /*
  * if we aren't doing padding
  * set the pad character to NULL
  */
 #ifndef DOPAD
 #undef CHARPAD
 #define CHARPAD '\0'
 #endif
 
-int modp_b64_encode(char* dest, const char* str, int len)
+size_t modp_b64_encode(char* dest, const char* str, size_t len)
 {
-    int i;
+    size_t i = 0;
     uint8_t* p = (uint8_t*) dest;
 
     /* unsigned here is important! */
     uint8_t t1, t2, t3;
 
-    for (i = 0; i < len - 2; i += 3) {
-        t1 = str[i]; t2 = str[i+1]; t3 = str[i+2];
-        *p++ = e0[t1];
-        *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
-        *p++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
-        *p++ = e2[t3];
+    if (len > 2) {
+        for (; i < len - 2; i += 3) {
+            t1 = str[i]; t2 = str[i+1]; t3 = str[i+2];
+            *p++ = e0[t1];
+            *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *p++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+            *p++ = e2[t3];
+        }
     }
 
     switch (len - i) {
     case 0:
         break;
     case 1:
         t1 = str[i];
         *p++ = e0[t1];
         *p++ = e1[(t1 & 0x03) << 4];
         *p++ = CHARPAD;
@@ skipping 13 matching lines @@
 
 #ifdef WORDS_BIGENDIAN   /* BIG ENDIAN -- SUN / IBM / MOTOROLA */
 int modp_b64_decode(char* dest, const char* src, int len)
 {
     if (len == 0) return 0;
 
 #ifdef DOPAD
     /* if padding is used, then the message must be at least
        4 chars and be a multiple of 4.
        there can be at most 2 pad chars at the end */
-    if (len < 4 || (len % 4 != 0)) return -1;
+    if (len < 4 || (len % 4 != 0)) return MODP_B64_ERROR;
     if (src[len-1] == CHARPAD) {
         len--;
         if (src[len -1] == CHARPAD) {
             len--;
         }
     }
 #endif  /* DOPAD */
 
-    int i;
+    size_t i;
     int leftover = len % 4;
-    int chunks = (leftover == 0) ? len / 4 - 1 : len /4;
+    size_t chunks = (leftover == 0) ? len / 4 - 1 : len /4;
 
     uint8_t* p = (uint8_t*) dest;
     uint32_t x = 0;
     uint32_t* destInt = (uint32_t*) p;
     uint32_t* srcInt = (uint32_t*) src;
     uint32_t y = *srcInt++;
     for (i = 0; i < chunks; ++i) {
         x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] |
             d2[y >> 8 & 0xff] | d3[y & 0xff];
 
-        if (x >= BADCHAR)  return -1;
+        if (x >= BADCHAR)  return MODP_B64_ERROR;
         *destInt = x << 8;
         p += 3;
         destInt = (uint32_t*)p;
         y = *srcInt++;
     }
 
     switch (leftover) {
     case 0:
         x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] |
             d2[y >>  8 & 0xff] | d3[y & 0xff];
-        if (x >= BADCHAR)  return -1;
+        if (x >= BADCHAR)  return MODP_B64_ERROR;
         *p++ = ((uint8_t*)&x)[1];
         *p++ = ((uint8_t*)&x)[2];
         *p = ((uint8_t*)&x)[3];
         return (chunks+1)*3;
     case 1:
         x = d3[y >> 24];
         *p =  (uint8_t)x;
         break;
     case 2:
         x = d3[y >> 24] *64 + d3[(y >> 16) & 0xff];
         *p =  (uint8_t)(x >> 4);
         break;
     default:  /* case 3 */
         x = (d3[y >> 24] *64 + d3[(y >> 16) & 0xff])*64 +
             d3[(y >> 8) & 0xff];
         *p++ = (uint8_t) (x >> 10);
         *p = (uint8_t) (x >> 2);
         break;
     }
 
-    if (x >= BADCHAR) return -1;
+    if (x >= BADCHAR) return MODP_B64_ERROR;
     return 3*chunks + (6*leftover)/8;
 }
 
 #else /* LITTLE  ENDIAN -- INTEL AND FRIENDS */
 
-int modp_b64_decode(char* dest, const char* src, int len)
+size_t modp_b64_decode(char* dest, const char* src, size_t len)
 {
     if (len == 0) return 0;
 
 #ifdef DOPAD
     /*
      * if padding is used, then the message must be at least
      * 4 chars and be a multiple of 4
      */
-    if (len < 4 || (len % 4 != 0)) return -1; /* error */
+    if (len < 4 || (len % 4 != 0)) return MODP_B64_ERROR; /* error */
     /* there can be at most 2 pad chars at the end */
     if (src[len-1] == CHARPAD) {
         len--;
         if (src[len -1] == CHARPAD) {
             len--;
         }
     }
 #endif
 
-    int i;
+    size_t i;
     int leftover = len % 4;
-    int chunks = (leftover == 0) ? len / 4 - 1 : len /4;
+    size_t chunks = (leftover == 0) ? len / 4 - 1 : len /4;
 
     uint8_t* p = (uint8_t*)dest;
     uint32_t x = 0;
     uint32_t* destInt = (uint32_t*) p;
     uint32_t* srcInt = (uint32_t*) src;
     uint32_t y = *srcInt++;
     for (i = 0; i < chunks; ++i) {
         x = d0[y & 0xff] |
             d1[(y >> 8) & 0xff] |
             d2[(y >> 16) & 0xff] |
             d3[(y >> 24) & 0xff];
 
-        if (x >= BADCHAR) return -1;
+        if (x >= BADCHAR) return MODP_B64_ERROR;
         *destInt = x ;
         p += 3;
         destInt = (uint32_t*)p;
         y = *srcInt++;}
 
 
     switch (leftover) {
     case 0:
         x = d0[y & 0xff] |
             d1[(y >> 8) & 0xff] |
             d2[(y >> 16) & 0xff] |
             d3[(y >> 24) & 0xff];
 
-        if (x >= BADCHAR) return -1;
+        if (x >= BADCHAR) return MODP_B64_ERROR;
         *p++ =  ((uint8_t*)(&x))[0];
         *p++ =  ((uint8_t*)(&x))[1];
         *p =    ((uint8_t*)(&x))[2];
         return (chunks+1)*3;
         break;
     case 1:  /* with padding this is an impossible case */
         x = d0[y & 0xff];
         *p = *((uint8_t*)(&x)); // i.e. first char/byte in int
         break;
     case 2: // * case 2, 1  output byte */
         x = d0[y & 0xff] | d1[y >> 8 & 0xff];
         *p = *((uint8_t*)(&x)); // i.e. first char
         break;
     default: /* case 3, 2 output bytes */
         x = d0[y & 0xff] |
             d1[y >> 8 & 0xff ] |
             d2[y >> 16 & 0xff];  /* 0x3c */
         *p++ =  ((uint8_t*)(&x))[0];
         *p =  ((uint8_t*)(&x))[1];
         break;
     }
 
-    if (x >= BADCHAR) return -1;
+    if (x >= BADCHAR) return MODP_B64_ERROR;
 
     return 3*chunks + (6*leftover)/8;
 }
 
 #endif  /* if bigendian / else / endif */