xpcom/glue/nsCRTGlue.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsCRTGlue.h"
   8 #include "nsXPCOM.h"
   9 #include "nsDebug.h"
  10 #include "prtime.h"
  11
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <stdio.h>
  15 #include <stdarg.h>
  16
  17 #ifdef XP_WIN
  18 #include <io.h>
  19 #include <windows.h>
  20 #endif
  21
  22 #ifdef ANDROID
  23 #include <android/log.h>
  24 #endif
  25
  26 const char*
  27 NS_strspnp(const char* aDelims, const char* aStr)
  28 {
  29   const char* d;
  30   do {
  31     for (d = aDelims; *d != '\0'; ++d) {
  32       if (*aStr == *d) {
  33         ++aStr;
  34         break;
  35       }
  36     }
  37   } while (*d);
  38
  39   return aStr;
  40 }
  41
  42 char*
  43 NS_strtok(const char* aDelims, char** aStr)
  44 {
  45   if (!*aStr) {
  46     return nullptr;
  47   }
  48
  49   char* ret = (char*)NS_strspnp(aDelims, *aStr);
  50
  51   if (!*ret) {
  52     *aStr = ret;
  53     return nullptr;
  54   }
  55
  56   char* i = ret;
  57   do {
  58     for (const char* d = aDelims; *d != '\0'; ++d) {
  59       if (*i == *d) {
  60         *i = '\0';
  61         *aStr = ++i;
  62         return ret;
  63       }
  64     }
  65     ++i;
  66   } while (*i);
  67
  68   *aStr = nullptr;
  69   return ret;
  70 }
  71
  72 uint32_t
  73 NS_strlen(const char16_t* aString)
  74 {
  75   const char16_t* end;
  76
  77   for (end = aString; *end; ++end) {
  78     // empty loop
  79   }
  80
  81   return end - aString;
  82 }
  83
  84 int
  85 NS_strcmp(const char16_t* aStrA, const char16_t* aStrB)
  86 {
  87   while (*aStrB) {
  88     int r = *aStrA - *aStrB;
  89     if (r) {
  90       return r;
  91     }
  92
  93     ++aStrA;
  94     ++aStrB;
  95   }
  96
  97   return *aStrA != '\0';
  98 }
  99
 100 char16_t*
 101 NS_strdup(const char16_t* aString)
 102 {
 103   uint32_t len = NS_strlen(aString);
 104   return NS_strndup(aString, len);
 105 }
 106
 107 char16_t*
 108 NS_strndup(const char16_t* aString, uint32_t aLen)
 109 {
 110   char16_t* newBuf = (char16_t*)NS_Alloc((aLen + 1) * sizeof(char16_t));
 111   if (newBuf) {
 112     memcpy(newBuf, aString, aLen * sizeof(char16_t));
 113     newBuf[aLen] = '\0';
 114   }
 115   return newBuf;
 116 }
 117
 118 char*
 119 NS_strdup(const char* aString)
 120 {
 121   uint32_t len = strlen(aString);
 122   char* str = (char*)NS_Alloc(len + 1);
 123   if (str) {
 124     memcpy(str, aString, len);
 125     str[len] = '\0';
 126   }
 127   return str;
 128 }
 129
 130 // This table maps uppercase characters to lower case characters;
 131 // characters that are neither upper nor lower case are unaffected.
 132 const unsigned char nsLowerUpperUtils::kUpper2Lower[256] = {
 133     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 134    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 135    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 136    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 137    64,
 138
 139     // upper band mapped to lower [A-Z] => [a-z]
 140        97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 141   112,113,114,115,116,117,118,119,120,121,122,
 142
 143                                                91, 92, 93, 94, 95,
 144    96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 145   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
 146   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 147   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 148   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 149   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 150   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 151   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 152   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 153   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
 154 };
 155
 156 const unsigned char nsLowerUpperUtils::kLower2Upper[256] = {
 157     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 158    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 159    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 160    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 161    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 162    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
 163    96,
 164
 165     // lower band mapped to upper [a-z] => [A-Z]
 166        65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 167    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
 168
 169                                               123,124,125,126,127,
 170   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 171   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 172   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 173   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 174   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 175   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 176   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 177   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
 178 };
 179
 180 bool
 181 NS_IsUpper(char aChar)
 182 {
 183   return aChar != (char)nsLowerUpperUtils::kUpper2Lower[(unsigned char)aChar];
 184 }
 185
 186 bool
 187 NS_IsLower(char aChar)
 188 {
 189   return aChar != (char)nsLowerUpperUtils::kLower2Upper[(unsigned char)aChar];
 190 }
 191
 192 bool
 193 NS_IsAscii(char16_t aChar)
 194 {
 195   return (0x0080 > aChar);
 196 }
 197
 198 bool
 199 NS_IsAscii(const char16_t* aString)
 200 {
 201   while (*aString) {
 202     if (0x0080 <= *aString) {
 203       return false;
 204     }
 205     aString++;
 206   }
 207   return true;
 208 }
 209
 210 bool
 211 NS_IsAscii(const char* aString)
 212 {
 213   while (*aString) {
 214     if (0x80 & *aString) {
 215       return false;
 216     }
 217     aString++;
 218   }
 219   return true;
 220 }
 221
 222 bool
 223 NS_IsAscii(const char* aString, uint32_t aLength)
 224 {
 225   const char* end = aString + aLength;
 226   while (aString < end) {
 227     if (0x80 & *aString) {
 228       return false;
 229     }
 230     ++aString;
 231   }
 232   return true;
 233 }
 234
 235 bool
 236 NS_IsAsciiAlpha(char16_t aChar)
 237 {
 238   return (aChar >= 'A' && aChar <= 'Z') ||
 239          (aChar >= 'a' && aChar <= 'z');
 240 }
 241
 242 bool
 243 NS_IsAsciiWhitespace(char16_t aChar)
 244 {
 245   return aChar == ' ' ||
 246          aChar == '\r' ||
 247          aChar == '\n' ||
 248          aChar == '\t';
 249 }
 250
 251 bool
 252 NS_IsAsciiDigit(char16_t aChar)
 253 {
 254   return aChar >= '0' && aChar <= '9';
 255 }
 256
 257
 258 #ifndef XPCOM_GLUE_AVOID_NSPR
 259 #define TABLE_SIZE 36
 260 static const char table[] = {
 261   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
 262   'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
 263   'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
 264   '4', '5', '6', '7', '8', '9'
 265 };
 266
 267 void
 268 NS_MakeRandomString(char* aBuf, int32_t aBufLen)
 269 {
 270   // turn PR_Now() into milliseconds since epoch
 271   // and salt rand with that.
 272   static unsigned int seed = 0;
 273   if (seed == 0) {
 274     double fpTime = double(PR_Now());
 275     seed = (unsigned int)(fpTime * 1e-6 + 0.5); // use 1e-6, granularity of PR_Now() on the mac is seconds
 276     srand(seed);
 277   }
 278
 279   int32_t i;
 280   for (i = 0; i < aBufLen; ++i) {
 281     *aBuf++ = table[rand() % TABLE_SIZE];
 282   }
 283   *aBuf = 0;
 284 }
 285
 286 #endif
 287
 288 static StderrCallback sStderrCallback = nullptr;
 289
 290 void
 291 set_stderr_callback(StderrCallback aCallback)
 292 {
 293   sStderrCallback = aCallback;
 294 }
 295
 296 #ifdef HAVE_VA_COPY
 297 #define VARARGS_ASSIGN(foo, bar)        VA_COPY(foo,bar)
 298 #elif defined(HAVE_VA_LIST_AS_ARRAY)
 299 #define VARARGS_ASSIGN(foo, bar)     foo[0] = bar[0]
 300 #else
 301 #define VARARGS_ASSIGN(foo, bar)     (foo) = (bar)
 302 #endif
 303
 304 #if defined(XP_WIN)
 305
 306 void
 307 vprintf_stderr(const char* aFmt, va_list aArgs)
 308 {
 309   if (sStderrCallback) {
 310     va_list argsCpy;
 311     VARARGS_ASSIGN(argsCpy, aArgs);
 312     sStderrCallback(aFmt, aArgs);
 313     va_end(argsCpy);
 314   }
 315
 316   if (IsDebuggerPresent()) {
 317     char buf[2048];
 318     va_list argsCpy;
 319     VARARGS_ASSIGN(argsCpy, aArgs);
 320     vsnprintf(buf, sizeof(buf), aFmt, argsCpy);
 321     buf[sizeof(buf) - 1] = '\0';
 322     va_end(argsCpy);
 323     OutputDebugStringA(buf);
 324   }
 325
 326   FILE* fp = _fdopen(_dup(2), "a");
 327   if (!fp) {
 328     return;
 329   }
 330
 331   vfprintf(fp, aFmt, aArgs);
 332
 333   fclose(fp);
 334 }
 335
 336 #elif defined(ANDROID)
 337 void
 338 vprintf_stderr(const char* aFmt, va_list aArgs)
 339 {
 340   if (sStderrCallback) {
 341     va_list argsCpy;
 342     VARARGS_ASSIGN(argsCpy, aArgs);
 343     sStderrCallback(aFmt, aArgs);
 344     va_end(argsCpy);
 345   }
 346
 347   __android_log_vprint(ANDROID_LOG_INFO, "Gecko", aFmt, aArgs);
 348 }
 349 #else
 350 void
 351 vprintf_stderr(const char* aFmt, va_list aArgs)
 352 {
 353   if (sStderrCallback) {
 354     va_list argsCpy;
 355     VARARGS_ASSIGN(argsCpy, aArgs);
 356     sStderrCallback(aFmt, aArgs);
 357     va_end(argsCpy);
 358   }
 359
 360   vfprintf(stderr, aFmt, aArgs);
 361 }
 362 #endif
 363
 364 void
 365 printf_stderr(const char* aFmt, ...)
 366 {
 367   va_list args;
 368   va_start(args, aFmt);
 369   vprintf_stderr(aFmt, args);
 370   va_end(args);
 371 }
 372
 373 void
 374 fprintf_stderr(FILE* aFile, const char* aFmt, ...)
 375 {
 376   va_list args;
 377   va_start(args, aFmt);
 378   if (aFile == stderr) {
 379     vprintf_stderr(aFmt, args);
 380   } else {
 381     vfprintf(aFile, aFmt, args);
 382   }
 383   va_end(args);
 384 }
 385
 386