xpcom/ds/nsCRT.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5 #ifndef nsCRT_h___
   6 #define nsCRT_h___
   7
   8 #include <stdlib.h>
   9 #include <ctype.h>
  10 #include "plstr.h"
  11 #include "nscore.h"
  12 #include "nsCRTGlue.h"
  13
  14 #if defined(XP_WIN)
  15 #  define NS_LINEBREAK           "\015\012"
  16 #  define NS_LINEBREAK_LEN       2
  17 #else
  18 #  ifdef XP_UNIX
  19 #    define NS_LINEBREAK         "\012"
  20 #    define NS_LINEBREAK_LEN     1
  21 #  endif /* XP_UNIX */
  22 #endif /* XP_WIN */
  23
  24 extern const char16_t kIsoLatin1ToUCS2[256];
  25
  26 // This macro can be used in a class declaration for classes that want
  27 // to ensure that their instance memory is zeroed.
  28 #define NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW   \
  29   void* operator new(size_t sz) CPP_THROW_NEW { \
  30     void* rv = ::operator new(sz);              \
  31     if (rv) {                                   \
  32       memset(rv, 0, sz);                        \
  33     }                                           \
  34     return rv;                                  \
  35   }                                             \
  36   void operator delete(void* ptr) {             \
  37     ::operator delete(ptr);                     \
  38   }
  39
  40 // This macro works with the next macro to declare a non-inlined
  41 // version of the above.
  42 #define NS_DECL_ZEROING_OPERATOR_NEW           \
  43   void* operator new(size_t sz) CPP_THROW_NEW; \
  44   void operator delete(void* ptr);
  45
  46 #define NS_IMPL_ZEROING_OPERATOR_NEW(_class)            \
  47   void* _class::operator new(size_t sz) CPP_THROW_NEW { \
  48     void* rv = ::operator new(sz);                      \
  49     if (rv) {                                           \
  50       memset(rv, 0, sz);                                \
  51     }                                                   \
  52     return rv;                                          \
  53   }                                                     \
  54   void _class::operator delete(void* ptr) {             \
  55     ::operator delete(ptr);                             \
  56   }
  57
  58 // Freeing helper
  59 #define CRTFREEIF(x) if (x) { nsCRT::free(x); x = 0; }
  60
  61 /// This is a wrapper class around all the C runtime functions.
  62
  63 class nsCRT
  64 {
  65 public:
  66   enum
  67   {
  68     LF = '\n'   /* Line Feed */,
  69     VTAB = '\v' /* Vertical Tab */,
  70     CR = '\r'   /* Carriage Return */
  71   };
  72
  73   /// String comparison.
  74   static int32_t strcmp(const char* aStr1, const char* aStr2)
  75   {
  76     return int32_t(PL_strcmp(aStr1, aStr2));
  77   }
  78
  79   static int32_t strncmp(const char* aStr1, const char* aStr2,
  80                          uint32_t aMaxLen)
  81   {
  82     return int32_t(PL_strncmp(aStr1, aStr2, aMaxLen));
  83   }
  84
  85   /// Case-insensitive string comparison.
  86   static int32_t strcasecmp(const char* aStr1, const char* aStr2)
  87   {
  88     return int32_t(PL_strcasecmp(aStr1, aStr2));
  89   }
  90
  91   /// Case-insensitive string comparison with length
  92   static int32_t strncasecmp(const char* aStr1, const char* aStr2,
  93                              uint32_t aMaxLen)
  94   {
  95     int32_t result = int32_t(PL_strncasecmp(aStr1, aStr2, aMaxLen));
  96     //Egads. PL_strncasecmp is returning *very* negative numbers.
  97     //Some folks expect -1,0,1, so let's temper its enthusiasm.
  98     if (result < 0) {
  99       result = -1;
 100     }
 101     return result;
 102   }
 103
 104   static int32_t strncmp(const char* aStr1, const char* aStr2, int32_t aMaxLen)
 105   {
 106     // inline the first test (assumes strings are not null):
 107     int32_t diff =
 108       ((const unsigned char*)aStr1)[0] - ((const unsigned char*)aStr2)[0];
 109     if (diff != 0) {
 110       return diff;
 111     }
 112     return int32_t(PL_strncmp(aStr1, aStr2, unsigned(aMaxLen)));
 113   }
 114
 115   /**
 116
 117     How to use this fancy (thread-safe) version of strtok:
 118
 119     void main(void) {
 120       printf("%s\n\nTokens:\n", string);
 121       // Establish string and get the first token:
 122       char* newStr;
 123       token = nsCRT::strtok(string, seps, &newStr);
 124       while (token != nullptr) {
 125         // While there are tokens in "string"
 126         printf(" %s\n", token);
 127         // Get next token:
 128         token = nsCRT::strtok(newStr, seps, &newStr);
 129       }
 130     }
 131     * WARNING - STRTOK WHACKS str THE FIRST TIME IT IS CALLED *
 132     * MAKE A COPY OF str IF YOU NEED TO USE IT AFTER strtok() *
 133   */
 134   static char* strtok(char* aStr, const char* aDelims, char** aNewStr);
 135
 136   /// Like strcmp except for ucs2 strings
 137   static int32_t strcmp(const char16_t* aStr1, const char16_t* aStr2);
 138   /// Like strcmp except for ucs2 strings
 139   static int32_t strncmp(const char16_t* aStr1, const char16_t* aStr2,
 140                          uint32_t aMaxLen);
 141
 142   // The GNU libc has memmem, which is strstr except for binary data
 143   // This is our own implementation that uses memmem on platforms
 144   // where it's available.
 145   static const char* memmem(const char* aHaystack, uint32_t aHaystackLen,
 146                             const char* aNeedle, uint32_t aNeedleLen);
 147
 148   // String to longlong
 149   static int64_t atoll(const char* aStr);
 150
 151   static char ToUpper(char aChar) { return NS_ToUpper(aChar); }
 152   static char ToLower(char aChar) { return NS_ToLower(aChar); }
 153
 154   static bool IsUpper(char aChar) { return NS_IsUpper(aChar); }
 155   static bool IsLower(char aChar) { return NS_IsLower(aChar); }
 156
 157   static bool IsAscii(char16_t aChar) { return NS_IsAscii(aChar); }
 158   static bool IsAscii(const char16_t* aString) { return NS_IsAscii(aString); }
 159   static bool IsAsciiAlpha(char16_t aChar) { return NS_IsAsciiAlpha(aChar); }
 160   static bool IsAsciiDigit(char16_t aChar) { return NS_IsAsciiDigit(aChar); }
 161   static bool IsAsciiSpace(char16_t aChar) { return NS_IsAsciiWhitespace(aChar); }
 162   static bool IsAscii(const char* aString) { return NS_IsAscii(aString); }
 163   static bool IsAscii(const char* aString, uint32_t aLength)
 164   {
 165     return NS_IsAscii(aString, aLength);
 166   }
 167 };
 168
 169
 170 inline bool
 171 NS_IS_SPACE(char16_t aChar)
 172 {
 173   return ((int(aChar) & 0x7f) == int(aChar)) && isspace(int(aChar));
 174 }
 175
 176 #define NS_IS_CNTRL(i)   ((((unsigned int) (i)) > 0x7f) ? (int) 0 : iscntrl(i))
 177 #define NS_IS_DIGIT(i)   ((((unsigned int) (i)) > 0x7f) ? (int) 0 : isdigit(i))
 178 #if defined(XP_WIN)
 179 #define NS_IS_ALPHA(VAL) (isascii((int)(VAL)) && isalpha((int)(VAL)))
 180 #else
 181 #define NS_IS_ALPHA(VAL) ((((unsigned int) (VAL)) > 0x7f) ? (int) 0 : isalpha((int)(VAL)))
 182 #endif
 183
 184
 185 #endif /* nsCRT_h___ */