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
|
/* $Id$ */
/** @file string.h */
#ifndef STRING_H
#define STRING_H
#include "macros.h"
/**
* usage ttd_strlcpy(dst, src, lengthof(dst));
* @param dst destination buffer
* @param src string to copy/concatenate
* @param size size of the destination buffer
*/
void ttd_strlcat(char *dst, const char *src, size_t size);
void ttd_strlcpy(char *dst, const char *src, size_t size);
/**
* usage: strecpy(dst, src, lastof(dst));
* @param dst destination buffer
* @param src string to copy
* @param last pointer to the last element in the dst array
* if NULL no boundary check is performed
* @return a pointer to the terminating \0 in the destination buffer
*/
char *strecat(char *dst, const char *src, const char *last);
char *strecpy(char *dst, const char *src, const char *last);
char *CDECL str_fmt(const char *str, ...);
/** Scans the string for valid characters and if it finds invalid ones,
* replaces them with a question mark '?' */
void str_validate(char *str);
/** Scans the string for colour codes and strips them */
void str_strip_colours(char *str);
/**
* Valid filter types for IsValidChar.
*/
enum CharSetFilter {
CS_ALPHANUMERAL, ///< Both numeric and alphabetic and spaces and stuff
CS_NUMERAL, ///< Only numeric ones
CS_ALPHA, ///< Only alphabetic values
};
/** Convert the given string to lowercase, only works with ASCII! */
void strtolower(char *str);
static inline bool StrEmpty(const char *s) { return s == NULL || s[0] == '\0'; }
/** Get the length of a string, within a limited buffer */
static inline int ttd_strnlen(const char *str, int maxlen)
{
const char *t;
for (t = str; *t != '\0' && t - str < maxlen; t++);
return t - str;
}
/** Convert the md5sum number to a 'hexadecimal' string, return next pos in buffer */
char *md5sumToString(char *buf, const char *last, const uint8 md5sum[16]);
typedef uint32 WChar;
/**
* Only allow certain keys. You can define the filter to be used. This makes
* sure no invalid keys can get into an editbox, like BELL.
* @param key character to be checked
* @param afilter the filter to use
* @return true or false depending if the character is printable/valid or not
*/
bool IsValidChar(WChar key, CharSetFilter afilter);
size_t Utf8Decode(WChar *c, const char *s);
size_t Utf8Encode(char *buf, WChar c);
size_t Utf8TrimString(char *s, size_t maxlen);
static inline WChar Utf8Consume(const char **s)
{
WChar c;
*s += Utf8Decode(&c, *s);
return c;
}
/** Return the length of a UTF-8 encoded character.
* @param c Unicode character.
* @return Length of UTF-8 encoding for character.
*/
static inline size_t Utf8CharLen(WChar c)
{
if (c < 0x80) return 1;
if (c < 0x800) return 2;
if (c < 0x10000) return 3;
if (c < 0x110000) return 4;
/* Invalid valid, we encode as a '?' */
return 1;
}
/**
* Return the length of an UTF-8 encoded value based on a single char. This
* char should be the first byte of the UTF-8 encoding. If not, or encoding
* is invalid, return value is 0
* @param c char to query length of
* @return requested size
*/
static inline size_t Utf8EncodedCharLen(char c)
{
if (GB(c, 3, 5) == 0x1E) return 4;
if (GB(c, 4, 4) == 0x0E) return 3;
if (GB(c, 5, 3) == 0x06) return 2;
if (GB(c, 7, 1) == 0x00) return 1;
/* Invalid UTF8 start encoding */
return 0;
}
/* Check if the given character is part of a UTF8 sequence */
static inline bool IsUtf8Part(char c)
{
return GB(c, 6, 2) == 2;
}
/**
* Retrieve the previous UNICODE character in an UTF-8 encoded string.
* @param s char pointer pointing to (the first char of) the next character
* @return a pointer in 's' to the previous UNICODE character's first byte
* @note The function should not be used to determine the length of the previous
* encoded char because it might be an invalid/corrupt start-sequence
*/
static inline char *Utf8PrevChar(const char *s)
{
const char *ret = s;
while (IsUtf8Part(*--ret));
return (char*)ret;
}
static inline bool IsPrintable(WChar c)
{
if (c < 0x20) return false;
if (c < 0xE000) return true;
if (c < 0xE200) return false;
return true;
}
/**
* Check whether UNICODE character is whitespace or not
* @param c UNICODE character to check
* @return a boolean value whether 'c' is a whitespace character or not
* @see http://www.fileformat.info/info/unicode/category/Zs/list.htm
*/
static inline bool IsWhitespace(WChar c)
{
return
c == 0x0020 /* SPACE */ ||
c == 0x00A0 /* NO-BREAK SPACE */ ||
c == 0x3000 /* IDEOGRAPHIC SPACE */
;
}
#endif /* STRING_H */
|
