1

/* $Id$ */

     2

     3

/** @file string.cpp Handling of C-type strings (char*). */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "core/alloc_func.hpp"

     9

#include "core/math_func.hpp"

    10

#include "string_func.h"

    11

    12

#include "table/control_codes.h"

    13

    14

#include <stdarg.h>

    15

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

    16

    17

/**

    18

 * Safer implementation of vsnprintf; same as vsnprintf except:

    19

 * - last instead of size, i.e. replace sizeof with lastof.

    20

 * - return gives the amount of characters added, not what it would add.

    21

 * @param str    buffer to write to up to last

    22

 * @param last   last character we may write to

    23

 * @param format the formatting (see snprintf)

    24

 * @param ap     the list of arguments for the format

    25

 * @return the number of added characters

    26

 */

    27

static int CDECL vseprintf(char *str, const char *last, const char *format, va_list ap)

    28

{

    29

	if (str >= last) return 0;

    30

	size_t size = last - str;

    31

	return min((int)size, vsnprintf(str, size, format, ap));

    32

}

    33

    34

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

    35

{

    36

	assert(size > 0);

    37

	while (size > 0 && *dst != '\0') {

    38

		size--;

    39

		dst++;

    40

	}

    41

    42

	ttd_strlcpy(dst, src, size);

    43

}

    44

    45

    46

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

    47

{

    48

	assert(size > 0);

    49

	while (--size > 0 && *src != '\0') {

    50

		*dst++ = *src++;

    51

	}

    52

	*dst = '\0';

    53

}

    54

    55

    56

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

    57

{

    58

	assert(dst <= last);

    59

	while (*dst != '\0') {

    60

		if (dst == last) return dst;

    61

		dst++;

    62

	}

    63

    64

	return strecpy(dst, src, last);

    65

}

    66

    67

    68

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

    69

{

    70

	assert(dst <= last);

    71

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

    72

		*dst++ = *src++;

    73

	}

    74

	*dst = '\0';

    75

    76

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

    77

#ifdef STRGEN

    78

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

    79

#else /* STRGEN */

    80

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

    81

#endif /* STRGEN */

    82

	}

    83

	return dst;

    84

}

    85

    86

    87

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

    88

{

    89

	char buf[4096];

    90

	va_list va;

    91

    92

	va_start(va, str);

    93

	int len = vseprintf(buf, lastof(buf), str, va);

    94

	va_end(va);

    95

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

    96

	memcpy(p, buf, len + 1);

    97

	return p;

    98

}

    99

   100

   101

void str_validate(char *str)

   102

{

   103

	char *dst = str;

   104

	WChar c;

   105

	size_t len;

   106

   107

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

   108

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

   109

			IsValidChar(c - SCC_SPRITE_START, CS_ALPHANUMERAL))) {

   110

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

   111

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

   112

			 * moving the pointers ahead by len */

   113

			do {

   114

				*dst++ = *str++;

   115

			} while (--len != 0);

   116

		} else {

   117

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

   118

			str += len;

   119

			*dst++ = '?';

   120

		}

   121

	}

   122

   123

	*dst = '\0';

   124

}

   125

   126

   127

void str_strip_colours(char *str)

   128

{

   129

	char *dst = str;

   130

	WChar c;

   131

	size_t len;

   132

   133

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

   134

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

   135

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

   136

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

   137

			 * moving the pointers ahead by len */

   138

			do {

   139

				*dst++ = *str++;

   140

			} while (--len != 0);

   141

		} else {

   142

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

   143

			str += len;

   144

		}

   145

	}

   146

	*dst = '\0';

   147

}

   148

   149

/** Convert a given ASCII string to lowercase.

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

 * @param str string to convert */

   157

void strtolower(char *str)

   158

{

   159

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

   160

}

   161

   162

/**

   163

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

   164

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

   165

 * @param key character to be checked

   166

 * @param afilter the filter to use

   167

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

   168

 */

   169

bool IsValidChar(WChar key, CharSetFilter afilter)

   170

{

   171

	switch (afilter) {

   172

		case CS_ALPHANUMERAL: return IsPrintable(key);

   173

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

   174

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

   175

	}

   176

   177

	return false;

   178

}

   179

   180

