1

/* $Id$ */

     2

     3

/** @file string.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "core/alloc_func.hpp"

     9

#include "string_func.h"

    10

    11

#include "table/control_codes.h"

    12

    13

#include <stdarg.h>

    14

#include <ctype.h> // required for tolower()

    15

    16

void ttd_strlcat(char *dst, const char *src, size_t size)

    17

{

    18

	assert(size > 0);

    19

	for (; size > 0 && *dst != '\0'; --size, ++dst) {}

    20

	assert(size > 0);

    21

	while (--size > 0 && *src != '\0') *dst++ = *src++;

    22

	*dst = '\0';

    23

}

    24

    25

    26

void ttd_strlcpy(char *dst, const char *src, size_t size)

    27

{

    28

	assert(size > 0);

    29

	while (--size > 0 && *src != '\0') *dst++ = *src++;

    30

	*dst = '\0';

    31

}

    32

    33

    34

char* strecat(char* dst, const char* src, const char* last)

    35

{

    36

	assert(dst <= last);

    37

	for (; *dst != '\0'; ++dst)

    38

		if (dst == last) return dst;

    39

	for (; *src != '\0' && dst != last; ++dst, ++src) *dst = *src;

    40

	*dst = '\0';

    41

	return strecpy(dst, src, last);

    42

}

    43

    44

    45

char* strecpy(char* dst, const char* src, const char* last)

    46

{

    47

	assert(dst <= last);

    48

	for (; *src != '\0' && dst != last; ++dst, ++src) *dst = *src;

    49

	*dst = '\0';

    50

	if (dst == last && *src != '\0') {

    51

#ifdef STRGEN

    52

		error("String too long for destination buffer");

    53

#else /* STRGEN */

    54

		DEBUG(misc, 0, "String too long for destination buffer");

    55

		*dst = '\0';

    56

#endif /* STRGEN */

    57

	}

    58

	return dst;

    59

}

    60

    61

    62

char* CDECL str_fmt(const char* str, ...)

    63

{

    64

	char buf[4096];

    65

	va_list va;

    66

	int len;

    67

    68

	va_start(va, str);

    69

	len = vsnprintf(buf, lengthof(buf), str, va);

    70

	va_end(va);

    71

	char* p = MallocT<char>(len + 1);

    72

	if (p != NULL) memcpy(p, buf, len + 1);

    73

	return p;

    74

}

    75

    76

    77

void str_validate(char *str)

    78

{

    79

	char *dst = str;

    80

	WChar c;

    81

	size_t len;

    82

    83

	for (len = Utf8Decode(&c, str); c != '\0'; len = Utf8Decode(&c, str)) {

    84

		if (IsPrintable(c) && (c < SCC_SPRITE_START || c > SCC_SPRITE_END ||

    85

			IsValidChar(c - SCC_SPRITE_START, CS_ALPHANUMERAL))) {

    86

			/* Copy the character back. Even if dst is current the same as str

    87

			 * (i.e. no characters have been changed) this is quicker than

    88

			 * moving the pointers ahead by len */

    89

			do {

    90

				*dst++ = *str++;

    91

			} while (--len != 0);

    92

		} else {

    93

			/* Replace the undesirable character with a question mark */

    94

			str += len;

    95

			*dst++ = '?';

    96

		}

    97

	}

    98

    99

	*dst = '\0';

   100

}

   101

   102

   103

void str_strip_colours(char *str)

   104

{

   105

	char *dst = str;

   106

	WChar c;

   107

	size_t len;

   108

   109

	for (len = Utf8Decode(&c, str); c != '\0'; len = Utf8Decode(&c, str)) {

   110

		if (c < SCC_BLUE || c > SCC_BLACK) {

   111

			/* Copy the character back. Even if dst is current the same as str

   112

			 * (i.e. no characters have been changed) this is quicker than

   113

			 * moving the pointers ahead by len */

   114

			do {

   115

				*dst++ = *str++;

   116

			} while (--len != 0);

   117

		} else {

   118

			/* Just skip (strip) the colour codes */

   119

			str += len;

   120

		}

   121

	}

   122

	*dst = '\0';

   123

}

   124

   125

