1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "string.h"

     5

     6

#include <stdarg.h>

     7

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

     8

     9

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

    10

{

    11

	assert(size > 0);

    12

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

    13

	assert(size > 0);

    14

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

    15

	*dst = '\0';

    16

}

    17

    18

    19

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

    20

{

    21

	assert(size > 0);

    22

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

    23

	*dst = '\0';

    24

}

    25

    26

    27

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

    28

{

    29

	assert(last == NULL || dst <= last);

    30

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

    31

		if (dst == last) return dst;

    32

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

    33

	*dst = '\0';

    34

	return strecpy(dst, src, last);

    35

}

    36

    37

    38

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

    39

{

    40

	assert(last == NULL || dst <= last);

    41

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

    42

	*dst = '\0';

    43

	return dst;

    44

}

    45

    46

    47

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

    48

{

    49

	char buf[4096];

    50

	va_list va;

    51

	int len;

    52

	char* p;

    53

    54

	va_start(va, str);

    55

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

    56

	va_end(va);

    57

	p = malloc(len + 1);

    58

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

    59

	return p;

    60

}

    61

    62

void str_validate(char *str)

    63

{

    64

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

    65

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

    66

}

    67

    68

/**

    69

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

    70

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

    71

 * @param key character to be checked

    72

 * @param afilter the filter to use

    73

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

    74

 */

    75

bool IsValidAsciiChar(byte key, CharSetFilter afilter)

    76

{

    77

	bool firsttest = false;

    78

    79

	switch (afilter) {

    80

		case CS_ALPHANUMERAL:

    81

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

    82

			break;

    83

    84

		/* We are very strict here */

    85

		case CS_NUMERAL:

    86

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

    87

    88

		case CS_ALPHA:

    89

		default:

    90

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

    91

			break;

    92

	}

    93

    94

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

    95

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

    96

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

    97

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

    98

}

    99

   100

void strtolower(char *str)

   101

{

   102

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

   103

}

   104

   105

#ifdef WIN32

   106

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

   107

{

   108

	va_list ap;

   109

	int ret;

   110

   111

	va_start(ap, format);

   112

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

   113

	va_end(ap);

   114

	return ret;

   115

}

   116

   117

#ifdef _MSC_VER

   118

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

   119

{

   120

	int ret;

   121

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

   122

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

   123

	return ret;

   124

}

   125

#endif /* _MSC_VER */

   126

   127

#endif /* WIN32 */