#ifdef WIN32

   181

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

   182

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

   183

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

   184

{

   185

	va_list ap;

   186

	int ret;

   187

   188

	va_start(ap, format);

   189

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

   190

	va_end(ap);

   191

	return ret;

   192

}

   193

#endif /* MinGW Runtime < 3.14 */

   194

   195

#ifdef _MSC_VER

   196

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

   197

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

   198

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

   199

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

   200

 */

   201

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

   202

{

   203

	int ret;

   204

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

   205

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

   206

	return ret;

   207

}

   208

#endif /* _MSC_VER */

   209

   210

#endif /* WIN32 */

   211

   212

/**

   213

 * Safer implementation of snprintf; same as snprintf except:

   214

 * - last instead of size, i.e. replace sizeof with lastof.

   215

 * - return gives the amount of characters added, not what it would add.

   216

 * @param str    buffer to write to up to last

   217

 * @param last   last character we may write to

   218

 * @param format the formatting (see snprintf)

   219

 * @return the number of added characters

   220

 */

   221

int CDECL seprintf(char *str, const char *last, const char *format, ...)

   222

{

   223

	va_list ap;

   224

   225

	va_start(ap, format);

   226

	int ret = vseprintf(str, last, format, ap);

   227

	va_end(ap);

   228

	return ret;

   229

}

   230

   231

   232

/** Convert the md5sum to a hexadecimal string representation

   233

 * @param buf buffer to put the md5sum into

   234

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

   235

 * @param md5sum the md5sum itself

   236

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

   237

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

   238

{

   239

	char *p = buf;

   240

   241

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

   242

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

   243

	}

   244

   245

	return p;

   246

}

   247

   248

   249

/* UTF-8 handling routines */

   250

   251

   252

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

   253

 * @param c Buffer to place decoded character.

   254

 * @param s Character stream to retrieve character from.

   255

 * @return Number of characters in the sequence.

   256

 */

   257

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

   258

{

   259

	assert(c != NULL);

   260

   261

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

   262

		/* Single byte character: 0xxxxxxx */

   263

		*c = s[0];

   264

		return 1;

   265

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

   266

		if (IsUtf8Part(s[1])) {

   267

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

   268

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

   269

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

   270

		}

   271

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

   272

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

   273

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

   274

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

   275

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

   276

		}

   277

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

   278

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

   279

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

   280

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

   281

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

   282

		}

   283

	}

   284

   285

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

   286

	*c = '?';

   287

	return 1;

   288

}

   289

   290

   291

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

   292

 * @param buf Buffer to place character.

   293

 * @param c   Unicode character to encode.

   294

 * @return Number of characters in the encoded sequence.

   295

 */

   296

size_t Utf8Encode(char *buf, WChar c)

   297

{

   298

	if (c < 0x80) {

   299

		*buf = c;

   300

		return 1;

   301

	} else if (c < 0x800) {

   302

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

   303

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

   304

		return 2;

   305

	} else if (c < 0x10000) {

   306

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

   307

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

   308

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

   309

		return 3;

   310

	} else if (c < 0x110000) {

   311

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

   312

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

   313

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

   314

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

   315

		return 4;

   316

	}

   317

   318

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

   319

	*buf = '?';

   320

	return 1;

   321

}

   322

   323

/**

   324

 * Properly terminate an UTF8 string to some maximum length

   325

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

   326

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

   327

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

   328

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

   329

 */

   330

size_t Utf8TrimString(char *s, size_t maxlen)

   331

{

   332

	size_t length = 0;

   333

   334

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

   335

		size_t len = Utf8EncodedCharLen(*s);

   336

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

   337

		if (len == 0) len = 1;

   338

   339

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

   340

		 * the last UTF8 sequence is invalid */

   341

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

   342

		s += len;

   343

		length += len;

   344

	}

   345

   346

	*s = '\0';

   347

	return length;

   348

}

   349

   350

#ifndef _GNU_SOURCE

   351

#include "core/math_func.hpp"

   352

char *strndup(const char *s, size_t len)

   353

{

   354

	len = min(strlen(s), len);

   355

	char *tmp = CallocT<char>(len + 1);

   356

	memcpy(tmp, s, len);

   357

	return tmp;

   358

}

   359

#endif /* !_GNU_SOURCE */