/** Convert a given ASCII string to lowercase.

   126

 * NOTE: only support ASCII characters, no UTF8 fancy. As currently

   127

 * the function is only used to lowercase data-filenames if they are

   128

 * not found, this is sufficient. If more, or general functionality is

   129

 * needed, look to r7271 where it was removed because it was broken when

   130

 * using certain locales: eg in Turkish the uppercase 'I' was converted to

   131

 * '?', so just revert to the old functionality

   132

 * @param str string to convert */

   133

void strtolower(char *str)

   134

{

   135

	for (; *str != '\0'; str++) *str = tolower(*str);

   136

}

   137

   138

/**

   139

 * Only allow certain keys. You can define the filter to be used. This makes

   140

 *  sure no invalid keys can get into an editbox, like BELL.

   141

 * @param key character to be checked

   142

 * @param afilter the filter to use

   143

 * @return true or false depending if the character is printable/valid or not

   144

 */

   145

bool IsValidChar(WChar key, CharSetFilter afilter)

   146

{

   147

	switch (afilter) {

   148

		case CS_ALPHANUMERAL: return IsPrintable(key);

   149

		case CS_NUMERAL:      return (key >= '0' && key <= '9');

   150

		case CS_ALPHA:        return IsPrintable(key) && !(key >= '0' && key <= '9');

   151

	}

   152

   153

	return false;

   154

}

   155

   156

#ifdef WIN32

   157

/* Since version 3.14, MinGW Runtime has snprintf() and vsnprintf() conform to C99 but it's not the case for older versions */

   158

#if (__MINGW32_MAJOR_VERSION < 3) || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION < 14))

   159

int CDECL snprintf(char *str, size_t size, const char *format, ...)

   160

{

   161

	va_list ap;

   162

	int ret;

   163

   164

	va_start(ap, format);

   165

	ret = vsnprintf(str, size, format, ap);

   166

	va_end(ap);

   167

	return ret;

   168

}

   169

#endif /* MinGW Runtime < 3.14 */

   170

   171

#ifdef _MSC_VER

   172

/* *nprintf broken, not POSIX compliant, MSDN description

   173

 * - If len < count, then len characters are stored in buffer, a null-terminator is appended, and len is returned.

   174

 * - If len = count, then len characters are stored in buffer, no null-terminator is appended, and len is returned.

   175

 * - If len > count, then count characters are stored in buffer, no null-terminator is appended, and a negative value is returned

   176

 */

   177

int CDECL vsnprintf(char *str, size_t size, const char *format, va_list ap)

   178

{

   179

	int ret;

   180

	ret = _vsnprintf(str, size, format, ap);

   181

	if (ret < 0 || ret == size) str[size - 1] = '\0';

   182

	return ret;

   183

}

   184

#endif /* _MSC_VER */

   185

   186

#endif /* WIN32 */

   187

   188

   189

/** Convert the md5sum to a hexadecimal string representation

   190

 * @param buf buffer to put the md5sum into

   191

 * @param last last character of buffer (usually lastof(buf))

   192

 * @param md5sum the md5sum itself

   193

 * @return a pointer to the next character after the md5sum */

   194

char *md5sumToString(char *buf, const char *last, const uint8 md5sum[16])

   195

{

   196

	char *p = buf;

   197

   198

	for (uint i = 0; i < 16; i++) {

   199

		p += snprintf(p, last + 1 - p, "%02X", md5sum[i]);

   200

		if (p >= last) break;

   201

	}

   202

   203

	return p;

   204

}

   205

   206

   207

/* UTF-8 handling routines */

   208

   209

   210

/* Decode and consume the next UTF-8 encoded character

   211

 * @param c Buffer to place decoded character.

   212

 * @param s Character stream to retrieve character from.

   213

 * @return Number of characters in the sequence.

   214

 */

   215

size_t Utf8Decode(WChar *c, const char *s)

   216

