--- a/js/src/jsprf.cpp
+++ b/js/src/jsprf.cpp
@@ -58,67 +58,45 @@ struct NumArgState
 {
     int type;       // type of the current ap
     va_list ap;     // point to the corresponding position on ap
 };
 
 typedef mozilla::Vector<NumArgState, 20, js::SystemAllocPolicy> NumArgStateVector;
 
 
-#define TYPE_INT16      0
-#define TYPE_UINT16     1
+#define TYPE_SHORT      0
+#define TYPE_USHORT     1
 #define TYPE_INTN       2
 #define TYPE_UINTN      3
-#define TYPE_INT32      4
-#define TYPE_UINT32     5
-#define TYPE_INT64      6
-#define TYPE_UINT64     7
+#define TYPE_LONG       4
+#define TYPE_ULONG      5
+#define TYPE_LONGLONG   6
+#define TYPE_ULONGLONG  7
 #define TYPE_STRING     8
 #define TYPE_DOUBLE     9
 #define TYPE_INTSTR     10
-#define TYPE_WSTRING    11
+#define TYPE_POINTER    11
 #define TYPE_UNKNOWN    20
 
 #define FLAG_LEFT       0x1
 #define FLAG_SIGNED     0x2
 #define FLAG_SPACED     0x4
 #define FLAG_ZEROS      0x8
 #define FLAG_NEG        0x10
 
 inline bool
 generic_write(SprintfState* ss, const char* src, size_t srclen)
 {
     return (*ss->stuff)(ss, src, srclen);
 }
 
-inline bool
-generic_write(SprintfState* ss, const char16_t* src, size_t srclen)
-{
-    const size_t CHUNK_SIZE = 64;
-    char chunk[CHUNK_SIZE];
-
-    size_t j = 0;
-    size_t i = 0;
-    while (i < srclen) {
-        // FIXME: truncates characters to 8 bits
-        chunk[j++] = char(src[i++]);
-
-        if (j == CHUNK_SIZE || i == srclen) {
-            if (!(*ss->stuff)(ss, chunk, j))
-                return false;
-            j = 0;
-        }
-    }
-    return true;
-}
-
 // Fill into the buffer using the data in src
-template <typename Char>
 static bool
