1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "string.h"

     7

     8

#include <stdarg.h>

     9

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

    10

    11

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

    12

{

    13

	assert(size > 0);

    14

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

    15

	assert(size > 0);

    16

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

    17

	*dst = '\0';

    18

}

    19

    20

    21

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

    22

{

    23

	assert(size > 0);

    24

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

    25

	*dst = '\0';

    26

}

    27

    28

    29

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

    30

{

    31

	assert(dst <= last);

    32

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

    33

		if (dst == last) return dst;

    34

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

    35

	*dst = '\0';

    36

	return strecpy(dst, src, last);

    37

}

    38

    39

    40

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

    41

{

    42

	assert(dst <= last);

    43

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

    44

	*dst = '\0';

    45

#if 1

    46

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

    47

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

    48

	}

    49

#endif

    50

	return dst;

    51

}

    52

    53

    54

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

    55

{

    56

	char buf[4096];

    57

	va_list va;

    58

	int len;

    59

	char* p;

    60

    61

	va_start(va, str);

    62

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

    63

	va_end(va);

    64

	p = malloc(len + 1);

    65

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

    66

	return p;

    67

}

    68

    69

void str_validate(char *str)

    70

{

    71

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

    72

		if (!IsValidAsciiChar(*str, CS_ALPHANUMERAL)) *str = '?';

    73

}

    74

    75

/**

    76

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

    77

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

    78

 * @param key character to be checked

    79

 * @param afilter the filter to use

    80

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

    81

 */

    82

bool IsValidAsciiChar(byte key, CharSetFilter afilter)

    83

{

    84

	bool firsttest = false;

    85

    86

	switch (afilter) {

    87

		case CS_ALPHANUMERAL:

    88

			firsttest = (key >= ' ' && key < 127);

    89

			break;

    90

    91

		/* We are very strict here */

    92

		case CS_NUMERAL:

    93

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

    94

    95

		case CS_ALPHA:

    96

		default:

    97

			firsttest = ((key >= 'A' && key <= 'Z') || (key >= 'a' && key <= 'z'));

    98

			break;

    99

	}

   100

   101

	/* Allow some special chars too that are non-ASCII but still valid (like '^' above 'a') */

   102

	return (firsttest || (key >= 160 &&

   103

		key != 0xAA && key != 0xAC && key != 0xAD && key != 0xAF &&

   104

		key != 0xB5 && key != 0xB6 && key != 0xB7 && key != 0xB9));

   105

}

   106

   107

void strtolower(char *str)

   108

{

   109

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

   110

}

   111

   112

#ifdef WIN32

   113

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

   114

{

   115

	va_list ap;

   116

	int ret;

   117

   118

	va_start(ap, format);

   119

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

   120

	va_end(ap);

   121

	return ret;

   122

}

   123

   124

#ifdef _MSC_VER

   125

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

   126

{

   127

	int ret;

   128

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

   129

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

   130

	return ret;

   131

}

   132

#endif /* _MSC_VER */

   133

   134

#endif /* WIN32 */