1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsCRTGlue_h__
#define nsCRTGlue_h__
#include "nscore.h"
/**
* Scan a string for the first character that is *not* in a set of
* delimiters. If the string is only delimiter characters, the end of the
* string is returned.
*
* @param aDelims The set of delimiters (null-terminated)
* @param aStr The string to search (null-terminated)
*/
const char* NS_strspnp(const char* aDelims, const char* aStr);
/**
* Tokenize a string. This function is similar to the strtok function in the
* C standard library, but it does not use static variables to maintain state
* and is therefore thread and reentrancy-safe.
*
* Any leading delimiters in str are skipped. Then the string is scanned
* until an additional delimiter or end-of-string is found. The final
* delimiter is set to '\0'.
*
* @param aDelims The set of delimiters.
* @param aStr The string to search. This is an in-out parameter; it is
* reset to the end of the found token + 1, or to the
* end-of-string if there are no more tokens.
* @return The token. If no token is found (the string is only
* delimiter characters), nullptr is returned.
*/
char* NS_strtok(const char* aDelims, char** aStr);
/**
* "strlen" for char16_t strings
*/
uint32_t NS_strlen(const char16_t* aString);
/**
* "strcmp" for char16_t strings
*/
int NS_strcmp(const char16_t* aStrA, const char16_t* aStrB);
/**
* "strncmp" for char16_t strings
*/
int NS_strncmp(const char16_t* aStrA, const char16_t* aStrB, size_t aLen);
/**
* "strdup" for char16_t strings, uses the infallible moz_xmalloc allocator.
*/
char16_t* NS_xstrdup(const char16_t* aString);
/**
* "strdup", but using the infallible moz_xmalloc allocator.
*/
char* NS_xstrdup(const char* aString);
/**
* strndup for char16_t or char strings (normal strndup is not available on
* windows). This function will ensure that the new string is
* null-terminated. Uses the infallible moz_xmalloc allocator.
*
* CharT may be either char16_t or char.
*/
template <typename CharT>
CharT* NS_xstrndup(const CharT* aString, uint32_t aLen);
// The following case-conversion methods only deal in the ascii repertoire
// A-Z and a-z
// semi-private data declarations... don't use these directly.
class nsLowerUpperUtils {
public:
static const unsigned char kLower2Upper[256];
static const unsigned char kUpper2Lower[256];
};
inline char NS_ToUpper(char aChar) {
return (char)nsLowerUpperUtils::kLower2Upper[(unsigned char)aChar];
}
inline char NS_ToLower(char aChar) {
return (char)nsLowerUpperUtils::kUpper2Lower[(unsigned char)aChar];
}
bool NS_IsUpper(char aChar);
bool NS_IsLower(char aChar);
constexpr bool NS_IsAscii(const char* aString) {
while (*aString) {
if (0x80 & *aString) {
return false;
}
aString++;
}
return true;
}
constexpr bool NS_IsAscii(const char* aString, uint32_t aLength) {
const char* end = aString + aLength;
while (aString < end) {
if (0x80 & *aString) {
return false;
}
aString++;
}
return true;
}
constexpr bool NS_IsAsciiWhitespace(char16_t aChar) {
return aChar == ' ' || aChar == '\r' || aChar == '\n' || aChar == '\t';
}
#ifndef XPCOM_GLUE_AVOID_NSPR
void NS_MakeRandomString(char* aBuf, int32_t aBufLen);
#endif
#define FF '\f'
#define TAB '\t'
#define CRSTR "\015"
#define LFSTR "\012"
#define CRLF "\015\012" /* A CR LF equivalent string */
#if defined(ANDROID)
// On mobile devices, the file system may be very limited in what it
// considers valid characters. To avoid errors, sanitize conservatively.
# define OS_FILE_ILLEGAL_CHARACTERS "/:*?\"<>|;,+=[]"
#else
// Otherwise, we use the most restrictive filesystem as our default set of
// illegal filename characters. This is currently Windows.
# define OS_FILE_ILLEGAL_CHARACTERS "/:*?\"<>|"
#endif
// We also provide a list of all known file path separators for all filesystems.
// This can be used in replacement of FILE_PATH_SEPARATOR when you need to
// identify or replace all known path separators.
#define KNOWN_PATH_SEPARATORS "\\/"
#if defined(XP_MACOSX)
# define FILE_PATH_SEPARATOR "/"
#elif defined(XP_WIN)
# define FILE_PATH_SEPARATOR "\\"
#elif defined(XP_UNIX)
# define FILE_PATH_SEPARATOR "/"
#else
# error need_to_define_your_file_path_separator_and_maybe_illegal_characters
#endif
// Not all these control characters are illegal in all OSs, but we don't really
// want them appearing in filenames
#define CONTROL_CHARACTERS \
"\001\002\003\004\005\006\007" \
"\010\011\012\013\014\015\016\017" \
"\020\021\022\023\024\025\026\027" \
"\030\031\032\033\034\035\036\037" \
"\177" \
"\200\201\202\203\204\205\206\207" \
"\210\211\212\213\214\215\216\217" \
"\220\221\222\223\224\225\226\227" \
"\230\231\232\233\234\235\236\237"
#define FILE_ILLEGAL_CHARACTERS CONTROL_CHARACTERS OS_FILE_ILLEGAL_CHARACTERS
#endif // nsCRTGlue_h__
|
