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);

    43

}

    44

    45

    46

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

    47

{

    48

	assert(size > 0);

    52

	*dst = '\0';

    53

}

    54

    55

    56

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

    57

{

    58

	assert(dst <= last);

    60

		if (dst == last) return dst;

    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);

    74

	*dst = '\0';

    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

		*dst = '\0';

    82

#endif /* STRGEN */

    83

	}

    84

	return dst;

    85

}

    86

    87

    88

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

    89

{

    90

	char buf[4096];

    91

	va_list va;

    92

    93

	va_start(va, str);

    94

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

    95

	va_end(va);

    96

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

    97

	memcpy(p, buf, len + 1);

    98

	return p;

    99

}

   100

   101

   102

void str_validate(char *str)

   103

{

   104

	char *dst = str;

   105

	WChar c;

   106

	size_t len;

   107

   108

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

   109

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

   110

			IsValidChar(c - SCC_SPRITE_START, CS_ALPHANUMERAL))) {

   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

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

   119

			str += len;

   120

			*dst++ = '?';

   121

		}

   122

	}

   123

   124

	*dst = '\0';

   125

}

   126

   127

   128

void str_strip_colours(char *str)

   129

{

   130

	char *dst = str;

   131

	WChar c;

   132

	size_t len;

   133

   134

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

   135

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

   136

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

   137

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

   138

			 * moving the pointers ahead by len */

   139

			do {

   140

				*dst++ = *str++;

   141

			} while (--len != 0);

   142

		} else {

   143

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

   144

			str += len;

   145

		}

   146

	}

   147

	*dst = '\0';

   148

}

   149

   150

/** Convert a given ASCII string to lowercase.

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

 * @param str string to convert */

   158

void strtolower(char *str)

   159

{

   160

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

   161

}

   162

   163

/**

   164

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

   165

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

   166

 * @param key character to be checked

   167

 * @param afilter the filter to use

   168

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

   169

 */

   170

bool IsValidChar(WChar key, CharSetFilter afilter)

   171

{

   172

	switch (afilter) {

   173

		case CS_ALPHANUMERAL: return IsPrintable(key);

   174

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

   175

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

   176

	}

   177

   178

	return false;

   179

}

   180

   181

#ifdef WIN32

   182

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

   183

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

   184

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

   185

{

   186

	va_list ap;

   187

	int ret;

   188

   189

	va_start(ap, format);

   190

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

   191

	va_end(ap);

   192

	return ret;

   193

}

   194

#endif /* MinGW Runtime < 3.14 */

   195

   196

#ifdef _MSC_VER

   197

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

   198

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

   199

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

   200

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

   201

 */

   202

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

   203

{

   204

	int ret;

   205

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

   206

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

   207

	return ret;

   208

}

   209

#endif /* _MSC_VER */

   210

   211

#endif /* WIN32 */

   212

   213

/**

   214

 * Safer implementation of snprintf; same as snprintf except:

   215

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

   216

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

   217

 * @param str    buffer to write to up to last

   218

 * @param last   last character we may write to

   219

 * @param format the formatting (see snprintf)

   220

 * @return the number of added characters

   221

 */

   222

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

   223

{

   224

	va_list ap;

   225

   226

	va_start(ap, format);

   227

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

   228

	va_end(ap);

   229

	return ret;

   230

}

   231

   232

   233

/** Convert the md5sum to a hexadecimal string representation

   234

 * @param buf buffer to put the md5sum into

   235

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

   236

 * @param md5sum the md5sum itself

   237

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

   238

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

   239

{

   240

	char *p = buf;

   241

   242

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

   243

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

   244

	}

   245

   246

	return p;

   247

}

   248

   249

   250

/* UTF-8 handling routines */

   251

   252

   253

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

   254

 * @param c Buffer to place decoded character.

   255

 * @param s Character stream to retrieve character from.

   256

 * @return Number of characters in the sequence.

   257

 */

   258

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

   259

{

   260

	assert(c != NULL);

   261

   262

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

   263

		/* Single byte character: 0xxxxxxx */

   264

		*c = s[0];

   265

		return 1;

   266

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

   267

		if (IsUtf8Part(s[1])) {

   268

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

   269

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

   270

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

   271

		}

   272

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

   273

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

   274

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

   275

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

   276

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

   277

		}

   278

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

   279

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

   280

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

   281

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

   282

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

   283

		}

   284

	}

   285

   286

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

   287

	*c = '?';

   288

	return 1;

   289

}

   290

   291

   292

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

   293

 * @param buf Buffer to place character.

   294

 * @param c   Unicode character to encode.

   295

 * @return Number of characters in the encoded sequence.

   296

 */

   297

size_t Utf8Encode(char *buf, WChar c)

   298

{

   299

	if (c < 0x80) {

   300

		*buf = c;

   301

		return 1;

   302

	} else if (c < 0x800) {

   303

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

   304

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

   305

		return 2;

   306

	} else if (c < 0x10000) {

   307

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

   308

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

   309

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

   310

		return 3;

   311

	} else if (c < 0x110000) {

   312

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

   313

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

   314

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

   315

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

   316

		return 4;

   317

	}

   318

   319

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

   320

	*buf = '?';

   321

	return 1;

   322

}

   323

   324

/**

   325

 * Properly terminate an UTF8 string to some maximum length

   326

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

   327

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

   328

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

   329

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

   330

 */

   331

size_t Utf8TrimString(char *s, size_t maxlen)

   332

{

   333

	size_t length = 0;

   334

   335

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

   336

		size_t len = Utf8EncodedCharLen(*s);

   337

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

   338

		if (len == 0) len = 1;

   339

   340

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

   341

		 * the last UTF8 sequence is invalid */

   342

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

   343

		s += len;

   344

		length += len;

   345

	}

   346

   347

	*s = '\0';

   348

	return length;

   349

}

   350

   351

#ifndef _GNU_SOURCE

   352

#include "core/math_func.hpp"

   353

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

   354

{

   355

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

   356

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

   357

	memcpy(tmp, s, len);

   358

	return tmp;

   359

}

   360

#endif /* !_GNU_SOURCE */