-fill2(SprintfState* ss, const Char* src, int srclen, int width, int flags)
+fill2(SprintfState* ss, const char* src, int srclen, int width, int flags)
 {
     char space = ' ';
 
     width -= srclen;
     if (width > 0 && (flags & FLAG_LEFT) == 0) {    // Right adjusting
         if (flags & FLAG_ZEROS)
             space = '0';
         while (--width >= 0) {
@@ -313,29 +291,26 @@ static bool cvt_f(SprintfState* ss, doub
     }
 #endif
     SprintfLiteral(fout, fin, d);
 
     return (*ss->stuff)(ss, fout, strlen(fout));
 }
 
 static inline const char* generic_null_str(const char*) { return "(null)"; }
-static inline const char16_t* generic_null_str(const char16_t*) { return u"(null)"; }
 
 static inline size_t generic_strlen(const char* s) { return strlen(s); }
-static inline size_t generic_strlen(const char16_t* s) { return js_strlen(s); }
 
 /*
  * Convert a string into its printable form.  "width" is the output
  * width. "prec" is the maximum number of characters of "s" to output,
  * where -1 means until NUL.
  */
-template <typename Char>
 static bool
-cvt_s(SprintfState* ss, const Char* s, int width, int prec, int flags)
+cvt_s(SprintfState* ss, const char* s, int width, int prec, int flags)
 {
     if (prec == 0)
         return true;
     if (!s)
         s = generic_null_str(s);
 
     // Limit string length by precision value
     int slen = int(generic_strlen(s));
@@ -447,33 +422,34 @@ BuildArgArray(const char* fmt, va_list a
             while ((c >= '0') && (c <= '9')) {
                 c = *p++;
             }
         }
 
         // size
         nas[cn].type = TYPE_INTN;
         if (c == 'h') {
-            nas[cn].type = TYPE_INT16;
+            nas[cn].type = TYPE_SHORT;
             c = *p++;
         } else if (c == 'L') {
-            // XXX not quite sure here
-            nas[cn].type = TYPE_INT64;
+            nas[cn].type = TYPE_LONGLONG;
             c = *p++;
         } else if (c == 'l') {
-            nas[cn].type = TYPE_INT32;
+            nas[cn].type = TYPE_LONG;
             c = *p++;
             if (c == 'l') {
-                nas[cn].type = TYPE_INT64;
+                nas[cn].type = TYPE_LONGLONG;
                 c = *p++;
             }
         } else if (c == 'z' || c == 'I') {
-            static_assert(sizeof(size_t) == sizeof(int32_t) || sizeof(size_t) == sizeof(int64_t),
+            static_assert(sizeof(size_t) == sizeof(int) || sizeof(size_t) == sizeof(long) ||
+                          sizeof(size_t) == sizeof(long long),
                           "size_t is not one of the expected sizes");
-            nas[cn].type = sizeof(size_t) == sizeof(int64_t) ? TYPE_INT64 : TYPE_INT32;
+            nas[cn].type = sizeof(size_t) == sizeof(int) ? TYPE_INTN :
+                sizeof(size_t) == sizeof(long) ? TYPE_LONG : TYPE_LONGLONG;
             c = *p++;
         }
 
         // format
         switch (c) {
         case 'd':
         case 'c':
         case 'i':
@@ -485,39 +461,30 @@ BuildArgArray(const char* fmt, va_list a
 
         case 'e':
         case 'f':
         case 'g':
             nas[cn].type = TYPE_DOUBLE;
             break;
 
         case 'p':
-            // XXX should use cpp
-            if (sizeof(void*) == sizeof(int32_t)) {
-                nas[cn].type = TYPE_UINT32;
-            } else if (sizeof(void*) == sizeof(int64_t)) {
-                nas[cn].type = TYPE_UINT64;
-            } else if (sizeof(void*) == sizeof(int)) {
-                nas[cn].type = TYPE_UINTN;
-            } else {
-                nas[cn].type = TYPE_UNKNOWN;
-            }
+            nas[cn].type = TYPE_POINTER;
             break;
 
         case 'C':
         case 'S':
         case 'E':
         case 'G':
             // XXX not supported I suppose
             MOZ_ASSERT(0);
             nas[cn].type = TYPE_UNKNOWN;
             break;
 
         case 's':
-            nas[cn].type = (nas[cn].type == TYPE_UINT16) ? TYPE_WSTRING : TYPE_STRING;
+            nas[cn].type = TYPE_STRING;
             break;
 
         case 'n':
             nas[cn].type = TYPE_INTSTR;
             break;
 
         default:
             MOZ_ASSERT(0);
@@ -539,28 +506,28 @@ BuildArgArray(const char* fmt, va_list a
         if (nas[cn].type == TYPE_UNKNOWN) {
             cn++;
             continue;
         }
 
         VARARGS_ASSIGN(nas[cn].ap, ap);
 
         switch (nas[cn].type) {
-        case TYPE_INT16:
-        case TYPE_UINT16:
+        case TYPE_SHORT:
+        case TYPE_USHORT:
         case TYPE_INTN:
         case TYPE_UINTN:        (void) va_arg(ap, int);         break;
-        case TYPE_INT32:        (void) va_arg(ap, int32_t);     break;
-        case TYPE_UINT32:       (void) va_arg(ap, uint32_t);    break;
-        case TYPE_INT64:        (void) va_arg(ap, int64_t);     break;
-        case TYPE_UINT64:       (void) va_arg(ap, uint64_t);    break;
+        case TYPE_LONG:         (void) va_arg(ap, long);        break;
+        case TYPE_ULONG:        (void) va_arg(ap, unsigned long); break;
+        case TYPE_LONGLONG:     (void) va_arg(ap, long long);   break;
+        case TYPE_ULONGLONG:    (void) va_arg(ap, unsigned long long); break;
         case TYPE_STRING:       (void) va_arg(ap, char*);       break;
-        case TYPE_WSTRING:      (void) va_arg(ap, char16_t*);   break;
         case TYPE_INTSTR:       (void) va_arg(ap, int*);        break;
         case TYPE_DOUBLE:       (void) va_arg(ap, double);      break;
+        case TYPE_POINTER:      (void) va_arg(ap, void*);       break;
 
         default: MOZ_CRASH();
         }
 
         cn++;
     }
 
     return true;
@@ -571,24 +538,23 @@ BuildArgArray(const char* fmt, va_list a
  */
 static bool
 dosprintf(SprintfState* ss, const char* fmt, va_list ap)
 {
     char c;
     int flags, width, prec, radix, type;
     union {
         char ch;
-        char16_t wch;
         int i;
         long l;
-        int64_t ll;
+        long long ll;
         double d;
         const char* s;
-        const char16_t* ws;
         int* ip;
+        void* p;
     } u;
     const char* fmt0;
     static const char hex[] = "0123456789abcdef";
     static const char HEX[] = "0123456789ABCDEF";
     const char* hexp;
     int i;
     char pattern[20];
     const char* dolPt = nullptr;  // in "%4$.2f", dolPt will point to '.'
@@ -680,33 +646,34 @@ dosprintf(SprintfState* ss, const char* 
                     c = *fmt++;
                 }
             }
         }
 
         // size
         type = TYPE_INTN;
         if (c == 'h') {
-            type = TYPE_INT16;
+            type = TYPE_SHORT;
             c = *fmt++;
         } else if (c == 'L') {
-            // XXX not quite sure here
-            type = TYPE_INT64;
+            type = TYPE_LONGLONG;
             c = *fmt++;
         } else if (c == 'l') {
-            type = TYPE_INT32;
+            type = TYPE_LONG;
             c = *fmt++;
             if (c == 'l') {
-                type = TYPE_INT64;
+                type = TYPE_LONGLONG;
                 c = *fmt++;
             }
         } else if (c == 'z' || c == 'I') {
-            static_assert(sizeof(size_t) == sizeof(int32_t) || sizeof(size_t) == sizeof(int64_t),
+            static_assert(sizeof(size_t) == sizeof(int) || sizeof(size_t) == sizeof(long) ||
+                          sizeof(size_t) == sizeof(long long),
                           "size_t is not one of the expected sizes");
-            type = sizeof(size_t) == sizeof(int64_t) ? TYPE_INT64 : TYPE_INT32;
+            type = sizeof(size_t) == sizeof(int) ? TYPE_INTN :
+                sizeof(size_t) == sizeof(long) ? TYPE_LONG : TYPE_LONGLONG;
             c = *fmt++;
         }
 
         // format
         hexp = hex;
         switch (c) {
           case 'd': case 'i':                   // decimal/integer
             radix = 10;
@@ -730,61 +697,64 @@ dosprintf(SprintfState* ss, const char* 
           case 'X':                             // unsigned HEX
             radix = 16;
             hexp = HEX;
             type |= 1;
             goto fetch_and_convert;
 
           fetch_and_convert:
             switch (type) {
-              case TYPE_INT16:
+              case TYPE_SHORT:
                 u.l = va_arg(ap, int);
                 if (u.l < 0) {
                     u.l = -u.l;
                     flags |= FLAG_NEG;
                 }
                 goto do_long;
-              case TYPE_UINT16:
-                u.l = va_arg(ap, int) & 0xffff;
+              case TYPE_USHORT:
+                u.l = (unsigned short) va_arg(ap, unsigned int);
                 goto do_long;
               case TYPE_INTN:
                 u.l = va_arg(ap, int);
                 if (u.l < 0) {
                     u.l = -u.l;
                     flags |= FLAG_NEG;
                 }
                 goto do_long;
               case TYPE_UINTN:
                 u.l = (long)va_arg(ap, unsigned int);
                 goto do_long;
 
-              case TYPE_INT32:
-                u.l = va_arg(ap, int32_t);
+              case TYPE_LONG:
+                u.l = va_arg(ap, long);
                 if (u.l < 0) {
                     u.l = -u.l;
                     flags |= FLAG_NEG;
                 }
                 goto do_long;
-              case TYPE_UINT32:
-                u.l = (long)va_arg(ap, uint32_t);
+              case TYPE_ULONG:
+                u.l = (long)va_arg(ap, unsigned long);
               do_long:
                 if (!cvt_l(ss, u.l, width, prec, radix, type, flags, hexp))
                     return false;
 
                 break;
 
-              case TYPE_INT64:
-                u.ll = va_arg(ap, int64_t);
+              case TYPE_LONGLONG:
+                u.ll = va_arg(ap, long long);
                 if (u.ll < 0) {
                     u.ll = -u.ll;
                     flags |= FLAG_NEG;
                 }
                 goto do_longlong;
-              case TYPE_UINT64:
-                u.ll = va_arg(ap, uint64_t);
+              case TYPE_POINTER:
+                u.ll = (uintptr_t)va_arg(ap, void*);
+                goto do_longlong;
+              case TYPE_ULONGLONG:
+                u.ll = va_arg(ap, unsigned long long);
               do_longlong:
                 if (!cvt_ll(ss, u.ll, width, prec, radix, type, flags, hexp))
                     return false;
 
                 break;
             }
             break;
 
@@ -811,65 +781,50 @@ dosprintf(SprintfState* ss, const char* 
           case 'c':
             if ((flags & FLAG_LEFT) == 0) {
                 while (width-- > 1) {
                     if (!(*ss->stuff)(ss, " ", 1))
                         return false;
                 }
             }
             switch (type) {
-              case TYPE_INT16:
+              case TYPE_SHORT:
               case TYPE_INTN:
                 u.ch = va_arg(ap, int);
                 if (!(*ss->stuff)(ss, &u.ch, 1))
                     return false;
                 break;
             }
             if (flags & FLAG_LEFT) {
                 while (width-- > 1) {
                     if (!(*ss->stuff)(ss, " ", 1))
                         return false;
                 }
             }
             break;
 
           case 'p':
-            if (sizeof(void*) == sizeof(int32_t)) {
-                type = TYPE_UINT32;
-            } else if (sizeof(void*) == sizeof(int64_t)) {
-                type = TYPE_UINT64;
-            } else if (sizeof(void*) == sizeof(int)) {
-                type = TYPE_UINTN;
-            } else {
-                MOZ_ASSERT(0);
-                break;
-            }
+            type = TYPE_POINTER;
             radix = 16;
             goto fetch_and_convert;
 
 #if 0
           case 'C':
           case 'S':
           case 'E':
           case 'G':
             // XXX not supported I suppose
             MOZ_ASSERT(0);
             break;
 #endif
 
           case 's':
-            if(type == TYPE_INT16) {
-                u.ws = va_arg(ap, const char16_t*);
-                if (!cvt_s(ss, u.ws, width, prec, flags))
-                    return false;
-            } else {
-                u.s = va_arg(ap, const char*);
-                if (!cvt_s(ss, u.s, width, prec, flags))
-                    return false;
-            }
+            u.s = va_arg(ap, const char*);
+            if (!cvt_s(ss, u.s, width, prec, flags))
+                return false;
             break;
 
           case 'n':
             u.ip = va_arg(ap, int*);
             if (u.ip) {
                 *u.ip = ss->cur - ss->base;
             }
             break;
@@ -999,27 +954,27 @@ JS_vsprintf_append(char* last, const cha
     }
     if (!dosprintf(&ss, fmt, ap)) {
         js_free(ss.base);
         return 0;
     }
     return ss.base;
 }
 
-#undef TYPE_INT16
-#undef TYPE_UINT16
+#undef TYPE_SHORT
+#undef TYPE_USHORT
 #undef TYPE_INTN
 #undef TYPE_UINTN
-#undef TYPE_INT32
-#undef TYPE_UINT32
-#undef TYPE_INT64
-#undef TYPE_UINT64
+#undef TYPE_LONG
+#undef TYPE_ULONG
+#undef TYPE_LONGLONG
+#undef TYPE_ULONGLONG
 #undef TYPE_STRING
 #undef TYPE_DOUBLE
 #undef TYPE_INTSTR
-#undef TYPE_WSTRING
+#undef TYPE_POINTER
 #undef TYPE_UNKNOWN
 
 #undef FLAG_LEFT
 #undef FLAG_SIGNED
 #undef FLAG_SPACED
 #undef FLAG_ZEROS
 #undef FLAG_NEG

--- a/js/src/jsprf.h
+++ b/js/src/jsprf.h
@@ -9,21 +9,23 @@
 
 /*
 ** API for PR printf like routines. Supports the following formats
 **      %d - decimal
 **      %u - unsigned decimal
 **      %x - unsigned hex
 **      %X - unsigned uppercase hex
 **      %o - unsigned octal
-**      %hd, %hu, %hx, %hX, %ho - 16-bit versions of above
-**      %ld, %lu, %lx, %lX, %lo - 32-bit versions of above
-**      %lld, %llu, %llx, %llX, %llo - 64 bit versions of above
-**      %s - ascii string
-**      %hs - ucs2 string
+**      %hd, %hu, %hx, %hX, %ho - "short" versions of above
+**      %ld, %lu, %lx, %lX, %lo - "long" versions of above
+**      %lld, %llu, %llx, %llX, %llo - "long long" versions of above
+**      %zd, %zo, %zu, %zx, %zX - size_t versions of above
+**      %Id, %Io, %Iu, %Ix, %IX - size_t versions of above (for Windows compat)
+**           You should use PRI*SIZE macros instead
+**      %s - string
 **      %c - character
 **      %p - pointer (deals with machine dependent pointer size)
 **      %f - float
 **      %g - float
 */
 
 #include "mozilla/IntegerPrintfMacros.h"
 #include "mozilla/SizePrintfMacros.h"