xpcom/base/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 #include "mozilla/Sprintf.h"
  18
  19 #ifdef XP_WIN
  20 #  include <io.h>
  21 #  include <windows.h>
  22 #endif
  23
  24 #ifdef FUZZING_SNAPSHOT
  25 #  include <mozilla/fuzzing/NyxWrapper.h>
  26 #endif
  27
  28 using namespace mozilla;
  29
  30 const char* NS_strspnp(const char* aDelims, const char* aStr) {
  31   const char* d;
  32   do {
  33     for (d = aDelims; *d != '\0'; ++d) {
  34       if (*aStr == *d) {
  35         ++aStr;
  36         break;
  37       }
  38     }
  39   } while (*d);
  40
  41   return aStr;
  42 }
  43
  44 char* NS_strtok(const char* aDelims, char** aStr) {
  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 NS_strlen(const char16_t* aString) {
  73   MOZ_ASSERT(aString);
  74   const char16_t* end;
  75
  76   for (end = aString; *end; ++end) {
  77     // empty loop
  78   }
  79
  80   return end - aString;
  81 }
  82
  83 int NS_strcmp(const char16_t* aStrA, const char16_t* aStrB) {
  84   while (*aStrB) {
  85     int r = *aStrA - *aStrB;
  86     if (r) {
  87       return r;
  88     }
  89
  90     ++aStrA;
  91     ++aStrB;
  92   }
  93
  94   return *aStrA != '\0';
  95 }
  96
  97 int NS_strncmp(const char16_t* aStrA, const char16_t* aStrB, size_t aLen) {
  98   while (aLen && *aStrB) {
  99     int r = *aStrA - *aStrB;
 100     if (r) {
 101       return r;
 102     }
 103
 104     ++aStrA;
 105     ++aStrB;
 106     --aLen;
 107   }
 108
 109   return aLen ? *aStrA != '\0' : 0;
 110 }
 111
 112 char16_t* NS_xstrdup(const char16_t* aString) {
 113   uint32_t len = NS_strlen(aString);
 114   return NS_xstrndup(aString, len);
 115 }
 116
 117 template <typename CharT>
 118 CharT* NS_xstrndup(const CharT* aString, uint32_t aLen) {
 119   auto newBuf = (CharT*)moz_xmalloc((aLen + 1) * sizeof(CharT));
 120   memcpy(newBuf, aString, aLen * sizeof(CharT));
 121   newBuf[aLen] = '\0';
 122   return newBuf;
 123 }
 124
 125 template char16_t* NS_xstrndup<char16_t>(const char16_t* aString,
 126                                          uint32_t aLen);
 127 template char* NS_xstrndup<char>(const char* aString, uint32_t aLen);
 128
 129 char* NS_xstrdup(const char* aString) {
 130   uint32_t len = strlen(aString);
 131   char* str = (char*)moz_xmalloc(len + 1);
 132   memcpy(str, aString, len);
 133   str[len] = '\0';
 134   return str;
 135 }
 136
 137 // clang-format off
 138
 139 // This table maps uppercase characters to lower case characters;
 140 // characters that are neither upper nor lower case are unaffected.
 141 const unsigned char nsLowerUpperUtils::kUpper2Lower[256] = {
 142     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 143    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 144    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 145    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 146    64,
 147
 148     // upper band mapped to lower [A-Z] => [a-z]
 149        97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 150   112,113,114,115,116,117,118,119,120,121,122,
 151
 152                                                91, 92, 93, 94, 95,
 153    96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 154   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
 155   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 156   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 157   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 158   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 159   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 160   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 161   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 162   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
 163 };
 164
 165 const unsigned char nsLowerUpperUtils::kLower2Upper[256] = {
 166     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 167    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 168    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 169    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 170    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 171    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
 172    96,
 173
 174     // lower band mapped to upper [a-z] => [A-Z]
 175        65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 176    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
 177
 178                                               123,124,125,126,127,
 179   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 180   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 181   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 182   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 183   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 184   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 185   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 186   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
 187 };
 188
 189 // clang-format on
 190
 191 bool NS_IsUpper(char aChar) {
 192   return aChar != (char)nsLowerUpperUtils::kUpper2Lower[(unsigned char)aChar];
 193 }
 194
 195 bool NS_IsLower(char aChar) {
 196   return aChar != (char)nsLowerUpperUtils::kLower2Upper[(unsigned char)aChar];
 197 }
 198
 199 #ifndef XPCOM_GLUE_AVOID_NSPR
 200
 201 void NS_MakeRandomString(char* aBuf, int32_t aBufLen) {
 202 #  define TABLE_SIZE 36
 203   static const char table[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
 204                                'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
 205                                's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0',
 206                                '1', '2', '3', '4', '5', '6', '7', '8', '9'};
 207
 208   // turn PR_Now() into milliseconds since epoch
 209   // and salt rand with that.
 210   static unsigned int seed = 0;
 211   if (seed == 0) {
 212     double fpTime = double(PR_Now());
 213     seed =
 214         (unsigned int)(fpTime * 1e-6 + 0.5);  // use 1e-6, granularity of
 215                                               // PR_Now() on the mac is seconds
 216     srand(seed);
 217   }
 218
 219   int32_t i;
 220   for (i = 0; i < aBufLen; ++i) {
 221     *aBuf++ = table[rand() % TABLE_SIZE];
 222   }
 223   *aBuf = 0;
 224 }
 225
 226 #endif