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
|
#ifndef SOURCETOOLS_CORE_UTIL_H
#define SOURCETOOLS_CORE_UTIL_H
#include <string>
#include <memory>
#include <cctype>
#include <cstdlib>
namespace sourcetools {
namespace detail {
class noncopyable
{
protected:
noncopyable() {}
~noncopyable() {}
private:
noncopyable(const noncopyable&);
noncopyable& operator=(const noncopyable&);
};
} // namespace detail
typedef detail::noncopyable noncopyable;
template <typename T>
class scoped_ptr : noncopyable
{
public:
explicit scoped_ptr(T* pData) : pData_(pData) {}
T& operator*() const { return *pData_; }
T* operator->() const { return pData_; }
operator T*() const { return pData_; }
~scoped_ptr() { delete pData_; }
private:
T* pData_;
};
template <typename T>
class scoped_array : noncopyable
{
public:
explicit scoped_array(T* pData) : pData_(pData) {}
T& operator*() const { return *pData_; }
T* operator->() const { return pData_; }
operator T*() const { return pData_; }
~scoped_array() { delete[] pData_; }
private:
T* pData_;
};
namespace utils {
inline bool isWhitespace(char ch)
{
return
ch == ' ' ||
ch == '\f' ||
ch == '\r' ||
ch == '\n' ||
ch == '\t' ||
ch == '\v';
}
template <typename T>
inline bool countWhitespaceBytes(const char* data,
T* pBytes)
{
T bytes = 0;
while (isWhitespace(*data)) {
++data;
++bytes;
}
*pBytes = bytes;
return bytes != 0;
}
inline bool isDigit(char ch)
{
return
(ch >= '0' && ch <= '9');
}
inline bool isAlphabetic(char ch)
{
return
(ch >= 'a' && ch <= 'z') ||
(ch >= 'A' && ch <= 'Z');
}
inline bool isAlphaNumeric(char ch)
{
return
(ch >= 'a' && ch <= 'z') ||
(ch >= 'A' && ch <= 'Z') ||
(ch >= '0' && ch <= '9');
}
inline bool isHexDigit(char ch)
{
return
(ch >= '0' && ch <= '9') ||
(ch >= 'a' && ch <= 'f') ||
(ch >= 'A' && ch <= 'F');
}
inline bool isValidForStartOfRSymbol(char ch)
{
return
isAlphabetic(ch) ||
ch == '.' ||
static_cast<signed char>(ch) < 0;
}
inline bool isValidForRSymbol(char ch)
{
return
isAlphaNumeric(ch) ||
ch == '.' ||
ch == '_' ||
static_cast<signed char>(ch) < 0;
}
inline std::string escape(char ch)
{
switch (ch) {
case '\r':
return "\\r";
case '\n':
return "\\n";
case '\t':
return "\\t";
default:
return std::string(1, ch);
}
}
} // namespace utils
} // namespace sourcetools
#endif /* SOURCETOOLS_CORE_UTIL_H */
|