{

   217

	assert(c != NULL);

   218

   219

	if (!HasBit(s[0], 7)) {

   220

		/* Single byte character: 0xxxxxxx */

   221

		*c = s[0];

   222

		return 1;

   223

	} else if (GB(s[0], 5, 3) == 6) {

   224

		if (IsUtf8Part(s[1])) {

   225

			/* Double byte character: 110xxxxx 10xxxxxx */

   226

			*c = GB(s[0], 0, 5) << 6 | GB(s[1], 0, 6);

   227

			if (*c >= 0x80) return 2;

   228

		}

   229

	} else if (GB(s[0], 4, 4) == 14) {

   230

		if (IsUtf8Part(s[1]) && IsUtf8Part(s[2])) {

   231

			/* Triple byte character: 1110xxxx 10xxxxxx 10xxxxxx */

   232

			*c = GB(s[0], 0, 4) << 12 | GB(s[1], 0, 6) << 6 | GB(s[2], 0, 6);

   233

			if (*c >= 0x800) return 3;

   234

		}

   235

	} else if (GB(s[0], 3, 5) == 30) {

   236

		if (IsUtf8Part(s[1]) && IsUtf8Part(s[2]) && IsUtf8Part(s[3])) {

   237

			/* 4 byte character: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */

   238

			*c = GB(s[0], 0, 3) << 18 | GB(s[1], 0, 6) << 12 | GB(s[2], 0, 6) << 6 | GB(s[3], 0, 6);

   239

			if (*c >= 0x10000 && *c <= 0x10FFFF) return 4;

   240

		}

   241

	}

   242

   243

	//DEBUG(misc, 1, "[utf8] invalid UTF-8 sequence");

   244

	*c = '?';

   245

	return 1;

   246

}

   247

   248

   249

/* Encode a unicode character and place it in the buffer

   250

 * @param buf Buffer to place character.

   251

 * @param c   Unicode character to encode.

   252

 * @return Number of characters in the encoded sequence.

   253

 */

   254

size_t Utf8Encode(char *buf, WChar c)

   255

{

   256

	if (c < 0x80) {

   257

		*buf = c;

   258

		return 1;

   259

	} else if (c < 0x800) {

   260

		*buf++ = 0xC0 + GB(c,  6, 5);

   261

		*buf   = 0x80 + GB(c,  0, 6);

   262

		return 2;

   263

	} else if (c < 0x10000) {

   264

		*buf++ = 0xE0 + GB(c, 12, 4);

   265

		*buf++ = 0x80 + GB(c,  6, 6);

   266

		*buf   = 0x80 + GB(c,  0, 6);

   267

		return 3;

   268

	} else if (c < 0x110000) {

   269

		*buf++ = 0xF0 + GB(c, 18, 3);

   270

		*buf++ = 0x80 + GB(c, 12, 6);

   271

		*buf++ = 0x80 + GB(c,  6, 6);

   272

		*buf   = 0x80 + GB(c,  0, 6);

   273

		return 4;

   274

	}

   275

   276

	//DEBUG(misc, 1, "[utf8] can't UTF-8 encode value 0x%X", c);

   277

	*buf = '?';

   278

	return 1;

   279

}

   280

   281

/**

   282

 * Properly terminate an UTF8 string to some maximum length

   283

 * @param s string to check if it needs additional trimming

   284

 * @param maxlen the maximum length the buffer can have.

   285

 * @return the new length in bytes of the string (eg. strlen(new_string))

   286

 * @NOTE maxlen is the string length _INCLUDING_ the terminating '\0'

   287

 */

   288

size_t Utf8TrimString(char *s, size_t maxlen)

   289

{

   290

	size_t length = 0;

   291

   292

	for (const char *ptr = strchr(s, '\0'); *s != '\0';) {

   293

		size_t len = Utf8EncodedCharLen(*s);

   294

		/* Silently ignore invalid UTF8 sequences, our only concern trimming */

   295

		if (len == 0) len = 1;

   296

   297

		/* Take care when a hard cutoff was made for the string and

   298

		 * the last UTF8 sequence is invalid */

   299

		if (length + len >= maxlen || (s + len > ptr)) break;

   300

		s += len;

   301

		length += len;

   302

	}

   303

   304

	*s = '\0';

   305

	return length;

   306

}